oxen-io/session-android
1
0
Fork 0
mirror of https://github.com/oxen-io/session-android.git synced 2023-12-14 02:53:01 +01:00
Code Issues 1 Projects Releases Wiki Activity

Remove plaintext backup import option.

Browse source 
We have our own secure backup solution built into the app now.
No need to support plaintext backups.
This commit is contained in:
Greyson Parrelli 2018-07-02 17:11:13 -07:00
parent 5d8ada0219
commit 3134837d56
7 changed files with 0 additions and 365 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
AndroidManifest.xml
View file

@ -120,9 +120,6 @@
<activity android:name=".CountrySelectionActivity"
android:configChanges="touchscreen|keyboard|keyboardHidden|orientation|screenLayout|screenSize"/>
<activity android:name=".ImportExportActivity"
android:configChanges="touchscreen|keyboard|keyboardHidden|orientation|screenLayout|screenSize"/>
<activity android:name=".InviteActivity"
android:theme="@style/TextSecure.HighlightTheme"
android:windowSoftInputMode="stateHidden"

3
res/menu/text_secure_normal.xml
View file

@ -13,9 +13,6 @@
<item android:title="@string/text_secure_normal__invite_friends"
android:id="@+id/menu_invite" />
<item android:title="@string/arrays__import_export"
android:id="@+id/menu_import_export" />
<item android:title="@string/text_secure_normal__menu_settings"
android:id="@+id/menu_settings" />

30
res/values/strings.xml
View file

@ -352,36 +352,6 @@
<!-- GroupMembersDialog -->
<string name="GroupMembersDialog_me">Me</string>
<!-- ImportExportActivity -->
<string name="ImportExportActivity_import">Import</string>
<string name="ImportExportActivity_export">Export</string>
<!-- ImportFragment -->
<string name="ImportFragment_import_system_sms_database">Import system SMS database?</string>
<string name="ImportFragment_this_will_import_messages_from_the_system">This will import
messages from the system\'s default SMS database to Signal. If you\'ve previously
imported the system\'s SMS database, importing again will result in duplicated messages.
</string>
<string name="ImportFragment_import">Import</string>
<string name="ImportFragment_cancel">Cancel</string>
<string name="ImportFragment_import_plaintext_backup">Import plaintext backup?</string>
<string name="ImportFragment_this_will_import_messages_from_a_plaintext_backup">This will import
messages from a plaintext backup. If you\'ve previously imported this backup,
importing again will result in duplicated messages.
</string>
<string name="ImportFragment_importing">Importing</string>
<string name="ImportFragment_import_plaintext_backup_elipse">Importing plaintext backup...</string>
<string name="ImportFragment_no_plaintext_backup_found">No plaintext backup found!</string>
<string name="ImportFragment_error_importing_backup">Error importing backup!</string>
<string name="ImportFragment_import_complete">Import complete!</string>
<string name="ImportExportFragment_signal_needs_the_sms_permission_in_order_to_import_sms_messages">Signal needs the SMS permission in order to import SMS messages, but it has been permanently denied. Please continue to app settings, select \"Permissions\", and enable \"SMS\".</string>
<string name="ImportExportFragment_signal_needs_the_sms_permission_in_order_to_import_sms_messages_toast">Signal needs the SMS permission in order to import SMS messages</string>
<string name="ImportExportFragment_signal_needs_the_storage_permission_in_order_to_read_from_external_storage_but_it_has_been_permanently_denied">Signal needs the Storage permission in order to read from external storage, but it has been permanently denied. Please continue to app settings, select \"Permissions\", then enable \"Storage\".</string>
<string name="ImportExportFragment_signal_needs_the_storage_permission_in_order_to_read_from_external_storage">Signal needs the Storage permission in order to read from external storage.</string>
<string name="ImportExportFragment_signal_needs_the_storage_permission_in_order_to_write_to_external_storage_but_it_has_been_permanently_denied">Signal needs the Storage permission in order to write to external storage, but it has been permanently denied. Please continue to app settings, select \"Permissions\", then enable \"Storage\".</string>
<string name="ImportExportFragment_signal_needs_the_storage_permission_in_order_to_write_to_external_storage">Signal needs the Storage permission in order to write to external storage.</string>
<!-- InputPanel -->
<string name="InputPanel_tap_and_hold_to_record_a_voice_message_release_to_send">Tap and hold to record a voice message, release to send</string>

