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

package com.eveningoutpost.dexdrip.utils;

import android.app.Activity;
import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.os.Bundle;
import android.os.Environment;
import android.os.Process;
import android.util.Log;
import android.view.View;
import android.widget.Toast;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;
import com.eveningoutpost.dexdrip.BaseAppCompatActivity;
import com.eveningoutpost.dexdrip.GcmActivity;
import com.eveningoutpost.dexdrip.Home;
import com.eveningoutpost.dexdrip.models.AlertType;
import com.eveningoutpost.dexdrip.models.JoH;
import com.eveningoutpost.dexdrip.receiver.InfoContentProvider;
import com.eveningoutpost.dexdrip.utilitymodels.Pref;
import com.eveningoutpost.dexdrip.xdrip;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.ArrayList;
import java.util.List;

public class SdcardImportExport extends BaseAppCompatActivity {
    public static final String PREFERENCES_FILE = "shared_prefs/" + xdrip.getAppContext().getString(2131755767) + "_preferences.xml";
    private static boolean backupDismissed;

    public static boolean deleteFolder(File file, boolean z) {
        try {
            Log.d("jamorham sdcard", "deleteFolder called with: " + file.toString());
            if (file.exists()) {
                File[] listFiles = file.listFiles();
                if (listFiles == null) {
                    return true;
                }
                for (File file2 : listFiles) {
                    if (z && file2.isDirectory()) {
                        deleteFolder(file2, z);
                    } else {
                        Log.d("jamorham sdcard", "Calling delete for file: " + file2.getName());
                        file2.delete();
                    }
                }
            }
            return file.delete();
        } catch (Exception e) {
            Log.e("jamorham sdcard", "Got exception in delete: " + e.toString());
            return false;
        }
    }

    @Override
    protected void onCreate(Bundle bundle) {
        super.onCreate(bundle);
        setContentView(2131492937);
        JoH.fixActionBar(this);
        if (getIntent().getStringExtra("backup") != null) {
            savePreferencesToSD(null);
            finish();
        }
    }

    private boolean checkPermissions() {
        return checkPermissions(this, true, 104);
    }

    public static boolean checkPermissions(Activity activity, boolean z, int i) {
        if (ContextCompat.checkSelfPermission(activity, "android.permission.WRITE_EXTERNAL_STORAGE") == 0) {
            return true;
        }
        if (!z) {
            return false;
        }
        ActivityCompat.requestPermissions(activity, new String[]{"android.permission.WRITE_EXTERNAL_STORAGE"}, i);
        return false;
    }

    public void savePreferencesToSD(View view) {
        if (savePreferencesToSD()) {
            toast(getString(2131756142));
        } else if (checkPermissions(this, false, 104)) {
            toast(getString(2131755387));
        }
    }

    public static void hardReset() {
        JoH.wakeUpIntent(xdrip.getAppContext(), 4000L, Home.getHomePendingIntent());
        hardReset_orig();
    }

    public static void hardReset_orig() {
        GcmActivity.last_sync_request = 0L;
        Process.killProcess(Process.myPid());
    }

    public static void forceGMSreset() {
        Context appContext = xdrip.getAppContext();
        for (String str : "shared_prefs/com.google.android.gms.measurement.prefs.xml,shared_prefs/com.google.android.gms.appid.xml,databases/google_app_measurement.db,databases/google_app_measurement.db-journal".split(",")) {
            if (deleteFolder(new File(appContext.getFilesDir().getParent() + "/" + str), false)) {
                Log.d("jamorham sdcard", "Successfully deleted: " + str);
            } else {
                Log.e("jamorham sdcard", "Error deleting: " + str);
            }
        }
        hardReset();
    }

    public static void deletePersistentStore() {
        if (deleteFolder(new File(xdrip.getAppContext().getFilesDir().getParent() + "/shared_prefs/persist_internal_store.xml"), false)) {
            Log.d("jamorham sdcard", "Successfully deleted: shared_prefs/persist_internal_store.xml");
        } else {
            Log.e("jamorham sdcard", "Error deleting: shared_prefs/persist_internal_store.xml");
        }
        hardReset();
    }

    public void loadPreferencesToSD(View view) {
        if (checkPermissions()) {
            if (loadPreferencesFromSD()) {
                JoH.static_toast_short(getString(2131755765));
                hardReset();
            } else {
                JoH.static_toast_short(getString(2131755385));
            }
        }
    }

    public static void storePreferencesFromBytes(byte[] bArr, Context context) {
        if (dataFromBytes(bArr, PREFERENCES_FILE, context)) {
            InfoContentProvider.ping("pref");
            Log.i("jamorham sdcard", "Restarting as new preferences loaded from bytes");
            hardReset();
            return;
        }
        Log.e("jamorham sdcard", "Failed to write preferences from bytes");
    }

    public void deletePreferencesOnSD(View view) {
        if (!isExternalStorageWritable()) {
            toast(getString(2131755558));
        } else if (deleteFolder(new File(getCustomSDcardpath()), false)) {
            toast(getString(2131756433));
        } else {
            toast(getString(2131755425));
        }
    }

