26f2e1bc11bd4858cdc0c88bf88fd13eb294b093
[PrivacyBrowser.git] / app / src / main / java / com / stoutner / privacybrowser / activities / ImportExportActivity.java
1 /*
2  * Copyright © 2018 Soren Stoutner <soren@stoutner.com>.
3  *
4  * This file is part of Privacy Browser <https://www.stoutner.com/privacy-browser>.
5  *
6  * Privacy Browser is free software: you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation, either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * Privacy Browser is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with Privacy Browser.  If not, see <http://www.gnu.org/licenses/>.
18  */
19
20 package com.stoutner.privacybrowser.activities;
21
22 import android.Manifest;
23 import android.app.Activity;
24 import android.app.DialogFragment;
25 import android.content.Intent;
26 import android.content.pm.PackageManager;
27 import android.net.Uri;
28 import android.os.Build;
29 import android.os.Bundle;
30 import android.os.Environment;
31 import android.provider.DocumentsContract;
32 import android.support.annotation.NonNull;
33 import android.support.design.widget.Snackbar;
34 import android.support.v4.app.ActivityCompat;
35 import android.support.v4.content.ContextCompat;
36 import android.support.v7.app.ActionBar;
37 import android.support.v7.app.AppCompatActivity;
38 import android.support.v7.widget.Toolbar;
39 import android.text.Editable;
40 import android.text.TextWatcher;
41 import android.view.View;
42 import android.view.WindowManager;
43 import android.widget.Button;
44 import android.widget.EditText;
45 import android.widget.TextView;
46
47 import com.stoutner.privacybrowser.R;
48 import com.stoutner.privacybrowser.dialogs.ImportExportStoragePermissionDialog;
49 import com.stoutner.privacybrowser.helpers.ImportExportDatabaseHelper;
50
51 import java.io.File;
52
53 public class ImportExportActivity extends AppCompatActivity implements ImportExportStoragePermissionDialog.ImportExportStoragePermissionDialogListener {
54     private final static int EXPORT_FILE_PICKER_REQUEST_CODE = 1;
55     private final static int IMPORT_FILE_PICKER_REQUEST_CODE = 2;
56     private final static int EXPORT_REQUEST_CODE = 3;
57     private final static int IMPORT_REQUEST_CODE = 4;
58
59     @Override
60     public void onCreate(Bundle savedInstanceState) {
61         // Disable screenshots if not allowed.
62         if (!MainWebViewActivity.allowScreenshots) {
63             getWindow().addFlags(WindowManager.LayoutParams.FLAG_SECURE);
64         }
65
66         // Set the activity theme.
67         if (MainWebViewActivity.darkTheme) {
68             setTheme(R.style.PrivacyBrowserDark_SecondaryActivity);
69         } else {
70             setTheme(R.style.PrivacyBrowserLight_SecondaryActivity);
71         }
72
73         // Run the default commands.
74         super.onCreate(savedInstanceState);
75
76         // Set the content view.
77         setContentView(R.layout.import_export_coordinatorlayout);
78
79         // Use the `SupportActionBar` from `android.support.v7.app.ActionBar` until the minimum API is >= 21.
80         Toolbar importExportAppBar = findViewById(R.id.import_export_toolbar);
81         setSupportActionBar(importExportAppBar);
82
83         // Display the home arrow on the support action bar.
84         ActionBar appBar = getSupportActionBar();
85         assert appBar != null;// This assert removes the incorrect warning in Android Studio on the following line that `appBar` might be null.
86         appBar.setDisplayHomeAsUpEnabled(true);
87
88         // Get handles for the views that need to be modified.
89         EditText exportFileEditText = findViewById(R.id.export_file_edittext);
90         Button exportButton = findViewById(R.id.export_button);
91         EditText importFileEditText = findViewById(R.id.import_file_edittext);
92         Button importButton = findViewById(R.id.import_button);
93         TextView storagePermissionTextView = findViewById(R.id.import_export_storage_permission_textview);
94
95         // Initially disable the buttons.
96         exportButton.setEnabled(false);
97         importButton.setEnabled(false);
98
99         // Enable the export button when the export file EditText isn't empty.
100         exportFileEditText.addTextChangedListener(new TextWatcher() {
101             @Override
102             public void beforeTextChanged(CharSequence s, int start, int count, int after) {
103                 // Do nothing.
104             }
105
106             @Override
107             public void onTextChanged(CharSequence s, int start, int before, int count) {
108                 // Do nothing.
109             }
110
111             @Override
112             public void afterTextChanged(Editable s) {
113                 exportButton.setEnabled(!exportFileEditText.getText().toString().isEmpty());
114             }
115         });
116
117         // Enable the import button when the export file EditText isn't empty.
118         importFileEditText.addTextChangedListener(new TextWatcher() {
119             @Override
120             public void beforeTextChanged(CharSequence s, int start, int count, int after) {
121                 // Do nothing.
122             }
123
124             @Override
125             public void onTextChanged(CharSequence s, int start, int before, int count) {
126                 // Do nothing.
127             }
128
129             @Override
130             public void afterTextChanged(Editable s) {
131                 importButton.setEnabled(!importFileEditText.getText().toString().isEmpty());
132             }
133         });
134
135         // Set the initial file paths.
136         if (ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED) {  // The storage permission has been granted.
137             // Create a string for the external public path.
138             String EXTERNAL_PUBLIC_PATH = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOCUMENTS) + "/" + getString(R.string.privacy_browser_settings);
139
140             // Set the default path.
141             exportFileEditText.setText(EXTERNAL_PUBLIC_PATH);
142             importFileEditText.setText(EXTERNAL_PUBLIC_PATH);
143         } else {  // The storage permission has not been granted.
144             // Create a string for the external private path.
145             String EXTERNAL_PRIVATE_PATH = getApplicationContext().getExternalFilesDir(Environment.DIRECTORY_DOCUMENTS) + "/" + getString(R.string.privacy_browser_settings);
146
147             // Set the default path.
148             exportFileEditText.setText(EXTERNAL_PRIVATE_PATH);
149             importFileEditText.setText(EXTERNAL_PRIVATE_PATH);
150         }
151
152         // Hide the storage permissions TextView on API < 23 as permissions on older devices are automatically granted.
153         if (Build.VERSION.SDK_INT < 23) {
154             storagePermissionTextView.setVisibility(View.GONE);
155         }
156     }
157
158     public void exportBrowse(View view) {
159         // Create the file picker intent.
160         Intent intent = new Intent(Intent.ACTION_CREATE_DOCUMENT);
161
162         // Set the intent MIME type to include all files.
163         intent.setType("*/*");
164
165         // Set the initial export file name.
166         intent.putExtra(Intent.EXTRA_TITLE, getString(R.string.privacy_browser_settings));
167
168         // Set the initial directory if API >= 26.
169         if (Build.VERSION.SDK_INT >= 26) {
170             intent.putExtra(DocumentsContract.EXTRA_INITIAL_URI, Environment.getExternalStorageDirectory());
171         }
172
173         // Specify that a file that can be opened is requested.
174         intent.addCategory(Intent.CATEGORY_OPENABLE);
175
176         // Launch the file picker.
177         startActivityForResult(intent, EXPORT_FILE_PICKER_REQUEST_CODE);
178     }
179
180     public void onClickExport(View view) {
181         // Check to see if the storage permission has been granted.
182         if (ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED) {  // Storage permission granted.
183             // Export the settings.
184             exportSettings();
185         } else {  // Storage permission not granted.
186             // Get a handle for the export file EditText.
187             EditText exportFileEditText = findViewById(R.id.export_file_edittext);
188
189             // Get the export file string.
190             String exportFileString = exportFileEditText.getText().toString();
191
192             // Get the external private directory `File`.
193             File externalPrivateDirectoryFile = getApplicationContext().getExternalFilesDir(null);
194
195             // Remove the lint error below that the `File` might be null.
196             assert externalPrivateDirectoryFile != null;
197
198             // Get the external private directory string.
199             String externalPrivateDirectory = externalPrivateDirectoryFile.toString();
200
201             // Check to see if the export file path is in the external private directory.
202             if (exportFileString.startsWith(externalPrivateDirectory)) {  // The export path is in the external private directory.
203                 // Export the settings.
204                 exportSettings();
205             } else {  // The export path is in a public directory.
206                 // Check if the user has previously denied the storage permission.
207                 if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)) {  // Show a dialog explaining the request first.
208                     // Instantiate the storage permission alert dialog and set the type to EXPORT_SETTINGS.
209                     DialogFragment importExportStoragePermissionDialogFragment = ImportExportStoragePermissionDialog.type(ImportExportStoragePermissionDialog.EXPORT_SETTINGS);
210
211                     // Show the storage permission alert dialog.  The permission will be requested when the dialog is closed.
212                     importExportStoragePermissionDialogFragment.show(getFragmentManager(), getString(R.string.storage_permission));
213                 } else {  // Show the permission request directly.
214                     // Request the storage permission.  The export will be run when it finishes.
215                     ActivityCompat.requestPermissions(this, new String[] {Manifest.permission.WRITE_EXTERNAL_STORAGE}, EXPORT_REQUEST_CODE);
216                 }
217             }
218         }
219     }
220
221     public void importBrowse(View view) {
222         // Create the file picker intent.
223         Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT);
224
225         // Set the intent MIME type to include all files.
226         intent.setType("*/*");
227
228         // Set the initial directory if API >= 26.
229         if (Build.VERSION.SDK_INT >= 26) {
230             intent.putExtra(DocumentsContract.EXTRA_INITIAL_URI, Environment.getExternalStorageDirectory());
231         }
232
233         // Specify that a file that can be opened is requested.
234         intent.addCategory(Intent.CATEGORY_OPENABLE);
235
236         // Launch the file picker.
237         startActivityForResult(intent, IMPORT_FILE_PICKER_REQUEST_CODE);
238     }
239
240     public void onClickImport(View view) {
241         // Check to see if the storage permission has been granted.
242         if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED) {  // Storage permission granted.
243             // Import the settings.
244             importSettings();
245         } else {  // Storage permission not granted.
246             // Get a handle for the import file EditText.
247             EditText importFileEditText = findViewById(R.id.import_file_edittext);
248
249             // Get the import file string.
250             String importFileString = importFileEditText.getText().toString();
251
252             // Get the external private directory `File`.
253             File externalPrivateDirectoryFile = getApplicationContext().getExternalFilesDir(null);
254
255             // Remove the lint error below that `File` might be null.
256             assert externalPrivateDirectoryFile != null;
257
258             // Get the external private directory string.
259             String externalPrivateDirectory = externalPrivateDirectoryFile.toString();
260
261             // Check to see if the import file path is in the external private directory.
262             if (importFileString.startsWith(externalPrivateDirectory)) {  // The import path is in the external private directory.
263                 // Import the settings.
264                 importSettings();
265             } else {  // The import path is in a public directory.
266                 // Check if the user has previously denied the storage permission.
267                 if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.READ_EXTERNAL_STORAGE)) {  // Show a dialog explaining the request first.
268                     // Instantiate the storage permission alert dialog and set the type to IMPORT_SETTINGS.
269                     DialogFragment importExportStoragePermissionDialogFragment = ImportExportStoragePermissionDialog.type(ImportExportStoragePermissionDialog.IMPORT_SETTINGS);
270
271                     // Show the storage permission alert dialog.  The permission will be requested when the dialog is closed.
272                     importExportStoragePermissionDialogFragment.show(getFragmentManager(), getString(R.string.storage_permission));
273                 } else {  // Show the permission request directly.
274                     // Request the storage permission.  The export will be run when it finishes.
275                     ActivityCompat.requestPermissions(this, new String[] {Manifest.permission.READ_EXTERNAL_STORAGE}, IMPORT_REQUEST_CODE);
276                 }
277             }
278         }
279     }
280
281     @Override
282     public void onActivityResult(int requestCode, int resultCode, Intent data) {
283         // Don't do anything if the user pressed back from the file picker.
284         if (resultCode == Activity.RESULT_OK) {
285             // Run the commands for the specific request code.
286             switch (requestCode) {
287                 case EXPORT_FILE_PICKER_REQUEST_CODE:
288                     // Get a handle for the export file EditText.
289                     EditText exportFileEditText = findViewById(R.id.export_file_edittext);
290
291                     // Get the selected export file.
292                     Uri exportUri = data.getData();
293
294                     // Remove the lint warning that the export URI might be null.
295                     assert exportUri != null;
296
297                     // Get the raw export path.
298                     String rawExportPath = exportUri.getPath();
299
300                     // Remove the warning that the raw export path might be null.
301                     assert rawExportPath != null;
302
303                     // Check to see if the rawExportPath includes a valid storage location.
304                     if (rawExportPath.contains(":")) {  // The path is valid.
305                         // Split the path into the initial content uri and the path information.
306                         String exportContentPath = rawExportPath.substring(0, rawExportPath.indexOf(":"));
307                         String exportFilePath = rawExportPath.substring(rawExportPath.indexOf(":") + 1);
308
309                         // Create the export path string.
310                         String exportPath;
311
312                         // Construct the export path.
313                         switch (exportContentPath) {
314                             // The documents home has a special content path.
315                             case "/document/home":
316                                 exportPath = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOCUMENTS) + "/" + exportFilePath;
317                                 break;
318
319                             // Everything else for the primary user should be in `/document/primary`.
320                             case "/document/primary":
321                                 exportPath = Environment.getExternalStorageDirectory() + "/" + exportFilePath;
322                                 break;
323
324                             // Just in case, catch everything else and place it in the external storage directory.
325                             default:
326                                 exportPath = Environment.getExternalStorageDirectory() + "/" + exportFilePath;
327                                 break;
328                         }
329
330                         // Set the export file URI as the text for the export file EditText.
331                         exportFileEditText.setText(exportPath);
332                     } else {  // The path is invalid.
333                         Snackbar.make(exportFileEditText, rawExportPath + " + " + getString(R.string.invalid_location), Snackbar.LENGTH_INDEFINITE).show();
334                     }
335                     break;
336
337                 case IMPORT_FILE_PICKER_REQUEST_CODE:
338                     // Get a handle for the import file EditText.
339                     EditText importFileEditText = findViewById(R.id.import_file_edittext);
340
341                     // Get the selected import file.
342                     Uri importUri = data.getData();
343
344                     // Remove the lint warning that the import URI might be null.
345                     assert importUri != null;
346
347                     // Get the raw import path.
348                     String rawImportPath = importUri.getPath();
349
350                     // Remove the warning that the raw import path might be null.
351                     assert rawImportPath != null;
352
353                     // Check to see if the rawExportPath includes a valid storage location.
354                     if (rawImportPath.contains(":")) {  // The path is valid.
355                         // Split the path into the initial content uri and the path information.
356                         String importContentPath = rawImportPath.substring(0, rawImportPath.indexOf(":"));
357                         String importFilePath = rawImportPath.substring(rawImportPath.indexOf(":") + 1);
358
359                         // Create the export path string.
360                         String importPath;
361
362                         // Construct the export path.
363                         switch (importContentPath) {
364                             // The documents folder has a special content path.
365                             case "/document/home":
366                                 importPath = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOCUMENTS) + "/" + importFilePath;
367                                 break;
368
369                             // Everything else for the primary user should be in `/document/primary`.
370                             case "/document/primary":
371                                 importPath = Environment.getExternalStorageDirectory() + "/" + importFilePath;
372                                 break;
373
374                             // Just in case, catch everything else and place it in the external storage directory.
375                             default:
376                                 importPath = Environment.getExternalStorageDirectory() + "/" + importFilePath;
377                                 break;
378                         }
379
380                         // Set the export file URI as the text for the export file EditText.
381                         importFileEditText.setText(importPath);
382                     } else {  // The path is invalid.
383                         Snackbar.make(importFileEditText, rawImportPath + " + " + getString(R.string.invalid_location), Snackbar.LENGTH_INDEFINITE).show();
384                     }
385                     break;
386             }
387         }
388     }
389
390     @Override
391     public void onCloseImportExportStoragePermissionDialog(int type) {
392         // Request the storage permission based on the button that was pressed.
393         switch (type) {
394             case ImportExportStoragePermissionDialog.EXPORT_SETTINGS:
395                 // Request the storage permission.  The export will be run when it finishes.
396                 ActivityCompat.requestPermissions(this, new String[] {Manifest.permission.WRITE_EXTERNAL_STORAGE}, EXPORT_REQUEST_CODE);
397                 break;
398
399             case ImportExportStoragePermissionDialog.IMPORT_SETTINGS:
400                 // Request the storage permission.  The import will be run when it finishes.
401                 ActivityCompat.requestPermissions(this, new String[] {Manifest.permission.READ_EXTERNAL_STORAGE}, IMPORT_REQUEST_CODE);
402                 break;
403         }
404     }
405
406     @Override
407     public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
408         switch (requestCode) {
409             case EXPORT_REQUEST_CODE:
410                 // Check to see if the storage permission was granted.  If the dialog was canceled the grant results will be empty.
411                 if ((grantResults.length > 0) && (grantResults[0] == PackageManager.PERMISSION_GRANTED)) {  // The storage permission was granted.
412                     // Export the settings.
413                     exportSettings();
414                 } else {  // The storage permission was not granted.
415                     // Get a handle for the export file EditText.
416                     EditText exportFileEditText = findViewById(R.id.export_file_edittext);
417
418                     // Display an error snackbar.
419                     Snackbar.make(exportFileEditText, getString(R.string.cannot_export), Snackbar.LENGTH_LONG).show();
420                 }
421                 break;
422
423             case IMPORT_REQUEST_CODE:
424                 // Check to see if the storage permission was granted.  If the dialog was canceled the grant results will be empty.
425                 if ((grantResults.length > 0) && (grantResults[0] == PackageManager.PERMISSION_GRANTED)) {  // The storage permission was granted.
426                     // Import the settings.
427                     importSettings();
428                 } else {  // The storage permission was not granted.
429                     // Get a handle for the import file EditText.
430                     EditText importFileEditText = findViewById(R.id.import_file_edittext);
431
432                     // Display an error snackbar.
433                     Snackbar.make(importFileEditText, getString(R.string.cannot_import), Snackbar.LENGTH_LONG).show();
434                 }
435                 break;
436         }
437     }
438
439     private void exportSettings() {
440         // Get a handle for the export file EditText.
441         EditText exportFileEditText = findViewById(R.id.export_file_edittext);
442
443         // Get the export file string.
444         String exportFileString = exportFileEditText.getText().toString();
445
446         // Set the export file.
447         File exportFile = new File(exportFileString);
448
449         // Instantiate the import export database helper.
450         ImportExportDatabaseHelper importExportDatabaseHelper = new ImportExportDatabaseHelper();
451
452         // Export the unencrypted file.
453         String exportStatus = importExportDatabaseHelper.exportUnencrypted(exportFile, getApplicationContext());
454
455         // Show a disposition snackbar.
456         if (exportStatus.equals(ImportExportDatabaseHelper.EXPORT_SUCCESSFUL)) {
457             Snackbar.make(exportFileEditText, getString(R.string.export_successful), Snackbar.LENGTH_SHORT).show();
458         } else {
459             Snackbar.make(exportFileEditText, getString(R.string.export_failed) + "  " + exportStatus, Snackbar.LENGTH_INDEFINITE).show();
460         }
461     }
462
463     private void importSettings() {
464         // Get a handle for the import file EditText.
465         EditText importFileEditText = findViewById(R.id.import_file_edittext);
466
467         // Get the import file string.
468         String importFileString = importFileEditText.getText().toString();
469
470         // Set the import file.
471         File importFile = new File(importFileString);
472
473         // Instantiate the import export database helper.
474         ImportExportDatabaseHelper importExportDatabaseHelper = new ImportExportDatabaseHelper();
475
476         // Import the unencrypted file.
477         String importStatus = importExportDatabaseHelper.importUnencrypted(importFile, getApplicationContext());
478
479         // Respond to the import disposition.
480         if (importStatus.equals(ImportExportDatabaseHelper.IMPORT_SUCCESSFUL)) {  // The import was successful.
481             // Create an intent to restart Privacy Browser.
482             Intent restartIntent = getParentActivityIntent();
483
484             // Assert that the intent is not null to remove the lint error below.
485             assert restartIntent != null;
486
487             // `Intent.FLAG_ACTIVITY_CLEAR_TASK` removes all activities from the stack.  It requires `Intent.FLAG_ACTIVITY_NEW_TASK`.
488             restartIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
489
490             // Make it so.
491             startActivity(restartIntent);
492         } else {  // The import was not successful.
493             // Display a snack bar with the import error.
494             Snackbar.make(importFileEditText, getString(R.string.import_failed) + "  " + importStatus, Snackbar.LENGTH_INDEFINITE).show();
495         }
496     }
497 }