xDrip+ v04633772025.07.16 - BackupActivity.java 源代码

package com.eveningoutpost.dexdrip.cloud.backup;

import android.app.AlertDialog;
import android.app.PendingIntent;
import android.content.DialogInterface;
import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;
import androidx.databinding.ObservableArrayMap;
import androidx.databinding.ObservableField;
import com.eveningoutpost.dexdrip.cloud.backup.BackupActivity;
import com.eveningoutpost.dexdrip.databinding.ActivityBackupPickerBinding;
import com.eveningoutpost.dexdrip.models.JoH;
import com.eveningoutpost.dexdrip.models.UserError;
import com.eveningoutpost.dexdrip.receiver.InfoContentProvider;
import com.eveningoutpost.dexdrip.ui.dialog.GenericConfirmDialog;
import com.eveningoutpost.dexdrip.utilitymodels.Inevitable;
import com.eveningoutpost.dexdrip.utilitymodels.PrefsViewImpl;
import com.eveningoutpost.dexdrip.xdrip;
import com.google.api.client.googleapis.extensions.android.gms.auth.UserRecoverableAuthIOException;
import com.google.api.services.drive.model.File;
import java.io.IOException;

public class BackupActivity extends BackupBaseActivity implements BackupStatus {
    private static final String TAG = "BackupActivity";
    private ActivityBackupPickerBinding binding;

    @Override
    protected void onCreate(Bundle bundle) {
        super.onCreate(bundle);
        ActivityBackupPickerBinding inflate = ActivityBackupPickerBinding.inflate(getLayoutInflater());
        this.binding = inflate;
        inflate.setVm(new ViewModel());
        ActivityBackupPickerBinding activityBackupPickerBinding = this.binding;
        activityBackupPickerBinding.setMap(activityBackupPickerBinding.getVm().map);
        this.binding.setPrefs(new PrefsViewImpl());
        setContentView(this.binding.getRoot());
        JoH.fixActionBar(this);
    }

    @Override
    public void onResume() {
        super.onResume();
        this.binding.getVm().readMetaData();
    }

    void selectAutomaticFile() {
        if (isSignedIn() && hasNeededPermissions()) {
            AlertDialog.Builder message = new AlertDialog.Builder(this).setTitle(2131755309).setMessage("Automatic management appears to already be active.\nDo you want to change google account used with this feature?");
            message.setNegativeButton(2131755726, new DialogInterface.OnClickListener() {
                @Override
                public final void onClick(DialogInterface dialogInterface, int i) {
                    BackupActivity.this.lambda$selectAutomaticFile$0(dialogInterface, i);
                }
            });
            message.setPositiveButton(2131755308, new DialogInterface.OnClickListener() {
                @Override
                public final void onClick(DialogInterface dialogInterface, int i) {
                    BackupActivity.this.lambda$selectAutomaticFile$1(dialogInterface, i);
                }
            });
            AlertDialog create = message.create();
            try {
                if (create.isShowing()) {
                    create.dismiss();
                }
            } catch (Exception unused) {
            }
            create.show();
            return;
        }
        selectAutomaticFileReal();
    }

    public void lambda$selectAutomaticFile$0(DialogInterface dialogInterface, int i) {
        selectAutomaticFileReal();
    }

    public void lambda$selectAutomaticFile$1(DialogInterface dialogInterface, int i) {
        this.binding.getVm().clear();
        signOut(new BackupActivity$$ExternalSyntheticLambda4(this));
    }

    public void lambda$selectAutomaticFileReal$3() {
        Inevitable.task("selectAutomaticFile", 100L, new Runnable() {
            @Override
            public final void run() {
                BackupActivity.this.lambda$selectAutomaticFileReal$2();
            }
        });
    }

    public void lambda$selectAutomaticFileReal$4() {
        checkForGooglePermissions(new Runnable() {
            @Override
            public final void run() {
                BackupActivity.this.lambda$selectAutomaticFileReal$3();
            }
        });
    }

    void selectAutomaticFileReal() {
        isSignedInSignIn(new Runnable() {
            @Override
            public final void run() {
                BackupActivity.this.lambda$selectAutomaticFileReal$4();
            }
        });
    }