7
src/org/thoughtcrime/securesms/ConversationListActivity.java
View file

@ -25,8 +25,6 @@ import android.net.Uri;
import android.os.AsyncTask;
import android.os.Bundle;
import android.support.v7.widget.Toolbar;
import android.text.TextUtils;
import android.util.Log;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
@ -169,7 +167,6 @@ public class ConversationListActivity extends PassphraseRequiredActionBarActivit
case R.id.menu_settings: handleDisplaySettings(); return true;
case R.id.menu_clear_passphrase: handleClearPassphrase(); return true;
case R.id.menu_mark_all_read: handleMarkAllRead(); return true;
case R.id.menu_import_export: handleImportExport(); return true;
case R.id.menu_invite: handleInvite(); return true;
case R.id.menu_help: handleHelp(); return true;
}
@ -225,10 +222,6 @@ public class ConversationListActivity extends PassphraseRequiredActionBarActivit
startService(intent);
}
private void handleImportExport() {
startActivity(new Intent(this, ImportExportActivity.class));
}
@SuppressLint("StaticFieldLeak")
private void handleMarkAllRead() {
new AsyncTask<Void, Void, Void>() {

43
src/org/thoughtcrime/securesms/ImportExportActivity.java
View file

@ -1,43 +0,0 @@
package org.thoughtcrime.securesms;
import android.os.Bundle;
import android.view.MenuItem;
import org.thoughtcrime.securesms.util.DynamicLanguage;
import org.thoughtcrime.securesms.util.DynamicTheme;
public class ImportExportActivity extends PassphraseRequiredActionBarActivity {
private DynamicTheme dynamicTheme = new DynamicTheme();
private DynamicLanguage dynamicLanguage = new DynamicLanguage();
@Override
protected void onPreCreate() {
dynamicTheme.onCreate(this);
}
@Override
protected void onCreate(Bundle savedInstanceState, boolean ready) {
assert getSupportActionBar() != null;
getSupportActionBar().setDisplayHomeAsUpEnabled(true);
initFragment(android.R.id.content, new ImportExportFragment(), dynamicLanguage.getCurrentLocale());
}
@Override
public void onResume() {
dynamicTheme.onResume(this);
super.onResume();
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
super.onOptionsItemSelected(item);
switch (item.getItemId()) {
case android.R.id.home: finish(); return true;
}
return false;
}
}

172
src/org/thoughtcrime/securesms/ImportExportFragment.java
View file

@ -1,172 +0,0 @@
package org.thoughtcrime.securesms;
import android.Manifest;
import android.annotation.SuppressLint;
import android.app.ProgressDialog;
import android.content.Context;
import android.content.Intent;
import android.os.AsyncTask;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.v4.app.Fragment;
import android.support.v7.app.AlertDialog;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Toast;
import org.thoughtcrime.securesms.database.NoExternalStorageException;
import org.thoughtcrime.securesms.database.PlaintextBackupImporter;
import org.thoughtcrime.securesms.permissions.Permissions;
import org.thoughtcrime.securesms.service.ApplicationMigrationService;
import java.io.IOException;
public class ImportExportFragment extends Fragment {
@SuppressWarnings("unused")
private static final String TAG = ImportExportFragment.class.getSimpleName();
private static final int SUCCESS = 0;
private static final int NO_SD_CARD = 1;
private static final int ERROR_IO = 2;
private ProgressDialog progressDialog;
@Override
public void onCreate(Bundle bundle) {
super.onCreate(bundle);
}
@Override
public View onCreateView(@NonNull LayoutInflater inflater, ViewGroup container, Bundle bundle) {
View layout = inflater.inflate(R.layout.import_export_fragment, container, false);
View importSmsView = layout.findViewById(R.id.import_sms );
View importPlaintextView = layout.findViewById(R.id.import_plaintext_backup);
importSmsView.setOnClickListener(v -> handleImportSms());
importPlaintextView.setOnClickListener(v -> handleImportPlaintextBackup());
return layout;
}
@Override
public void onDestroy() {
super.onDestroy();
if (progressDialog != null && progressDialog.isShowing()) {
progressDialog.dismiss();
progressDialog = null;
}
}
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
Permissions.onRequestPermissionsResult(this, requestCode, permissions, grantResults);
}
@SuppressWarnings("CodeBlock2Expr")
private void handleImportSms() {
AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
builder.setIconAttribute(R.attr.dialog_info_icon);
builder.setTitle(getActivity().getString(R.string.ImportFragment_import_system_sms_database));
builder.setMessage(getActivity().getString(R.string.ImportFragment_this_will_import_messages_from_the_system));
builder.setPositiveButton(getActivity().getString(R.string.ImportFragment_import), (dialog, which) -> {
Permissions.with(this)
.request(Manifest.permission.READ_SMS)
.ifNecessary()
.withPermanentDenialDialog(getString(R.string.ImportExportFragment_signal_needs_the_sms_permission_in_order_to_import_sms_messages))
.onAllGranted(() -> {
Intent intent = new Intent(getActivity(), ApplicationMigrationService.class);
intent.setAction(ApplicationMigrationService.MIGRATE_DATABASE);
getActivity().startService(intent);
Intent nextIntent = new Intent(getActivity(), ConversationListActivity.class);
Intent activityIntent = new Intent(getActivity(), DatabaseMigrationActivity.class);
activityIntent.putExtra("next_intent", nextIntent);
getActivity().startActivity(activityIntent);
})
.onAnyDenied(() -> Toast.makeText(getContext(), R.string.ImportExportFragment_signal_needs_the_sms_permission_in_order_to_import_sms_messages_toast, Toast.LENGTH_LONG).show())
.execute();
});
builder.setNegativeButton(getActivity().getString(R.string.ImportFragment_cancel), null);
builder.show();
}
@SuppressWarnings("CodeBlock2Expr")
@SuppressLint("InlinedApi")
private void handleImportPlaintextBackup() {
AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
builder.setIconAttribute(R.attr.dialog_alert_icon);
builder.setTitle(getActivity().getString(R.string.ImportFragment_import_plaintext_backup));
builder.setMessage(getActivity().getString(R.string.ImportFragment_this_will_import_messages_from_a_plaintext_backup));
builder.setPositiveButton(getActivity().getString(R.string.ImportFragment_import), (dialog, which) -> {
Permissions.with(ImportExportFragment.this)
.request(Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.READ_EXTERNAL_STORAGE)
.ifNecessary()
.withPermanentDenialDialog(getString(R.string.ImportExportFragment_signal_needs_the_storage_permission_in_order_to_read_from_external_storage_but_it_has_been_permanently_denied))
.onAllGranted(() -> new ImportPlaintextBackupTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR))
.onAnyDenied(() -> Toast.makeText(getContext(), R.string.ImportExportFragment_signal_needs_the_storage_permission_in_order_to_read_from_external_storage, Toast.LENGTH_LONG).show())
.execute();
});
builder.setNegativeButton(getActivity().getString(R.string.ImportFragment_cancel), null);
builder.show();
}
@SuppressLint("StaticFieldLeak")
private class ImportPlaintextBackupTask extends AsyncTask<Void, Void, Integer> {
@Override
protected void onPreExecute() {
progressDialog = ProgressDialog.show(getActivity(),
getActivity().getString(R.string.ImportFragment_importing),
getActivity().getString(R.string.ImportFragment_import_plaintext_backup_elipse),
true, false);
}
protected void onPostExecute(Integer result) {
Context context = getActivity();
if (progressDialog != null)
progressDialog.dismiss();
if (context == null)
return;
switch (result) {
case NO_SD_CARD:
Toast.makeText(context,
context.getString(R.string.ImportFragment_no_plaintext_backup_found),
Toast.LENGTH_LONG).show();
break;
case ERROR_IO:
Toast.makeText(context,
context.getString(R.string.ImportFragment_error_importing_backup),
Toast.LENGTH_LONG).show();
break;
case SUCCESS:
Toast.makeText(context,
context.getString(R.string.ImportFragment_import_complete),
Toast.LENGTH_LONG).show();
break;
}
}
@Override
protected Integer doInBackground(Void... params) {
try {
PlaintextBackupImporter.importPlaintextFromSd(getActivity());
return SUCCESS;
} catch (NoExternalStorageException e) {
Log.w("ImportFragment", e);
return NO_SD_CARD;
} catch (IOException e) {
Log.w("ImportFragment", e);
return ERROR_IO;
}
}
}
}

