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

package com.eveningoutpost.dexdrip.ui.activities;

import android.app.Activity;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.net.Uri;
import android.os.Bundle;
import android.os.IBinder;
import android.os.ParcelUuid;
import android.text.method.ScrollingMovementMethod;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.TextView;
import androidx.appcompat.app.AppCompatActivity;
import androidx.databinding.Observable;
import androidx.databinding.ObservableArrayList;
import androidx.databinding.ObservableField;
import androidx.databinding.ObservableList;
import com.eveningoutpost.dexdrip.MegaStatus;
import com.eveningoutpost.dexdrip.databinding.ActivityThinJamBinding;
import com.eveningoutpost.dexdrip.models.JoH;
import com.eveningoutpost.dexdrip.models.UserError;
import com.eveningoutpost.dexdrip.ui.activities.ThinJamActivity;
import com.eveningoutpost.dexdrip.ui.dialog.GenericConfirmDialog;
import com.eveningoutpost.dexdrip.ui.dialog.QuickSettingsDialogs;
import com.eveningoutpost.dexdrip.utilitymodels.Inevitable;
import com.eveningoutpost.dexdrip.utilitymodels.PersistentStore;
import com.eveningoutpost.dexdrip.utilitymodels.Pref;
import com.eveningoutpost.dexdrip.utils.AndroidBarcode;
import com.eveningoutpost.dexdrip.utils.LocationHelper;
import com.eveningoutpost.dexdrip.utils.Preferences;
import com.eveningoutpost.dexdrip.utils.bt.BtCallBack2;
import com.eveningoutpost.dexdrip.utils.bt.ScanMeister;
import com.eveningoutpost.dexdrip.watch.thinjam.BlueJay;
import com.eveningoutpost.dexdrip.watch.thinjam.BlueJayEntry;
import com.eveningoutpost.dexdrip.watch.thinjam.BlueJayService;
import com.eveningoutpost.dexdrip.xdrip;
import com.google.zxing.integration.android.IntentIntegrator;
import com.google.zxing.integration.android.IntentResult;
import com.polidea.rxandroidble2.scan.ScanFilter;
import java.util.Iterator;
import me.tatarka.bindingcollectionadapter2.ItemBinding;