    public void lambda$selectAutomaticFileReal$2() {
        try {
            String str = TAG;
            UserError.Log.d(str, "Trying to get or make file");
            File orCreateFileSync = DriveManager.getInstance().getOrCreateFileSync(Backup.getDefaultFolderName() + "/" + Backup.getDefaultFileName());
            UserError.Log.d(str, "Auto file: " + orCreateFileSync.getName() + " " + orCreateFileSync.getId());
            Backup.setXdripManagedBackupUri(orCreateFileSync.getId(), orCreateFileSync.getName());
            this.binding.getVm().readMetaData();
        } catch (IOException | NullPointerException e) {
            UserError.Log.e(TAG, "Failed creating file: " + e);
            if (e instanceof UserRecoverableAuthIOException) {
                if (JoH.ratelimit("automatic-file-real-user-exception", 30)) {
                    this.runAfterOk = new BackupActivity$$ExternalSyntheticLambda4(this);
                    startActivityForResult(((UserRecoverableAuthIOException) e).getIntent(), 4005);
                    return;
                }
                return;
            }
            status(e.getMessage());
            e.printStackTrace();
        }
    }

    public void selectFile(boolean z) {
        Intent intent = new Intent(z ? "android.intent.action.CREATE_DOCUMENT" : "android.intent.action.OPEN_DOCUMENT");
        intent.addCategory("android.intent.category.OPENABLE");
        intent.setType("application/octet-stream");
        intent.putExtra("android.intent.extra.TITLE", Backup.getDefaultFileName());
        startActivityForResult(Intent.createChooser(intent, getString(2131756251)), 2008);
    }

    public class ViewModel {
        public final ObservableField<String> status = new ObservableField<>("Ready");
        public final ObservableField<Boolean> idle = new ObservableField<>(Boolean.TRUE);
        public final ObservableField<Boolean> showAuto = new ObservableField<>(Boolean.FALSE);
        public final ObservableArrayMap<String, String> map = new ObservableArrayMap<>();
        private BackupMetaData metaData = null;

        public ViewModel() {
            clear();
        }

        public void clear() {
            String[] strArr = {"lastBackupTime", "lastAgoTime", "lastDevice", "selectedLocation", "stext"};
            for (int i = 0; i < 5; i++) {
                this.map.put(strArr[i], "");
            }
        }

        private void map(String str, String str2, String str3) {
            this.map.put(str, str3);
            this.map.put(str + "String", str2);
        }

        public void selectFile() {
            final BackupActivity backupActivity = BackupActivity.this;
            AlertDialog.Builder message = new AlertDialog.Builder(backupActivity).setTitle(2131755323).setMessage(2131756252);
            message.setNegativeButton(2131756957, new DialogInterface.OnClickListener() {
                @Override
                public final void onClick(DialogInterface dialogInterface, int i) {
                    BackupActivity.this.selectFile(false);
                }
            });
            message.setPositiveButton(2131755189, new DialogInterface.OnClickListener() {
                @Override
                public final void onClick(DialogInterface dialogInterface, int i) {
                    BackupActivity.ViewModel.this.lambda$selectFile$1(dialogInterface, i);
                }
            });
            AlertDialog create = message.create();
            try {
                if (create.isShowing()) {
                    create.dismiss();
                }
            } catch (Exception unused) {
            }
            create.show();
        }

        public void lambda$selectFile$1(DialogInterface dialogInterface, int i) {
            BackupActivity.this.selectAutomaticFile();
        }

        public void backupNow() {
            if (this.idle.get().booleanValue()) {
                if (Backup.isBackupUriSet()) {
                    this.idle.set(Boolean.FALSE);
                    Inevitable.task("do backup", 200L, new Runnable() {
                        @Override
                        public final void run() {
                            BackupActivity.ViewModel.this.lambda$backupNow$3();
                        }
                    });
                } else {
                    BackupActivity backupActivity = BackupActivity.this;
                    backupActivity.status(backupActivity.getString(2131755903));
                }
            }
        }