    public static byte[] getPreferencesFileAsBytes(Context context) {
        return dataToBytes(PREFERENCES_FILE, context);
    }

    public boolean savePreferencesToSD() {
        if (isExternalStorageWritable()) {
            boolean settings = AlertType.toSettings(getApplicationContext());
            if (settings) {
                settings = dataToSDcopy(PREFERENCES_FILE);
            }
            Pref.setString("saved_alerts", "");
            return settings;
        }
        toast(getString(2131756238));
        return false;
    }

    public boolean loadPreferencesFromSD() {
        if (isExternalStorageWritable()) {
            return dataFromSDcopy(PREFERENCES_FILE);
        }
        toast(getString(2131756237));
        return false;
    }

    private boolean isExternalStorageWritable() {
        String externalStorageState = Environment.getExternalStorageState();
        checkPermissions();
        return "mounted".equals(externalStorageState);
    }

    private static String getCustomSDcardpath() {
        return Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS) + "/xDrip-export";
    }

    private static String getxDripCustomSDcardpath() {
        return FileUtils.getExternalDir() + "/settingsExport";
    }

    private static byte[] dataToBytes(String str, Context context) {
        try {
            return directReadFile(new File(context.getFilesDir().getParent() + "/" + str));
        } catch (Exception e) {
            Log.e("jamorham sdcard", "Got exception in datatoBytes: " + e.toString());
            return null;
        }
    }

    private boolean dataToSDcopy(String str) {
        File file = new File(getFilesDir().getParent() + "/" + str);
        String customSDcardpath = getCustomSDcardpath();
        try {
            new File(customSDcardpath).mkdirs();
            if (!directCopyFile(file, new File(customSDcardpath, file.getName()))) {
                return false;
            }
            Log.i("jamorham sdcard", "Copied success: " + str);
            return true;
        } catch (Exception unused) {
            Log.e("jamorham sdcard", "Error making directory: " + customSDcardpath);
            return false;
        }
    }

    public static boolean handleBackup(final Activity activity) {
        List<String> findAnyBackups = findAnyBackups(activity);
        if (backupDismissed || findAnyBackups == null || findAnyBackups.size() <= 0) {
            return false;
        }
        Log.e("jamorham sdcard", "Found: " + findAnyBackups.size() + " backup files");
        AlertDialog.Builder builder = new AlertDialog.Builder(activity);
        builder.setTitle(xdrip.gs(2131755197));
        builder.setMessage(xdrip.gs(2131755720));
        builder.setNegativeButton(2131755900, new DialogInterface.OnClickListener() {
            @Override
            public final void onClick(DialogInterface dialogInterface, int i) {
                SdcardImportExport.lambda$handleBackup$0(dialogInterface, i);
            }
        });
        builder.setPositiveButton(xdrip.gs(2131756211), new DialogInterface.OnClickListener() {
            @Override
            public final void onClick(DialogInterface dialogInterface, int i) {
                SdcardImportExport.lambda$handleBackup$1(activity, dialogInterface, i);
            }
        });
        builder.create().show();
        return true;
    }

    public static void lambda$handleBackup$0(DialogInterface dialogInterface, int i) {
        backupDismissed = true;
        dialogInterface.dismiss();
    }

    public static void lambda$handleBackup$1(Activity activity, DialogInterface dialogInterface, int i) {
        if (checkPermissions(activity, true, 9104)) {
            restoreSettingsNow(activity);
        } else {
            handleBackup(activity);
        }
        dialogInterface.dismiss();
    }

    public static void restoreSettingsNow(Activity activity) {
        List<String> findAnyBackups = findAnyBackups(activity);
        if (findAnyBackups == null || findAnyBackups.size() <= 0) {
            return;
        }
        JoH.static_toast_long("Restoring Settings");
        if (copyPreferencesFileBack(activity, findAnyBackups.get(0))) {
            Log.e("jamorham sdcard", "Restoring preferences succeeded from first match: " + findAnyBackups.get(0));
            InfoContentProvider.ping("pref");
            hardReset();
            return;
        }
        JoH.static_toast_long("Couldn't restore preferences from: " + findAnyBackups.get(0));
    }

    private static List<String> findAnyBackups(Context context) {
        ArrayList arrayList = new ArrayList();
        File file = new File(context.getFilesDir().getParent() + "/" + PREFERENCES_FILE);
        File file2 = new File(getCustomSDcardpath() + "/" + file.getName());
        File file3 = new File(getxDripCustomSDcardpath() + "/" + file.getName());
        if (file2.exists()) {
            arrayList.add(file2.getAbsolutePath());
        }
        if (file3.exists()) {
            arrayList.add(file3.getAbsolutePath());
        }
        for (String str : listAllDirectories("/storage", 2)) {
            StringBuilder sb = new StringBuilder();
            sb.append(str);
            sb.append("/");
            sb.append("xDrip-export");
            sb.append("/");
            String str2 = PREFERENCES_FILE;
            sb.append(str2);
            String sb2 = sb.toString();
            String str3 = str + "/" + str2;
            if (new File(sb2).exists()) {
                arrayList.add(sb2);
            }
            if (new File(str3).exists()) {
                arrayList.add(str3);
            }
        }
        return arrayList;
    }

    public static List<String> listAllDirectories(String str, int i) {
        ArrayList arrayList = new ArrayList();
        Log.d("jamorham sdcard", "Processing scan for directory: " + str + " depth: " + i);
        try {
            File[] listFiles = new File(str).listFiles();
            int i2 = i - 1;
            if (listFiles != null) {
                for (File file : listFiles) {
                    if (file.isDirectory()) {
                        arrayList.add(file.getAbsolutePath());
                        if (i2 > 0) {
                            arrayList.addAll(listAllDirectories(file.getAbsolutePath(), i2));
                        }
                    }
                }
            }
        } catch (Exception e) {
            Log.d("jamorham sdcard", "Got exception walking directories: " + e);
        }
        return arrayList;
    }

    private static boolean copyPreferencesFileBack(Context context, String str) {
        File file = new File(context.getFilesDir().getParent() + "/" + PREFERENCES_FILE);
        File file2 = new File(str);
        if (file2.exists()) {
            try {
                file.mkdirs();
                if (directCopyFile(file2, file)) {
                    Log.i("jamorham sdcard", "Copied success: " + str);
                    return true;
                }
            } catch (Exception unused) {
                Log.e("jamorham sdcard", "Error making directory: " + file.toString());
                return false;
            }
        } else {
            Log.e("jamorham sdcard", "Weirdly " + str + " doesn't seem to exist or failed to copy somehow! " + file.getAbsolutePath());
        }
        return false;
    }

    private boolean dataFromSDcopy(String str) {
        File file = new File(getFilesDir().getParent() + "/" + str);
        File file2 = new File(getCustomSDcardpath() + "/" + file.getName());
        File file3 = new File(getxDripCustomSDcardpath() + "/" + file.getName());
        Log.d("jamorham sdcard", file2.toString() + " or " + file3.toString() + " to: " + file.toString());
        if (file2.exists() && file3.exists()) {
            toast(getString(2131757020));
        } else if (file3.exists()) {
            toast(getString(2131755766));
            file2 = file3;
        }
        try {
            file.mkdirs();
            if (!directCopyFile(file2, file)) {
                return false;
            }
            Log.i("jamorham sdcard", "Copied success: " + str);
            return true;
        } catch (Exception unused) {
            Log.e("jamorham sdcard", "Error making directory: " + file.toString());
            return false;
        }
    }

    private static boolean directCopyFile(File file, File file2) {
        Log.i("jamorham sdcard", "Attempt to copy: " + file.toString() + " to " + file2.toString());
        try {
            FileInputStream fileInputStream = new FileInputStream(file);
            FileOutputStream fileOutputStream = new FileOutputStream(file2);
            byte[] bArr = new byte[8192];
            while (true) {
                int read = fileInputStream.read(bArr);
                if (read != -1) {
                    fileOutputStream.write(bArr, 0, read);
                } else {
                    fileInputStream.close();
                    fileOutputStream.flush();
                    fileOutputStream.close();
                    return true;
                }
            }
        } catch (Exception e) {
            Log.e("jamorham sdcard", e.getMessage());
            return false;
        }
    }

    private static byte[] directReadFile(File file) {
        Log.i("jamorham sdcard", "Attempt to read: " + file.toString());
        try {
            FileInputStream fileInputStream = new FileInputStream(file);
            int length = (int) file.length();
            byte[] bArr = new byte[length];
            fileInputStream.read(bArr);
            fileInputStream.close();
            Log.d("jamorham sdcard", "Read file size: " + length);
            return bArr;
        } catch (Exception e) {
            Log.e("jamorham sdcard", e.getMessage());
            return null;
        }
    }

    private static boolean dataFromBytes(byte[] bArr, String str, Context context) {
        if (bArr == null || bArr.length == 0) {
            Log.e("jamorham sdcard", "Got zero bytes in datafrom bytes");
            return false;
        }
        File file = new File(context.getFilesDir().getParent() + "/" + str);
        try {
            FileOutputStream fileOutputStream = new FileOutputStream(file);
            fileOutputStream.write(bArr);
            fileOutputStream.close();
            return true;
        } catch (Exception e) {
            Log.e("jamorham sdcard", "Error writing file: " + file.toString() + " " + e.toString());
            return false;
        }
    }

    private void toast(String str) {
        try {
            Toast.makeText(getApplicationContext(), str, 0).show();
            Log.d("jamorham sdcard", "Toast msg: " + str);
        } catch (Exception unused) {
            Log.e("jamorham sdcard", "Couldn't display toast: " + str);
        }
    }

    public void closeButton(View view) {
        finish();
    }
}