public class ThinJamActivity extends AppCompatActivity implements BtCallBack2 {
    private ActivityThinJamBinding binding;
    private BlueJayService thinJam;
    private final ScanMeister scanMeister = new ScanMeister();
    private final ScanFilter customFilter = new ScanFilter.Builder().setServiceUuid(ParcelUuid.fromString("4a616d21-0000-1000-8000-00805f9b34fb"), ParcelUuid.fromString("ffffffff-0000-0000-0000-000000000000")).build();
    private final ScanFilter nullFilter = new ScanFilter.Builder().build();
    private boolean mBound = false;
    private volatile Bundle savedExtras = null;
    private final Observable.OnPropertyChangedCallback changeRelayAdapter = new Observable.OnPropertyChangedCallback() {
        @Override
        public void onPropertyChanged(Observable observable, int i) {
            ThinJamActivity.this.binding.getVm().textWindow.set((String) ((ObservableField) observable).get());
        }
    };
    private ServiceConnection connection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            ThinJamActivity.this.thinJam = ((BlueJayService.LocalBinder) iBinder).getService();
            ThinJamActivity.this.thinJam.stringObservableField.removeOnPropertyChangedCallback(ThinJamActivity.this.changeRelayAdapter);
            ThinJamActivity.this.thinJam.stringObservableField.addOnPropertyChangedCallback(ThinJamActivity.this.changeRelayAdapter);
            ThinJamActivity.this.mBound = true;
            UserError.Log.d("ThinJamActivity", "Connected to service");
            ThinJamActivity thinJamActivity = ThinJamActivity.this;
            thinJamActivity.processIncomingBundle(thinJamActivity.savedExtras);
        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {
            ThinJamActivity.this.mBound = false;
        }
    };

    public static boolean isD() {
        return false;
    }

    @Override
    protected void onCreate(Bundle bundle) {
        super.onCreate(bundle);
        ActivityThinJamBinding inflate = ActivityThinJamBinding.inflate(getLayoutInflater());
        this.binding = inflate;
        inflate.setVm(new ViewModel(this));
        setContentView(this.binding.getRoot());
        JoH.fixActionBar(this);
        this.scanMeister.setFilter(this.customFilter);
        this.scanMeister.allowWide().unlimitedMatches();
        this.scanMeister.addCallBack2(this, "ThinJamActivity");
        ((TextView) findViewById(2131297131)).setMovementMethod(new ScrollingMovementMethod());
        processIncomingBundle(getIntent().getExtras());
        LocationHelper.requestLocationForBluetooth(this);
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(2131558415, menu);
        return true;
    }

    public void blueJayPowerStandby(MenuItem menuItem) {
        GenericConfirmDialog.show(this, "Confirm Standby", "Are you sure you want to put the watch in to Standby mode?\n\nLong Press Watch Button to wake it again.", new Runnable() {
            @Override
            public final void run() {
                ThinJamActivity.this.lambda$blueJayPowerStandby$0();
            }
        });
    }

    public void lambda$blueJayPowerStandby$0() {
        this.thinJam.standby();
    }

    @Override
    protected void onStart() {
        super.onStart();
        bindService();
    }

    private void bindService() {
        bindService(new Intent(this, (Class<?>) BlueJayService.class), this.connection, 1);
    }

    @Override
    protected void onStop() {
        this.thinJam.stringObservableField.removeOnPropertyChangedCallback(this.changeRelayAdapter);
        unbindService(this.connection);
        this.mBound = false;
        super.onStop();
    }

    @Override
    public void onNewIntent(Intent intent) {
        processIncomingBundle(intent.getExtras());
    }

    @Override
    public void btCallback2(String str, String str2, String str3, Bundle bundle) {
        UserError.Log.d("ThinJamActivity", "BT scan: " + str + " " + str2 + " " + str3);
        if (str2.equals("SCAN_FOUND")) {
            this.binding.getVm().addToList(str, str3);
        }
    }

    public class TjItem {
        public String mac;
        public String name;
        public int resource;

        public void onClick(View view) {
            UserError.Log.d("ThinJamActivity", "Clicked: " + this.mac);
            ThinJamActivity.this.binding.getVm().stopScan();
            ThinJamActivity.this.binding.getVm().items.clear();
            ThinJamActivity.this.binding.getVm().changeConnectedDevice(this);
        }

        TjItem(String str, String str2) {
            this.mac = str;
            this.name = str2;
        }
    }

    public class ViewModel {
        Activity activity;
        public final ObservableField<String> connectedDevice = new ObservableField<>();
        public final ObservableField<String> status = new ObservableField<>();
        public final ObservableField<String> textWindow = new ObservableField<>();
        public final ObservableField<Integer> progressBar = new ObservableField<>();
        public final ObservableList<TjItem> items = new ObservableArrayList();
        public final ItemBinding<TjItem> itemBinding = ItemBinding.of(10, 2131493096);
        private String mac = null;
        final String TJ_UI_TX_ID = "Last-tj-txid";

        public boolean showBack() {
            return true;
        }

        ViewModel(Activity activity) {
            this.activity = activity;
            loadLastConnectedDevice();
        }

        public void goBack(View view) {
            stopScan();
            this.items.clear();
        }

        public boolean doAction(String str) {
            str.hashCode();
            switch (str) {
                case "factoryreset":
                    JoH.static_toast_long("Factory Resetting");
                    ThinJamActivity.this.thinJam.factoryReset();
                    return true;
                case "reboot":
                    JoH.static_toast_long("Rebooting");
                    ThinJamActivity.this.thinJam.reboot();
                    return true;
                case "easyauth":
                    JoH.static_toast_long("Doing non-QR code Easy Auth");
                    ThinJamActivity.this.thinJam.easyAuth();
                    return true;
                case "asktxid":
                    setTx();
                    return true;
                case "updateconfig":
                    JoH.static_toast_long("Refreshing watch config");
                    validateTxId();
                    return true;
                case "launchhelp":
                    xdrip.getAppContext().startActivity(new Intent("android.intent.action.VIEW", Uri.parse("https://bluejay.website/quickhelp")).addFlags(268435456));
                    return true;
                case "launchsettings":
                    xdrip.getAppContext().startActivity(JoH.getStartActivityIntent(Preferences.class).setAction("bluejay_preference_screen").addFlags(131072));
                    return true;
                case "showqrcode":
                    JoH.static_toast_long("Showing QR code on watch");
                    ThinJamActivity.this.thinJam.showQrCode();
                    return true;
                case "launchstatus":
                    xdrip.getAppContext().startActivity(JoH.getStartActivityIntent(MegaStatus.class).setAction("BlueJay").addFlags(131072));
                    return true;
                default:
                    JoH.static_toast_long("Unknown action: " + str);
                    return true;
            }
        }

        public boolean scan(boolean z) {
            UserError.Log.d("ThinJamActivity", "Start scan");
            if (!JoH.ratelimit("bj-scan-startb", 5)) {
                return false;
            }
            if (z) {
                ThinJamActivity.this.scanMeister.setFilter(ThinJamActivity.this.nullFilter).scan();
                return false;
            }
            ThinJamActivity.this.scanMeister.setFilter(ThinJamActivity.this.customFilter).scan();
            return false;
        }

        void setTx() {
            QuickSettingsDialogs.textSettingDialog(this.activity, "Last-tj-txid", "Transmitter ID", "Enter TXID", 528528, new Runnable() {
                @Override
                public void run() {
                    ViewModel.this.validateTxId();
                }
            });
        }

        public void validateTxId() {
            Pref.setString("Last-tj-txid", Pref.getString("dex_txid", ""));
            String upperCase = Pref.getString("Last-tj-txid", "").trim().toUpperCase();
            ThinJamActivity.this.thinJam.setSettings(upperCase.length() <= 6 ? upperCase : "");
            ThinJamActivity.this.thinJam.setTime();
        }

        public boolean doOtaC(View view) {
            ThinJamActivity.this.thinJam.setProgressIndicator(this.progressBar);
            JoH.static_toast_long("Doing OTA CORE");
            Inevitable.task("do-ota-tj", 500L, new Runnable() {
                @Override
                public final void run() {
                    ThinJamActivity.ViewModel.this.lambda$doOtaC$1();
                }
            });
            return false;
        }

        public void lambda$doOtaC$1() {
            ThinJamActivity.this.thinJam.doOtaCore();
        }

        public void doOtaM(View view) {
            ThinJamActivity.this.thinJam.setProgressIndicator(this.progressBar);
            Inevitable.task("do-ota-tj", 500L, new Runnable() {
                @Override
                public final void run() {
                    ThinJamActivity.ViewModel.this.lambda$doOtaM$2();
                }
            });
        }

        public void lambda$doOtaM$2() {
            ThinJamActivity.this.thinJam.doOtaMain();
        }

        public void stopScan() {
            UserError.Log.d("ThinJamActivity", "Stop scan");
            ThinJamActivity.this.scanMeister.stop();
        }

        public void addToList(String str, String str2) {
            if (str == null) {
                return;
            }
            synchronized (this.items) {
                if (!macInList(str)) {
                    this.items.add(ThinJamActivity.this.new TjItem(str, str2));
                    UserError.Log.d("ThinJamActivity", "Added item " + str + " " + str2 + " total:" + this.items.size());
                }
            }
        }

        public boolean macInList(String str) {
            if (str == null) {
                return false;
            }
            Iterator<TjItem> it = this.items.iterator();
            while (it.hasNext()) {
                if (it.next().mac.equals(str)) {
                    return true;
                }
            }
            return false;
        }

        public void changeConnectedDevice(TjItem tjItem) {
            this.connectedDevice.set(tjItem.mac + " " + tjItem.name);
            setMac(tjItem.mac);
            saveConnectedDevice();
            BlueJayEntry.setEnabled();
            ThinJamActivity.this.thinJam.emptyQueue();
            ThinJamActivity.this.thinJam.stringObservableField.set("");
            ThinJamActivity.this.thinJam.notificationString.setLength(0);
            ThinJamActivity.refreshFromStoredMac();
        }

        private void saveConnectedDevice() {
            PersistentStore.setString("TJ_CONNECTED_DEVICE_INFO", this.connectedDevice.get());
        }

        private void loadLastConnectedDevice() {
            this.connectedDevice.set(PersistentStore.getString("TJ_CONNECTED_DEVICE_INFO"));
            try {
                String[] split = this.connectedDevice.get().split(" ");
                if (split[0].length() == 17) {
                    setMac(split[0]);
                }
            } catch (Exception unused) {
            }
            UserError.Log.d("ThinJamActivity", "Mac loaded in as: " + this.mac);
        }

        public void setMac(String str) {
            if (str == null) {
                return;
            }
            this.mac = str;
            ThinJamActivity.this.thinJam.setMac(str);
        }

        public void identify() {
            ThinJamActivity.this.thinJam.identify();
        }
    }

    public static void refreshFromStoredMac() {
        startWithCommand("REFRESH_FROM_STORED_MAC");
    }

    public static void installCorePrompt() {
        startWithCommand("INSTALL_CORE");
    }

    public static void updateCorePrompt() {
        startWithCommand("UPDATE_CORE");
    }

    public static void updateMainPrompt() {
        startWithCommand("UPDATE_MAIN");
    }

    public static void requestQrCode() {
        startWithCommand("REQUEST_QR");
    }

    public static void launchQRScan() {
        startWithCommand("SCAN_QR");
    }

    private static void startWithCommand(String str) {
        xdrip.getAppContext().startActivity(new Intent(xdrip.getAppContext(), (Class<?>) ThinJamActivity.class).setFlags(268435456).putExtra("THINJAM_ACTIVITY_COMMAND", str));
    }

    public void processIncomingBundle(Bundle bundle) {
        if (bundle != null) {
            Log.d("ThinJamActivity", "Processing incoming bundle");
            if (!this.mBound) {
                this.savedExtras = bundle;
            }
            this.savedExtras = null;
            String string = bundle.getString("THINJAM_ACTIVITY_COMMAND");
            if (string != null) {
                switch (string) {
                    case "SCAN_QR":
                        new AndroidBarcode(this).scan();
                        break;
                    case "REFRESH_FROM_STORED_MAC":
                        this.binding.getVm().connectedDevice.set(BlueJay.getMac());
                        this.binding.getVm().setMac(BlueJay.getMac());
                        this.binding.getVm().identify();
                        break;
                    case "INSTALL_CORE":
                        promptForCoreUpdate(false);
                        break;
                    case "REQUEST_QR":
                        this.binding.getVm().doAction("showqrcode");
                        break;
                    case "UPDATE_CORE":
                        promptForCoreUpdate(true);
                        break;
                    case "UPDATE_MAIN":
                        promptForMainUpdate();
                        break;
                }
            }
        }
    }

    private void promptForCoreUpdate(boolean z) {
        GenericConfirmDialog.show(this, z ? "Update Core?" : "Install Core?", "Install xDrip core module?\n\nMake sure device is charging or this can break it!", new Runnable() {
            @Override
            public final void run() {
                ThinJamActivity.this.lambda$promptForCoreUpdate$1();
            }
        });
    }

    public void lambda$promptForCoreUpdate$1() {
        this.binding.getVm().doOtaC(null);
    }

    private void promptForMainUpdate() {
        GenericConfirmDialog.show(this, "Update Firmware?", "Update BlueJay firmware?\n\nMake sure device is charging or this can break it!", new Runnable() {
            @Override
            public final void run() {
                ThinJamActivity.this.lambda$promptForMainUpdate$2();
            }
        });
    }

    public void lambda$promptForMainUpdate$2() {
        this.binding.getVm().doOtaM(null);
    }

    @Override
    public void onRequestPermissionsResult(int i, String[] strArr, int[] iArr) {
        super.onRequestPermissionsResult(i, strArr, iArr);
        for (int i2 = 0; i2 < strArr.length; i2++) {
            if (strArr[i2].equals("android.permission.ACCESS_FINE_LOCATION") && iArr[i2] == 0) {
                refreshFromStoredMac();
            }
        }
    }

    @Override
    public void onActivityResult(int i, int i2, Intent intent) {
        IntentResult parseActivityResult = IntentIntegrator.parseActivityResult(i, i2, intent);
        if (parseActivityResult == null || parseActivityResult.getContents() == null || !parseActivityResult.getFormatName().equals("QR_CODE")) {
            return;
        }
        try {
            BlueJay.processQRCode(parseActivityResult.getRawBytes());
        } catch (Exception unused) {
        }
    }
}