        public void lambda$backupNow$3() {
            try {
                BackupActivity backupActivity = BackupActivity.this;
                backupActivity.status(backupActivity.getString(2131755196));
                if (Backup.doCompleteBackup(BackupActivity.this)) {
                    BackupActivity backupActivity2 = BackupActivity.this;
                    backupActivity2.status(backupActivity2.getString(2131755439));
                } else {
                    BackupActivity backupActivity3 = BackupActivity.this;
                    backupActivity3.status(backupActivity3.getString(2131755198));
                }
                Inevitable.task("reload meta data", 2000L, new Runnable() {
                    @Override
                    public final void run() {
                        BackupActivity.ViewModel.this.lambda$backupNow$2();
                    }
                });
            } finally {
                this.idle.set(Boolean.TRUE);
            }
        }

        public void lambda$backupNow$2() {
            BackupActivity.this.binding.getVm().readMetaData();
        }

        public synchronized void restoreNow() {
            if (Backup.isBackupUriSet() && this.metaData != null) {
                Runnable runnable = new Runnable() {
                    @Override
                    public final void run() {
                        BackupActivity.ViewModel.this.lambda$restoreNow$5();
                    }
                };
                if (this.metaData.sourceDevice != null && this.metaData.sourceDevice.equals(Backup.cleanPhoneName())) {
                    runnable.run();
                } else {
                    BackupActivity backupActivity = BackupActivity.this;
                    GenericConfirmDialog.show(backupActivity, backupActivity.getString(2131755200), BackupActivity.this.getString(2131756612, this.metaData.sourceDevice), runnable);
                }
            }
            BackupActivity backupActivity2 = BackupActivity.this;
            backupActivity2.status(backupActivity2.getString(2131755933));
        }

        public void lambda$restoreNow$5() {
            BackupActivity backupActivity = BackupActivity.this;
            GenericConfirmDialog.show(backupActivity, backupActivity.getString(2131755151), BackupActivity.this.getString(2131756213), new Runnable() {
                @Override
                public final void run() {
                    BackupActivity.ViewModel.this.lambda$restoreNow$4();
                }
            });
        }

        public synchronized void lambda$restoreNow$4() {
            if (this.idle.get().booleanValue()) {
                this.idle.set(Boolean.FALSE);
                BackupActivity backupActivity = BackupActivity.this;
                backupActivity.status(backupActivity.getString(2131755161));
                Inevitable.task("do backup", 200L, new Runnable() {
                    @Override
                    public final void run() {
                        BackupActivity.ViewModel.this.lambda$restoreNowReal$6();
                    }
                });
            }
        }

        public void lambda$restoreNowReal$6() {
            try {
                BackupMetaData restoreBackFromDefaultUri = Backup.restoreBackFromDefaultUri();
                BackupActivity.this.status(restoreBackFromDefaultUri.successResult ? BackupActivity.this.getString(2131756212) : BackupActivity.this.getString(2131756209));
                if (restoreBackFromDefaultUri.exception != null) {
                    BackupActivity.this.status(BackupActivity.this.getString(2131755536) + " " + restoreBackFromDefaultUri.exception);
                }
                InfoContentProvider.ping("pref");
            } finally {
                this.idle.set(Boolean.TRUE);
            }
        }

        public void readMetaData() {
            this.showAuto.set(Boolean.valueOf(Backup.isBackupSuitableForAutomatic()));
            if (!Backup.isBackupUriSet()) {
                UserError.Log.d(BackupActivity.TAG, "No URI set to read metadata from");
            } else if (this.idle.get().booleanValue()) {
                this.idle.set(Boolean.FALSE);
                Inevitable.task("read backup meta data", 100L, new Runnable() {
                    @Override
                    public final void run() {
                        BackupActivity.ViewModel.this.lambda$readMetaData$9();
                    }
                });
            }
        }