107
src/org/thoughtcrime/securesms/database/PlaintextBackupImporter.java
View file

@ -1,107 +0,0 @@
package org.thoughtcrime.securesms.database;
import android.content.Context;
import android.os.Environment;
import android.util.Log;
import net.sqlcipher.database.SQLiteDatabase;
import net.sqlcipher.database.SQLiteStatement;
import org.thoughtcrime.securesms.recipients.Recipient;
import org.thoughtcrime.securesms.util.StorageUtil;
import org.xmlpull.v1.XmlPullParserException;
import java.io.File;
import java.io.IOException;
import java.util.HashSet;
import java.util.Set;
public class PlaintextBackupImporter {
public static void importPlaintextFromSd(Context context)
throws NoExternalStorageException, IOException
{
Log.w("PlaintextBackupImporter", "importPlaintext()");
SmsDatabase db = DatabaseFactory.getSmsDatabase(context);
SQLiteDatabase transaction = db.beginTransaction();
try {
ThreadDatabase threads = DatabaseFactory.getThreadDatabase(context);
XmlBackup backup = new XmlBackup(getPlaintextExportFile().getAbsolutePath());
Set<Long> modifiedThreads = new HashSet<>();
XmlBackup.XmlBackupItem item;
while ((item = backup.getNext()) != null) {
Recipient recipient = Recipient.from(context, Address.fromExternal(context, item.getAddress()), false);
long threadId = threads.getThreadIdFor(recipient);
SQLiteStatement statement = db.createInsertStatement(transaction);
if (item.getAddress() == null || item.getAddress().equals("null"))
continue;
if (!isAppropriateTypeForImport(item.getType()))
continue;
addStringToStatement(statement, 1, item.getAddress());
addNullToStatement(statement, 2);
addLongToStatement(statement, 3, item.getDate());
addLongToStatement(statement, 4, item.getDate());
addLongToStatement(statement, 5, item.getProtocol());
addLongToStatement(statement, 6, item.getRead());
addLongToStatement(statement, 7, item.getStatus());
addTranslatedTypeToStatement(statement, 8, item.getType());
addNullToStatement(statement, 9);
addStringToStatement(statement, 10, item.getSubject());
addStringToStatement(statement, 11, item.getBody());
addStringToStatement(statement, 12, item.getServiceCenter());
addLongToStatement(statement, 13, threadId);
modifiedThreads.add(threadId);
statement.execute();
}
for (long threadId : modifiedThreads) {
threads.update(threadId, true);
}
Log.w("PlaintextBackupImporter", "Exited loop");
} catch (XmlPullParserException e) {
Log.w("PlaintextBackupImporter", e);
throw new IOException("XML Parsing error!");
} finally {
db.endTransaction(transaction);
}
}
private static File getPlaintextExportFile() throws NoExternalStorageException {
File backup = new File(StorageUtil.getLegacyBackupDirectory(), "SignalPlaintextBackup.xml");
File oldBackup = new File(Environment.getExternalStorageDirectory(), "TextSecurePlaintextBackup.xml");
return !backup.exists() && oldBackup.exists() ? oldBackup : backup;
}
@SuppressWarnings("SameParameterValue")
private static void addTranslatedTypeToStatement(SQLiteStatement statement, int index, int type) {
statement.bindLong(index, SmsDatabase.Types.translateFromSystemBaseType(type));
}
private static void addStringToStatement(SQLiteStatement statement, int index, String value) {
if (value == null || value.equals("null")) statement.bindNull(index);
else statement.bindString(index, value);
}
private static void addNullToStatement(SQLiteStatement statement, int index) {
statement.bindNull(index);
}
private static void addLongToStatement(SQLiteStatement statement, int index, long value) {
statement.bindLong(index, value);
}
private static boolean isAppropriateTypeForImport(long theirType) {
long ourType = SmsDatabase.Types.translateFromSystemBaseType(theirType);
return ourType == MmsSmsColumns.Types.BASE_INBOX_TYPE ||
ourType == MmsSmsColumns.Types.BASE_SENT_TYPE ||
ourType == MmsSmsColumns.Types.BASE_SENT_FAILED_TYPE;
}
}