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

package com.eveningoutpost.dexdrip.ui.activities;

import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.os.Bundle;
import androidx.databinding.ObservableField;
import com.activeandroid.Cache;
import com.eveningoutpost.dexdrip.BaseAppCompatActivity;
import com.eveningoutpost.dexdrip.databinding.ActivityDatabaseAdminBinding;
import com.eveningoutpost.dexdrip.models.JoH;
import com.eveningoutpost.dexdrip.models.UserError;
import com.eveningoutpost.dexdrip.utilitymodels.Inevitable;
import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class DatabaseAdmin extends BaseAppCompatActivity {
    private ActivityDatabaseAdminBinding binding;
    private final DbAdminProcessor consoleProcessor = new ConsoleResults();
    private final DbAdminProcessor databaseSize = new DatabaseSize();
    public final ObservableField<String> console = new ObservableField<>();

    interface DbAdminProcessor {
        void process(List<String> list);
    }

    @Override
    protected void onCreate(Bundle bundle) {
        super.onCreate(bundle);
        ActivityDatabaseAdminBinding inflate = ActivityDatabaseAdminBinding.inflate(getLayoutInflater());
        this.binding = inflate;
        inflate.setVm(this);
        setContentView(this.binding.getRoot());
        JoH.fixActionBar(this);
        this.console.set("Ready\n");
        getDbSize();
    }

    public void getDbSize() {
        dbTask(this.databaseSize, "pragma database_list");
    }

    public void quickCheck() {
        dbTask(this.consoleProcessor, "pragma quick_check");
    }

    public void longCheck() {
        dbTask(this.consoleProcessor, "pragma integrity_check");
    }

    public void compact() {
        dbTask(new CompactSequenceProcessor(), null);
    }

    public void statistics() {
        dbTask(new Statistics(), "analyze", "select * from sqlite_stat1");
    }

    private void dbTask(DbAdminProcessor dbAdminProcessor, String... strArr) {
        dbTask(true, dbAdminProcessor, strArr);
    }

    public synchronized void dbTask(boolean z, final DbAdminProcessor dbAdminProcessor, final String... strArr) {
        if (z) {
            this.console.set("Please wait\n");
        }
        Inevitable.task("database-admin-task", 100L, new Runnable() {
            @Override
            public final void run() {
                DatabaseAdmin.this.lambda$dbTask$0(strArr, dbAdminProcessor);
            }
        });
    }

    public void lambda$dbTask$0(String[] strArr, DbAdminProcessor dbAdminProcessor) {
        try {
            ArrayList arrayList = new ArrayList();
            if (strArr != null) {
                for (String str : strArr) {
                    if (str != null) {
                        arrayList.addAll(executeSQL(str));
                    }
                }
            }
            dbAdminProcessor.process(arrayList);
        } catch (Exception e) {
            this.console.set("ERROR: " + e);
        }
    }

    private synchronized List<String> executeSQL(String str) {
        ArrayList arrayList;
        arrayList = new ArrayList();
        SQLiteDatabase openDatabase = Cache.openDatabase();
        boolean z = !str.equals("vacuum");
        if (z) {
            openDatabase.beginTransaction();
        }
        try {
            Cursor rawQuery = openDatabase.rawQuery(str, null);
            UserError.Log.d("DatabaseAdmin", "Got query results: " + str + " " + rawQuery.getCount());
            while (rawQuery.moveToNext()) {
                for (int i = 0; i < rawQuery.getColumnCount(); i++) {
                    arrayList.add(rawQuery.getString(i));
                }
            }
            rawQuery.close();
            if (z) {
                openDatabase.setTransactionSuccessful();
            }
        } finally {
            if (z) {
                openDatabase.endTransaction();
            }
        }
        return arrayList;
    }

    class ConsoleResults implements DbAdminProcessor {
        ConsoleResults() {
        }

        @Override
        public void process(List<String> list) {
            StringBuilder sb = new StringBuilder();
            for (String str : list) {
                if (!JoH.emptyString(str)) {
                    sb.append(str);
                    sb.append("\n");
                }
            }
            if (sb.length() > 1) {
                DatabaseAdmin.this.console.set(sb.toString());
            }
        }
    }

    class DatabaseSize implements DbAdminProcessor {
        private String insert;

        DatabaseSize() {
            this.insert = "";
        }

        DatabaseSize(String str) {
            this.insert = str;
        }

        @Override
        public void process(List<String> list) {
            String str;
            String str2;
            if (list.size() == 0) {
                DatabaseAdmin.this.console.set("Cannot locate database!!");
                return;
            }
            int i = 0;
            while (true) {
                try {
                    str = "";
                    if (i >= list.size()) {
                        str2 = "";
                        break;
                    } else {
                        if (list.get(i + 1).equals("main")) {
                            str2 = list.get(i + 2);
                            break;
                        }
                        i += 3;
                    }
                } catch (Exception e) {
                    DatabaseAdmin.this.consoleAppend("ERROR: " + e);
                    return;
                }
            }
            File file = new File(str2);
            if (file.exists()) {
                DatabaseAdmin databaseAdmin = DatabaseAdmin.this;
                StringBuilder sb = new StringBuilder();
                sb.append("Database ");
                sb.append(this.insert);
                sb.append(" size: ");
                sb.append(JoH.roundFloat(file.length() / 1048576.0f, 2));
                sb.append("M ");
                sb.append(file.canWrite() ? "" : " CANNOT WRITE");
                if (!file.canRead()) {
                    str = " CANNOT READ";
                }
                sb.append(str);
                sb.append("\n");
                databaseAdmin.consoleAppend(sb.toString());
                return;
            }
            DatabaseAdmin.this.console.set("Cannot find database file! " + str2);
        }
    }

    class Statistics implements DbAdminProcessor {
        Statistics() {
        }

        @Override
        public void process(List<String> list) {
            String str = "";
            DatabaseAdmin.this.console.set("");
            HashMap hashMap = new HashMap();
            boolean z = false;
            int i = 0;
            for (String str2 : list) {
                if (str2 != null && str2.length() > 3) {
                    if (i == 0) {
                        str = str2;
                    } else if (i == 2) {
                        try {
                            int i2 = JoH.tolerantParseInt(str2.substring(0, str2.indexOf(" ")), 0);
                            if (!hashMap.containsKey(str) || ((Integer) hashMap.get(str)).intValue() < i2) {
                                UserError.Log.d("DatabaseAdmin", "New high value: " + str + " " + i2);
                                hashMap.put(str, Integer.valueOf(i2));
                            }
                        } catch (Exception e) {
                            UserError.Log.e("DatabaseAdmin", "Exception in statistics: " + e);
                        }
                    }
                }
                i = (i + 1) % 3;
            }
            for (Map.Entry entry : JoH.mapSortedByValue(hashMap, true)) {
                if (((Integer) entry.getValue()).intValue() > 100) {
                    DatabaseAdmin.this.consoleAppend(((String) entry.getKey()) + ": " + entry.getValue() + "\n");
                    z = true;
                }
            }
            if (z) {
                return;
            }
            DatabaseAdmin.this.consoleAppend("No significant table data detected\n");
        }
    }

    private class CompactSequenceProcessor extends BaseSequenceProcessor {
        CompactSequenceProcessor() {
            super();
            this.startMessage = "Compacting - please wait";
            this.endMessage = "Done";
            this.queries = new String[]{"pragma database_list", "vacuum", "pragma database_list"};
            this.processors = new DbAdminProcessor[]{DatabaseAdmin.this.new DatabaseSize("Before"), DatabaseAdmin.this.consoleProcessor, DatabaseAdmin.this.new DatabaseSize("After")};
        }
    }

    abstract class BaseSequenceProcessor implements DbAdminProcessor {
        String startMessage = "";
        String endMessage = "";
        String[] queries = null;
        DbAdminProcessor[] processors = null;
        private volatile int state = 0;

        BaseSequenceProcessor() {
        }

        @Override
        public synchronized void process(List<String> list) {
            if (this.queries == null || this.processors == null) {
                UserError.Log.e("DatabaseAdmin", getClass().getSimpleName() + " not properly initialized");
                return;
            }
            try {
                int i = this.state;
                this.state++;
                if (i > 0) {
                    this.processors[i - 1].process(list);
                } else {
                    DatabaseAdmin.this.console.set(this.startMessage + "\n");
                }
                String[] strArr = this.queries;
                if (i < strArr.length) {
                    DatabaseAdmin.this.dbTask(false, this, strArr[i]);
                } else {
                    DatabaseAdmin.this.consoleAppend(this.endMessage + "\n");
                }
            } catch (Exception e) {
                DatabaseAdmin.this.console.set("" + e);
            }
        }
    }

    public void consoleAppend(String str) {
        this.console.set(this.console.get() + str);
    }
}