        public void lambda$readMetaData$9() {
            String str;
            try {
                BackupActivity backupActivity = BackupActivity.this;
                backupActivity.status(backupActivity.getString(2131755318));
                BackupMetaData backupMetaDataDefaultUri = Backup.getBackupMetaDataDefaultUri();
                this.metaData = backupMetaDataDefaultUri;
                if (backupMetaDataDefaultUri.successResult) {
                    map("lastBackupTime", "Last backup time", this.metaData.getTimeStampString());
                    map("lastAgoTime", "Last backup was", this.metaData.getTimeSinceString());
                    map("lastDevice", "Backup made by", this.metaData.sourceDevice);
                    map("selectedLocation", "Selected location", this.metaData.displayName);
                    map("stext", "Backup size", BackupActivity.this.getString(2131755808, Double.valueOf(this.metaData.getSizeInMb())));
                    BackupActivity backupActivity2 = BackupActivity.this;
                    backupActivity2.status(backupActivity2.getString(2131756166));
                } else {
                    BackupActivity backupActivity3 = BackupActivity.this;
                    StringBuilder sb = new StringBuilder();
                    sb.append(BackupActivity.this.getString(2131755570));
                    if (this.metaData.exception == null || this.metaData.exception.getMessage() == null) {
                        str = "";
                    } else {
                        str = ": " + this.metaData.exception.getMessage();
                    }
                    sb.append(str);
                    backupActivity3.status(sb.toString());
                    if (this.metaData.exception != null && (this.metaData.exception instanceof UserRecoverableAuthIOException)) {
                        if (JoH.ratelimit("reask-backup-perms", 20)) {
                            BackupActivity backupActivity4 = BackupActivity.this;
                            backupActivity4.status(backupActivity4.getString(2131756000));
                            BackupActivity.this.startActivityForResult(((UserRecoverableAuthIOException) this.metaData.exception).getIntent(), 4005);
                        } else if (JoH.ratelimit("reask-try-signout", 30)) {
                            clear();
                            BackupActivity.this.signOut(new Runnable() {
                                @Override
                                public final void run() {
                                    BackupActivity.ViewModel.this.lambda$readMetaData$8();
                                }
                            });
                        }
                    }
                }
            } finally {
                this.idle.set(Boolean.TRUE);
            }
        }

        public void lambda$readMetaData$7() {
            BackupActivity.this.selectAutomaticFileReal();
        }

        public void lambda$readMetaData$8() {
            BackupActivity.this.checkForGooglePermissions(new Runnable() {
                @Override
                public final void run() {
                    BackupActivity.ViewModel.this.lambda$readMetaData$7();
                }
            });
        }
    }

    @Override
    public void status(String str) {
        this.binding.getVm().status.set(str);
        UserError.Log.d(TAG, "Status: " + str);
    }

    @Override
    public void onActivityResult(int i, int i2, Intent intent) {
        super.onActivityResult(i, i2, intent);
        if (i == 2008) {
            if (intent != null) {
                final Uri data = intent.getData();
                try {
                    UserError.Log.d(TAG, "URL: " + data);
                    if (isOnGDrive(data)) {
                        GenericConfirmDialog.show(this, getString(2131756602), getString(2131755801), new Runnable() {
                            @Override
                            public final void run() {
                                BackupActivity.this.lambda$onActivityResult$5(data);
                            }
                        });
                    } else {
                        GenericConfirmDialog.show(this, getString(2131755132), getString(2131755133), new Runnable() {
                            @Override
                            public final void run() {
                                BackupActivity.this.lambda$onActivityResult$6(data);
                            }
                        });
                    }
                } catch (Exception e) {
                    JoH.static_toast_long(getString(2131756148) + " " + e.getMessage());
                }
            } else {
                status(getString(2131755910));
            }
        }
        if (i != 6000 || i2 == -1) {
            return;
        }
        status(getString(2131755386));
    }

    private boolean isOnGDrive(Uri uri) {
        String authority = uri.getAuthority();
        authority.hashCode();
        return authority.equals("com.google.android.apps.docs.storage") || authority.equals("com.google.android.apps.docs.storage.legacy");
    }

    public void lambda$onActivityResult$6(Uri uri) {
        getContentResolver().takePersistableUriPermission(uri, 3);
        Backup.setBackupUri(uri.toString());
        status(getString(2131756264));
        this.binding.getVm().readMetaData();
    }

    static PendingIntent getStartIntent() {
        return PendingIntent.getActivity(xdrip.getAppContext(), 0, new Intent(xdrip.getAppContext(), (Class<?>) BackupActivity.class), 134217728);
    }

    static void notifySecurityError() {
        if (JoH.pratelimit("backup-security-notification-n", 43200)) {
            JoH.showNotification(xdrip.gs(2131756019), xdrip.gs(2131755199), getStartIntent(), 1029, true, true, true);
            UserError.Log.uel(TAG, "Backup file is reporting security error. Re-select it to continue to allow xDrip access.");
        }
    }
}