mirror/Android
1
0
Fork 0
mirror of https://github.com/CatimaLoyalty/Android.git synced 2026-04-04 07:41:40 -04:00
Code Issues Packages Projects Releases Wiki Activity

Include basic error details on import failure

Browse Source
This commit is contained in:
Sylvia van Os
2022-02-05 16:54:40 +01:00
parent a20f8b58f8
commit 6a6a8fff2b
8 changed files with 109 additions and 83 deletions
Download Patch File Download Diff File Expand all files Collapse all files

72
app/src/main/java/protect/card_locker/ImportExportActivity.java
View File

@@ -35,6 +35,7 @@ import java.util.List;
import protect.card_locker.async.TaskHandler;
import protect.card_locker.importexport.DataFormat;
import protect.card_locker.importexport.ImportExportResult;
import protect.card_locker.importexport.ImportExportResultType;
public class ImportExportActivity extends CatimaAppCompatActivity {
private static final String TAG = "Catima";
@@ -97,7 +98,7 @@ public class ImportExportActivity extends CatimaAppCompatActivity {
startExport(writer, uri, exportPassword.toCharArray(), true);
} catch (IOException e) {
Log.e(TAG, "Failed to export file: " + result.toString(), e);
onExportComplete(ImportExportResult.GenericFailure, uri);
onExportComplete(new ImportExportResult(ImportExportResultType.GenericFailure, result.toString()), uri);
}
});
@@ -175,7 +176,7 @@ public class ImportExportActivity extends CatimaAppCompatActivity {
startImport(reader, uri, importDataFormat, password, true);
} catch (IOException e) {
Log.e(TAG, "Failed to import file: " + uri.toString(), e);
onImportComplete(ImportExportResult.GenericFailure, uri, importDataFormat);
onImportComplete(new ImportExportResult(ImportExportResultType.GenericFailure, e.toString()), uri, importDataFormat);
}
}
@@ -357,56 +358,51 @@ public class ImportExportActivity extends CatimaAppCompatActivity {
builder.show();
}
private String buildResultDialogMessage(ImportExportResult result, boolean isImport) {
int messageId;
if (result.resultType() == ImportExportResultType.Success) {
messageId = isImport ? R.string.importSuccessful : R.string.exportSuccessful;
} else {
messageId = isImport ? R.string.importFailed : R.string.exportFailed;
}
StringBuilder messageBuilder = new StringBuilder(getResources().getString(messageId));
if (result.developerDetails() != null) {
messageBuilder.append("\n\n");
messageBuilder.append(getResources().getString(R.string.include_if_asking_support));
messageBuilder.append("\n\n");
messageBuilder.append(result.developerDetails());
}
return messageBuilder.toString();
}
private void onImportComplete(ImportExportResult result, Uri path, DataFormat dataFormat) {
if (result == ImportExportResult.BadPassword) {
ImportExportResultType resultType = result.resultType();
if (resultType == ImportExportResultType.BadPassword) {
retryWithPassword(dataFormat, path);
return;
}
AlertDialog.Builder builder = new AlertDialog.Builder(this);
int messageId;
if (result == ImportExportResult.Success) {
builder.setTitle(R.string.importSuccessfulTitle);
messageId = R.string.importSuccessful;
} else {
builder.setTitle(R.string.importFailedTitle);
messageId = R.string.importFailed;
}
final String message = getResources().getString(messageId);
builder.setMessage(message);
builder.setNeutralButton(R.string.ok, new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
dialog.dismiss();
}
});
builder.setTitle(resultType == ImportExportResultType.Success ? R.string.importSuccessfulTitle : R.string.importFailedTitle);
builder.setMessage(buildResultDialogMessage(result, true));
builder.setNeutralButton(R.string.ok, (dialog, which) -> dialog.dismiss());
builder.create().show();
}
private void onExportComplete(ImportExportResult result, final Uri path) {
ImportExportResultType resultType = result.resultType();
AlertDialog.Builder builder = new AlertDialog.Builder(this);
int messageId;
if (result == ImportExportResult.Success) {
builder.setTitle(R.string.exportSuccessfulTitle);
messageId = R.string.exportSuccessful;
} else {
builder.setTitle(R.string.exportFailedTitle);
messageId = R.string.exportFailed;
}
final String message = getResources().getString(messageId);
builder.setMessage(message);
builder.setTitle(resultType == ImportExportResultType.Success ? R.string.exportSuccessfulTitle : R.string.exportFailedTitle);
builder.setMessage(buildResultDialogMessage(result, false));
builder.setNeutralButton(R.string.ok, (dialog, which) -> dialog.dismiss());
if (result == ImportExportResult.Success) {
if (resultType == ImportExportResultType.Success) {
final CharSequence sendLabel = ImportExportActivity.this.getResources().getText(R.string.sendLabel);
builder.setPositiveButton(sendLabel, (dialog, which) -> {

6
app/src/main/java/protect/card_locker/ImportExportTask.java
View File

@@ -16,6 +16,7 @@ import java.nio.charset.StandardCharsets;
import protect.card_locker.async.CompatCallable;
import protect.card_locker.importexport.DataFormat;
import protect.card_locker.importexport.ImportExportResult;
import protect.card_locker.importexport.ImportExportResultType;
import protect.card_locker.importexport.MultiFormatExporter;
import protect.card_locker.importexport.MultiFormatImporter;
@@ -63,19 +64,20 @@ public class ImportExportTask implements CompatCallable<ImportExportResult> {
private ImportExportResult performImport(Context context, InputStream stream, SQLiteDatabase database, char[] password) {
ImportExportResult importResult = MultiFormatImporter.importData(context, database, stream, format, password);
Log.i(TAG, "Import result: " + importResult.name());
Log.i(TAG, "Import result: " + importResult);
return importResult;
}
private ImportExportResult performExport(Context context, OutputStream stream, SQLiteDatabase database, char[] password) {
ImportExportResult result = ImportExportResult.GenericFailure;
ImportExportResult result;
try {
OutputStreamWriter writer = new OutputStreamWriter(stream, StandardCharsets.UTF_8);
result = MultiFormatExporter.exportData(context, database, stream, format, password);
writer.close();
} catch (IOException e) {
result = new ImportExportResult(ImportExportResultType.GenericFailure, e.toString());
Log.e(TAG, "Unable to export file", e);
}

24
app/src/main/java/protect/card_locker/importexport/ImportExportResult.java
View File

@@ -1,7 +1,23 @@
package protect.card_locker.importexport;
public enum ImportExportResult {
Success,
GenericFailure,
BadPassword;
public class ImportExportResult {
private ImportExportResultType resultType;
private String developerDetails;
public ImportExportResult(ImportExportResultType resultType) {
this(resultType, null);
}
public ImportExportResult(ImportExportResultType resultType, String developerDetails) {
this.resultType = resultType;
this.developerDetails = developerDetails;
}
public ImportExportResultType resultType() {
return resultType;
}
public String developerDetails() {
return developerDetails;
}
}

7
app/src/main/java/protect/card_locker/importexport/ImportExportResultType.java Normal file
View File

@@ -0,0 +1,7 @@
package protect.card_locker.importexport;
public enum ImportExportResultType {
Success,
GenericFailure,
BadPassword;
}

16
app/src/main/java/protect/card_locker/importexport/MultiFormatExporter.java
View File

@@ -32,20 +32,20 @@ public class MultiFormatExporter {
break;
}
String error;
if (exporter != null) {
try {
exporter.exportData(context, database, output, password);
return ImportExportResult.Success;
} catch (IOException e) {
Log.e(TAG, "Failed to export data", e);
} catch (InterruptedException e) {
return new ImportExportResult(ImportExportResultType.Success);
} catch (Exception e) {
Log.e(TAG, "Failed to export data", e);
error = e.toString();
}
return ImportExportResult.GenericFailure;
} else {
Log.e(TAG, "Unsupported data format exported: " + format.name());
return ImportExportResult.GenericFailure;
error = "Unsupported data format exported: " + format.name();
Log.e(TAG, error);
}
return new ImportExportResult(ImportExportResultType.GenericFailure, error);
}
}

11
app/src/main/java/protect/card_locker/importexport/MultiFormatImporter.java
View File

@@ -46,23 +46,26 @@ public class MultiFormatImporter {
break;
}
String error = null;
if (importer != null) {
database.beginTransaction();
try {
importer.importData(context, database, input, password);
database.setTransactionSuccessful();
return ImportExportResult.Success;
return new ImportExportResult(ImportExportResultType.Success);
} catch (ZipException e) {
return ImportExportResult.BadPassword;
return new ImportExportResult(ImportExportResultType.BadPassword);
} catch (IOException | FormatException | InterruptedException | JSONException | ParseException | NullPointerException e) {
Log.e(TAG, "Failed to import data", e);
error = e.toString();
} finally {
database.endTransaction();
}
} else {
Log.e(TAG, "Unsupported data format imported: " + format.name());
error = "Unsupported data format imported: " + format.name();
Log.e(TAG, error);
}
return ImportExportResult.GenericFailure;
return new ImportExportResult(ImportExportResultType.GenericFailure, error);
}
}