正在查看： xDrip+ v04633772025.07.16 应用的 WatchUpdaterService.java JAVA 源代码文件
本页面展示 JAVA 反编译生成的源代码文件，支持语法高亮显示。 仅供安全研究与技术分析使用，严禁用于任何非法用途。请遵守相关法律法规。
页面标题
页面副标题
xDrip+ v04633772025.07.16 - WatchUpdaterService.java 源代码
package com.eveningoutpost.dexdrip.wearintegration;
import android.annotation.SuppressLint;
import android.app.ActivityManager;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.PowerManager;
import android.preference.PreferenceManager;
import android.util.Log;
import androidx.appcompat.R$styleable;
import androidx.localbroadcastmanager.content.LocalBroadcastManager;
import com.eveningoutpost.dexdrip.BestGlucose;
import com.eveningoutpost.dexdrip.Home;
import com.eveningoutpost.dexdrip.cgm.carelinkfollow.message.Marker;
import com.eveningoutpost.dexdrip.g5model.CalibrationState;
import com.eveningoutpost.dexdrip.g5model.Ob1G5StateMachine;
import com.eveningoutpost.dexdrip.importedlibraries.usbserial.driver.UsbId;
import com.eveningoutpost.dexdrip.models.ActiveBluetoothDevice;
import com.eveningoutpost.dexdrip.models.AlertType;
import com.eveningoutpost.dexdrip.models.BgReading;
import com.eveningoutpost.dexdrip.models.BloodTest;
import com.eveningoutpost.dexdrip.models.Calibration;
import com.eveningoutpost.dexdrip.models.HeartRate;
import com.eveningoutpost.dexdrip.models.JoH;
import com.eveningoutpost.dexdrip.models.Sensor;
import com.eveningoutpost.dexdrip.models.StepCounter;
import com.eveningoutpost.dexdrip.models.TransmitterData;
import com.eveningoutpost.dexdrip.models.Treatments;
import com.eveningoutpost.dexdrip.models.UserError;
import com.eveningoutpost.dexdrip.services.G5BaseService;
import com.eveningoutpost.dexdrip.services.G5CollectionService;
import com.eveningoutpost.dexdrip.services.Ob1G5CollectionService;
import com.eveningoutpost.dexdrip.utilitymodels.AlertPlayer;
import com.eveningoutpost.dexdrip.utilitymodels.BgGraphBuilder;
import com.eveningoutpost.dexdrip.utilitymodels.BgSendQueue;
import com.eveningoutpost.dexdrip.utilitymodels.CollectionServiceStarter;
import com.eveningoutpost.dexdrip.utilitymodels.Inevitable;
import com.eveningoutpost.dexdrip.utilitymodels.LowPriorityThread;
import com.eveningoutpost.dexdrip.utilitymodels.PersistentStore;
import com.eveningoutpost.dexdrip.utilitymodels.Pref;
import com.eveningoutpost.dexdrip.utilitymodels.StatusLine;
import com.eveningoutpost.dexdrip.utilitymodels.WearSyncBooleans;
import com.eveningoutpost.dexdrip.utilitymodels.WearSyncPersistentStrings;
import com.eveningoutpost.dexdrip.utils.DexCollectionType;
import com.eveningoutpost.dexdrip.utils.GetWearApk;
import com.eveningoutpost.dexdrip.utils.PowerStateReceiver;
import com.eveningoutpost.dexdrip.wearintegration.WatchUpdaterService;
import com.eveningoutpost.dexdrip.xdrip;
import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.api.GoogleApiClient;
import com.google.android.gms.common.api.ResultCallback;
import com.google.android.gms.wearable.CapabilityApi;
import com.google.android.gms.wearable.CapabilityInfo;
import com.google.android.gms.wearable.Channel;
import com.google.android.gms.wearable.DataEvent;
import com.google.android.gms.wearable.DataEventBuffer;
import com.google.android.gms.wearable.DataMap;
import com.google.android.gms.wearable.DataMapItem;
import com.google.android.gms.wearable.MessageEvent;
import com.google.android.gms.wearable.Node;
import com.google.android.gms.wearable.PutDataMapRequest;
import com.google.android.gms.wearable.Wearable;
import com.google.android.gms.wearable.WearableListenerService;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.internal.bind.DateTypeAdapter;
import java.io.IOException;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Set;
import java.util.concurrent.TimeUnit;
@SuppressLint({"LogNotTimber"})
public class WatchUpdaterService extends WearableListenerService implements GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener {
private static byte[] apkBytes;
private static GoogleApiClient googleApiClient;
private SharedPreferences.OnSharedPreferenceChangeListener mPreferencesListener;
private SharedPreferences mPrefs;
public static final String ACTION_RESEND = WatchUpdaterService.class.getName().concat(".Resend");
public static final String ACTION_OPEN_SETTINGS = WatchUpdaterService.class.getName().concat(".OpenSettings");
public static final String ACTION_SYNC_DB = WatchUpdaterService.class.getName().concat(".SyncDB");
public static final String ACTION_RESET_DB = WatchUpdaterService.class.getName().concat(".ResetDB");
public static final String ACTION_SYNC_LOGS = WatchUpdaterService.class.getName().concat(".SyncLogs");
public static final String ACTION_CLEAR_LOGS = WatchUpdaterService.class.getName().concat(".ClearLogs");
public static final String ACTION_STATUS_COLLECTOR = WatchUpdaterService.class.getName().concat(".StatusCollector");
public static final String ACTION_START_COLLECTOR = WatchUpdaterService.class.getName().concat(".StartCollector");
public static final String ACTION_SYNC_SENSOR = WatchUpdaterService.class.getName().concat(".SyncSensor");
public static final String ACTION_SYNC_CALIBRATION = WatchUpdaterService.class.getName().concat(".SyncCalibration");
public static final String ACTION_SEND_TOAST = WatchUpdaterService.class.getName().concat(".SendWearLocalToast");
public static final String ACTION_SEND_STATUS = WatchUpdaterService.class.getName().concat(".SendStatus");
public static final String ACTION_SYNC_ACTIVEBTDEVICE = WatchUpdaterService.class.getName().concat(".SyncActiveBtDevice");
public static final String ACTION_SYNC_ALERTTYPE = WatchUpdaterService.class.getName().concat(".SyncAlertType");
private static final String ACTION_SEND_G5_QUEUE = WatchUpdaterService.class.getName().concat(".SendG5Queue");
public static final String ACTION_DISABLE_FORCE_WEAR = WatchUpdaterService.class.getName().concat(".DisableForceWear");
public static final String ACTION_SNOOZE_ALERT = WatchUpdaterService.class.getName().concat(".SnoozeAlert");
private static String localnode = "";
private static long lastRequest = 0;
private static final Integer sendTreatmentsCount = 60;
private static final Integer sendCalibrationCount = 3;
private static final Integer sendBgCount = 4;
private static long syncLogsRequested = 0;
private volatile String mWearNodeId = null;
private boolean wear_integration = false;
private boolean pebble_integration = false;
private boolean is_using_bt = false;
private static String getVersionID() {
return "0463377-2025.07.16";
}
@Override
public void onConnectionFailed(ConnectionResult connectionResult) {
}
@Override
public void onConnectionSuspended(int i) {
}
public static synchronized void receivedText(Context context, String str) {
synchronized (WatchUpdaterService.class) {
if (str.equals(PersistentStore.getString("watch-last-received-text"))) {
Log.e("jamorham watchupdater", "Received text is same as previous, ignoring: " + str);
return;
}
PersistentStore.setString("watch-last-received-text", str);
startHomeWithExtra(context, "/xdrip_plus_voice_payload", str);
}
}
private static void approveTreatment(Context context, String str) {
startHomeWithExtra(context, "/xdrip_plus_approve_treatment", str);
}
private static void cancelTreatment(Context context, String str) {
startHomeWithExtra(context, "/xdrip_plus_cancel_treatment", str);
}
private static void startHomeWithExtra(Context context, String str, String str2) {
Intent intent = new Intent(context, (Class<?>) Home.class);
intent.setFlags(268435456);
intent.putExtra(str, str2);
context.startActivity(intent);
}
private void sendDataReceived(String str, String str2, long j, String str3, long j2) {
Log.d("jamorham watchupdater", "sendDataReceived timeOfLastEntry=" + JoH.dateTimeText(j) + " Path=" + str);
forceGoogleApiConnect();
if (googleApiClient.isConnected()) {
PutDataMapRequest create = PutDataMapRequest.create(str);
create.setUrgent();
create.getDataMap().putDouble("timestamp", System.currentTimeMillis());
create.getDataMap().putLong("timeOfLastEntry", j);
create.getDataMap().putLong("syncLogsRequested", j2);
create.getDataMap().putString("type", str3);
create.getDataMap().putString("msg", str2);
Wearable.DataApi.putDataItem(googleApiClient, create.asPutDataRequest());
return;
}
Log.e("jamorham watchupdater", "sendDataReceived No connection to wearable available!");
}
private void syncFieldData(DataMap dataMap) {
String string = dataMap.getString("dex_txid", "");
byte[] byteArray = dataMap.getByteArray("g5-battery-");
byte[] byteArray2 = dataMap.getByteArray("g5-firmware-");
if (string == null || !string.equals(this.mPrefs.getString("dex_txid", "default"))) {
return;
}
if (byteArray != null) {
long j = dataMap.getLong("g5-battery-from");
if (j > PersistentStore.getLong("g5-battery-from" + string)) {
G5CollectionService.setStoredBatteryBytes(string, byteArray);
PersistentStore.setLong("g5-battery-from" + string, j);
G5BaseService.getBatteryStatusNow = false;
G5BaseService.getBatteryStatusNow = false;
}
}
if (byteArray2 != null) {
G5CollectionService.setStoredFirmwareBytes(string, byteArray2);
}
}
public static void checkOb1Queue() {
String extractQueueJson;
if (Pref.getBoolean("enable_wearG5", false) && Ob1G5CollectionService.usingNativeMode() && (extractQueueJson = Ob1G5StateMachine.extractQueueJson()) != null) {
xdrip.getAppContext().startService(new Intent(xdrip.getAppContext(), (Class<?>) WatchUpdaterService.class).setAction(ACTION_SEND_G5_QUEUE).putExtra("queueData", extractQueueJson));
}
}
private void syncPrefData(com.google.android.gms.wearable.DataMap r31) {
throw new UnsupportedOperationException("Method not decompiled: com.eveningoutpost.dexdrip.wearintegration.WatchUpdaterService.syncPrefData(com.google.android.gms.wearable.DataMap):void");
}
public void processConnect() {
Log.d("jamorham watchupdater", "processConnect enter");
this.wear_integration = this.mPrefs.getBoolean("wear_sync", false);
boolean z = this.mPrefs.getBoolean("enable_wearG5", false);
boolean z2 = this.mPrefs.getBoolean("force_wearG5", false);
if (this.wear_integration) {
initWearData();
if (!z) {
Log.d("jamorham watchupdater", "processConnect enable_wearG5=false - startBtService");
startBtService();
if (this.mPrefs.getBoolean("show_wear_treatments", false)) {
initWearTreatments();
return;
}
return;
}
if (z2) {
Log.d("jamorham watchupdater", "processConnect force_wearG5=true - stopBtService");
stopBtService();
return;
} else {
Log.d("jamorham watchupdater", "processConnect force_wearG5=false - startBtService");
startBtService();
return;
}
}
Log.d("jamorham watchupdater", "processConnect wear_integration=false - startBtService");
startBtService();
}
private synchronized void syncBgReadingsData(DataMap dataMap) {
Log.d("jamorham watchupdater", "sync-precalculated-bg-readings-Data");
Ob1G5CollectionService.processCalibrationState(CalibrationState.parse(dataMap.getInt("native_calibration_state", 0)));
Ob1G5StateMachine.injectDexTime(dataMap.getString("dextime", null));
if (dataMap.getBoolean("OB1-QUEUE-DRAINED")) {
Ob1G5StateMachine.emptyQueue();
}
ArrayList<DataMap> dataMapArrayList = dataMap.getDataMapArrayList("entries");
if (dataMapArrayList != null) {
Gson create = new GsonBuilder().excludeFieldsWithoutExposeAnnotation().registerTypeAdapter(Date.class, new DateTypeAdapter()).serializeSpecialFloatingPointValues().create();
int size = dataMapArrayList.size();
if (size > 0) {
Sensor currentSensor = Sensor.currentSensor();
if (currentSensor == null) {
UserError.Log.e("jamorham watchupdater", "Cannot sync wear BG readings because sensor is marked stopped on phone");
return;
}
Log.d("jamorham watchupdater", "syncTransmitterData add BgReading Table entries count=" + size);
Iterator<DataMap> it = dataMapArrayList.iterator();
long j = 0;
int i = 0;
while (it.hasNext()) {
DataMap next = it.next();
if (next != null) {
i++;
String string = next.getString("bgs");
if (string != null) {
BgReading bgReading = (BgReading) create.fromJson(string, BgReading.class);
if (BgReading.findByUuid(bgReading.uuid) == null) {
if (BgReading.getForTimestamp(bgReading.timestamp) == null) {
StringBuilder sb = new StringBuilder();
sb.append("Saving new synced pre-calculated bg-reading: ");
sb.append(JoH.dateTimeText(bgReading.timestamp));
sb.append(" last entry: ");
boolean z = true;
sb.append(i == size);
sb.append(" ");
sb.append(BgGraphBuilder.unitized_string_static(bgReading.calculated_value));
Log.d("jamorham watchupdater", sb.toString());
bgReading.sensor = currentSensor;
bgReading.save();
Context appContext = xdrip.getAppContext();
boolean z2 = Home.get_follower();
if (i == size) {
z = false;
}
BgSendQueue.handleNewBgReading(bgReading, "create", appContext, z2, z);
} else {
Log.d("jamorham watchupdater", "BgReading for timestamp already exists: " + JoH.dateTimeText(bgReading.timestamp));
}
} else {
Log.d("jamorham watchupdater", "BgReading with uuid: " + bgReading.uuid + " already exists: " + JoH.dateTimeText(bgReading.timestamp));
}
j = Math.max(bgReading.timestamp + 1, j);
}
}
}
sendDataReceived("/xdrip_plus_data-item-received", "DATA_RECEIVED_BGS count=" + dataMapArrayList.size(), j, Marker.MARKER_TYPE_BG, -1L);
} else {
UserError.Log.e("jamorham watchupdater", "Not acknowledging wear BG readings as count was 0");
}
} else {
UserError.Log.d("jamorham watchupdater", "Null entries list - should only happen with native status update only");
}
}
private synchronized void syncTransmitterData(DataMap dataMap, boolean z) {
BgReading create;
Log.d("jamorham watchupdater", "syncTransmitterData");
ArrayList<DataMap> dataMapArrayList = dataMap.getDataMapArrayList("entries");
Log.d("jamorham watchupdater", "syncTransmitterData add BgReading Table");
if (dataMapArrayList != null) {
Gson create2 = new GsonBuilder().excludeFieldsWithoutExposeAnnotation().registerTypeAdapter(Date.class, new DateTypeAdapter()).serializeSpecialFloatingPointValues().create();
int size = dataMapArrayList.size();
Log.d("jamorham watchupdater", "syncTransmitterData add BgReading Table entries count=" + size);
Iterator<DataMap> it = dataMapArrayList.iterator();
int i = 0;
long j = 0L;
while (it.hasNext()) {
DataMap next = it.next();
if (next != null) {
int i2 = i + 1;
String string = next.getString("bgs");
if (string != null) {
TransmitterData transmitterData = (TransmitterData) create2.fromJson(string, TransmitterData.class);
TransmitterData forTimestamp = TransmitterData.getForTimestamp(transmitterData.timestamp);
TransmitterData findByUuid = TransmitterData.findByUuid(transmitterData.uuid);
long j2 = transmitterData.timestamp + 1;
if (forTimestamp == null && findByUuid == null) {
Log.d("jamorham watchupdater", "syncTransmitterData add BG; does NOT exist for uuid=" + transmitterData.uuid + " timestamp=" + transmitterData.timestamp + " timeString=" + JoH.dateTimeText(transmitterData.timestamp) + " raw_data=" + transmitterData.raw_data);
if (!z) {
transmitterData.save();
if (TransmitterData.findByUuid(transmitterData.uuid) != null) {
Log.d("jamorham watchupdater", "syncTransmitterData: TransmitterData was saved for uuid:" + transmitterData.uuid);
Sensor currentSensor = Sensor.currentSensor();
if (currentSensor == null) {
Log.e("jamorham watchupdater", "syncTransmitterData: No Active Sensor, Data only stored in Transmitter Data");
return;
}
Sensor.updateBatteryLevel(currentSensor, transmitterData.sensor_battery_level);
Log.i("jamorham watchupdater", "syncTransmitterData: BG timestamp create " + Long.toString(transmitterData.timestamp));
if (size > 1 && i2 < size) {
create = BgReading.create(transmitterData.raw_data, transmitterData.filtered_data, this, Long.valueOf(transmitterData.timestamp), true);
} else {
create = BgReading.create(transmitterData.raw_data, transmitterData.filtered_data, this, Long.valueOf(transmitterData.timestamp));
}
if (create != null) {
Log.d("jamorham watchupdater", "syncTransmitterData BG GSON saved BG: " + create.toS());
} else {
Log.e("jamorham watchupdater", "syncTransmitterData BG GSON NOT saved");
}
} else {
Log.e("jamorham watchupdater", "syncTransmitterData: TransmitterData was NOT saved for uuid:" + transmitterData.uuid);
return;
}
}
i = i2;
j = j2;
}
Log.d("jamorham watchupdater", "syncTransmitterData BG already exists for uuid=" + transmitterData.uuid + " timestamp=" + transmitterData.timestamp + " timeString=" + JoH.dateTimeText(transmitterData.timestamp) + " raw_data=" + transmitterData.raw_data);
i = i2;
j = j2;
} else {
i = i2;
}
}
}
sendDataReceived("/xdrip_plus_data-item-received", "DATA_RECEIVED_BGS count=" + dataMapArrayList.size(), j, z ? "BM" : Marker.MARKER_TYPE_BG, -1L);
}
}
private synchronized void syncLogData(DataMap dataMap, boolean z) {
String string;
UserError userError;
Log.d("jamorham watchupdater", "syncLogData");
long j = dataMap.getLong("syncLogsRequested", -1L);
ArrayList<DataMap> dataMapArrayList = dataMap.getDataMapArrayList("entries");
if (dataMapArrayList != null) {
Gson create = new GsonBuilder().excludeFieldsWithoutExposeAnnotation().registerTypeAdapter(Date.class, new DateTypeAdapter()).serializeSpecialFloatingPointValues().create();
Log.d("jamorham watchupdater", "syncLogData add Table entries count=" + dataMapArrayList.size() + " watch_syncLogsRequested=" + j);
Iterator<DataMap> it = dataMapArrayList.iterator();
int i = 0;
long j2 = 0L;
while (it.hasNext()) {
DataMap next = it.next();
if (next != null && (string = next.getString("entry")) != null && (userError = (UserError) create.fromJson(string, UserError.class)) != null) {
j2 = userError.timestamp + 1;
String str = userError.shortError;
if (str != null && !str.isEmpty() && !userError.shortError.startsWith("wear")) {
userError.shortError = this.mPrefs.getString("wear_logs_prefix", "wear") + userError.shortError;
}
if (UserError.getForTimestamp(userError) == null && !z) {
userError.save();
i++;
}
}
}
if (i > 0) {
Log.d("jamorham watchupdater", "syncLogData Saved timeOfLastEntry=" + JoH.dateTimeText(j2) + " saved=" + i);
} else {
Log.d("jamorham watchupdater", "syncLogData No records saved due to being duplicates! timeOfLastEntry=" + JoH.dateTimeText(j2) + " count=" + dataMapArrayList.size());
}
sendDataReceived("/xdrip_plus_data-item-received", "DATA_RECEIVED_LOGS count=" + dataMapArrayList.size(), j2, z ? "BM" : "LOG", j);
}
}
private synchronized void syncStepSensorData(DataMap dataMap, boolean z) {
Log.d("jamorham watchupdater", "syncStepSensorData");
ArrayList<DataMap> dataMapArrayList = dataMap.getDataMapArrayList("entries");
Log.d("jamorham watchupdater", "syncStepSensorData add to Table");
if (dataMapArrayList != null) {
Gson create = new GsonBuilder().excludeFieldsWithoutExposeAnnotation().registerTypeAdapter(Date.class, new DateTypeAdapter()).serializeSpecialFloatingPointValues().create();
StepCounter.last();
Log.d("jamorham watchupdater", "syncStepSensorData add Table entries count=" + dataMapArrayList.size());
Iterator<DataMap> it = dataMapArrayList.iterator();
long j = 0L;
while (it.hasNext()) {
DataMap next = it.next();
if (next != null) {
Log.d("jamorham watchupdater", "syncStepSensorData add Table entry=" + next);
String string = next.getString("entry");
if (string != null) {
Log.d("jamorham watchupdater", "syncStepSensorData add Table record=" + string);
StepCounter stepCounter = (StepCounter) create.fromJson(string, StepCounter.class);
if (stepCounter != null) {
long j2 = stepCounter.timestamp + 1;
Log.d("jamorham watchupdater", "syncStepSensorData add Entry Wear=" + stepCounter.toString());
Log.d("jamorham watchupdater", "syncStepSensorData WATCH data.metric=" + stepCounter.metric + " timestamp=" + JoH.dateTimeText(stepCounter.timestamp));
if (!z) {
stepCounter.saveit();
}
j = j2;
}
}
}
}
sendDataReceived("/xdrip_plus_data-item-received", "DATA_RECEIVED_LOGS count=" + dataMapArrayList.size(), j, z ? "BM" : "STEP", -1L);
}
}
private synchronized void syncHeartSensorData(DataMap dataMap, boolean z) {
Log.d("jamorham watchupdater", "syncHeartSensorData");
ArrayList<DataMap> dataMapArrayList = dataMap.getDataMapArrayList("entries");
Log.d("jamorham watchupdater", "syncHeartSensorData add to Table");
if (dataMapArrayList != null) {
Gson defaultGsonInstance = JoH.defaultGsonInstance();
Log.d("jamorham watchupdater", "syncHeartSensorData add Table entries count=" + dataMapArrayList.size());
Iterator<DataMap> it = dataMapArrayList.iterator();
long j = 0L;
while (it.hasNext()) {
DataMap next = it.next();
if (next != null) {
Log.d("jamorham watchupdater", "syncHeartSensorData add Table entry=" + next);
String string = next.getString("entry");
if (string != null) {
Log.d("jamorham watchupdater", "syncHeartSensorData add Table record=" + string);
HeartRate heartRate = (HeartRate) defaultGsonInstance.fromJson(string, HeartRate.class);
if (heartRate != null) {
long j2 = heartRate.timestamp + 1;
Log.d("jamorham watchupdater", "syncHeartSensorData add Entry Wear=" + heartRate.toString() + " " + string);
Log.d("jamorham watchupdater", "syncHeartSensorData WATCH data.metric=" + heartRate.bpm + " timestamp=" + JoH.dateTimeText(heartRate.timestamp));
if (!z) {
heartRate.saveit();
}
j = j2;
}
}
}
}
sendDataReceived("/xdrip_plus_data-item-received", "DATA_RECEIVED_LOGS count=" + dataMapArrayList.size(), j, z ? "BM" : "HEART", -1L);
}
}
private synchronized void syncTreatmentsData(DataMap dataMap, boolean z) {
long j;
Log.d("jamorham watchupdater", "syncTreatmentsData");
ArrayList<DataMap> dataMapArrayList = dataMap.getDataMapArrayList("entries");
if (dataMapArrayList != null) {
Log.d("jamorham watchupdater", "syncTreatmentsData count=" + dataMapArrayList.size());
Iterator<DataMap> it = dataMapArrayList.iterator();
long j2 = 0;
loop0: while (true) {
j = j2;
while (it.hasNext()) {
DataMap next = it.next();
if (next != null) {
Log.d("jamorham watchupdater", "syncTreatmentsData entry=" + next);
String string = next.getString("entry");
if (string != null && string.length() > 1) {
Log.d("jamorham watchupdater", "Received wearable 2: voice payload: " + string);
long j3 = next.getLong("timestamp");
if (j3 <= PersistentStore.getLong("wear-sync-last-treatment-record-ts")) {
Log.e("jamorham watchupdater", "Ignoring repeated or older sync timestamp");
} else {
long msSince = JoH.msSince(j3);
if (msSince >= -5000 && msSince <= 259200000) {
if (string.contains("uuid null")) {
Log.e("jamorham watchupdater", "Skipping xx uuid null record!");
} else {
receivedText(getApplicationContext(), string);
PersistentStore.setLong("wear-sync-last-treatment-record-ts", j3);
Log.d("jamorham watchupdater", "syncTreatmentsData add Table record=" + string);
j2 = 1 + j3;
Log.d("jamorham watchupdater", "syncTreatmentsData WATCH treatments timestamp=" + JoH.dateTimeText(j3));
}
}
JoH.static_toast_long("Rejecting wear treatment as time out of range!");
UserError.Log.e("jamorham watchupdater", "Rejecting wear treatment due to time: " + string + " since: " + msSince);
Log.d("jamorham watchupdater", "syncTreatmentsData add Table record=" + string);
j2 = 1 + j3;
Log.d("jamorham watchupdater", "syncTreatmentsData WATCH treatments timestamp=" + JoH.dateTimeText(j3));
}
}
}
}
break loop0;
}
sendDataReceived("/xdrip_plus_data-item-received", "DATA_RECEIVED_LOGS count=" + dataMapArrayList.size(), j, z ? "BM" : "TREATMENTS", -1L);
}
}
public static void sendWearToast(String str, int i) {
GoogleApiClient googleApiClient2 = googleApiClient;
if (googleApiClient2 != null && googleApiClient2.isConnected()) {
PutDataMapRequest create = PutDataMapRequest.create("/xdrip_plus_toast");
create.setUrgent();
create.getDataMap().putDouble("timestamp", System.currentTimeMillis());
create.getDataMap().putInt("length", i);
create.getDataMap().putString("msg", str);
Wearable.DataApi.putDataItem(googleApiClient, create.asPutDataRequest());
return;
}
Log.e("jamorham watchupdater", "No connection to wearable available for toast! " + str);
}
public static void sendWearLocalToast(String str, int i) {
GoogleApiClient googleApiClient2 = googleApiClient;
if (googleApiClient2 != null && googleApiClient2.isConnected()) {
PutDataMapRequest create = PutDataMapRequest.create("/xdrip_plus_local_toast");
create.setUrgent();
create.getDataMap().putDouble("timestamp", System.currentTimeMillis());
create.getDataMap().putInt("length", i);
create.getDataMap().putString("msg", str);
Wearable.DataApi.putDataItem(googleApiClient, create.asPutDataRequest());
return;
}
Log.e("jamorham watchupdater", "No connection to wearable available for toast! " + str);
}
public static void sendTreatment(double d, double d2, double d3, String str, double d4, String str2) {
GoogleApiClient googleApiClient2 = googleApiClient;
if (googleApiClient2 != null && googleApiClient2.isConnected()) {
PutDataMapRequest create = PutDataMapRequest.create("/xdrip_plus_treatment_payload");
create.setUrgent();
create.getDataMap().putDouble("timestamp", System.currentTimeMillis());
create.getDataMap().putDouble("carbs", d);
create.getDataMap().putDouble("insulin", d2);
create.getDataMap().putDouble("bloodtest", d3);
create.getDataMap().putDouble("timeoffset", d4);
create.getDataMap().putString("timestring", str2);
create.getDataMap().putString("injectionJSON", str);
create.getDataMap().putBoolean("ismgdl", doMgdl(PreferenceManager.getDefaultSharedPreferences(xdrip.getAppContext())));
Wearable.DataApi.putDataItem(googleApiClient, create.asPutDataRequest());
return;
}
Log.e("jamorham watchupdater", "No connection to wearable available for send treatment!");
}
private static boolean doMgdl(SharedPreferences sharedPreferences) {
return sharedPreferences.getString("units", "mgdl").compareTo("mgdl") == 0;
}
@Override
public void onCreate() {
SharedPreferences defaultSharedPreferences = PreferenceManager.getDefaultSharedPreferences(getApplicationContext());
this.mPrefs = defaultSharedPreferences;
this.wear_integration = defaultSharedPreferences.getBoolean("wear_sync", false);
this.is_using_bt = DexCollectionType.hasBluetooth();
if (this.wear_integration) {
googleApiConnect();
}
setSettings();
listenForChangeInSettings();
}
class AnonymousClass1 implements SharedPreferences.OnSharedPreferenceChangeListener {
AnonymousClass1() {
}
@Override
public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String str) {
WatchUpdaterService watchUpdaterService = WatchUpdaterService.this;
watchUpdaterService.pebble_integration = watchUpdaterService.mPrefs.getBoolean("pebble_sync", false);
if (str.compareTo("bridge_battery") == 0 || str.compareTo("nfc_sensor_age") == 0 || str.compareTo("bg_notifications_watch") == 0 || str.compareTo("persistent_high_alert_enabled_watch") == 0) {
return;
}
Log.d("jamorham watchupdater", "Triggering Wear Settings Update due to key=" + str);
Inevitable.task("wear-update-settings", 2000L, new Runnable() {
@Override
public final void run() {
WatchUpdaterService.AnonymousClass1.this.lambda$onSharedPreferenceChanged$0();
}
});
}
public void lambda$onSharedPreferenceChanged$0() {
WatchUpdaterService.this.sendPrefSettings();
WatchUpdaterService.this.processConnect();
}
}
private void listenForChangeInSettings() {
AnonymousClass1 anonymousClass1 = new AnonymousClass1();
this.mPreferencesListener = anonymousClass1;
this.mPrefs.registerOnSharedPreferenceChangeListener(anonymousClass1);
}
private void setSettings() {
Log.d("jamorham watchupdater", "setSettings enter");
this.pebble_integration = this.mPrefs.getBoolean("pebble_sync", false);
processConnect();
if (this.wear_integration) {
if (googleApiClient == null) {
googleApiConnect();
}
Log.d("jamorham watchupdater", "setSettings wear_sync changed to True.");
sendPrefSettings();
}
}
private void googleApiConnect() {
GoogleApiClient googleApiClient2 = googleApiClient;
if (googleApiClient2 != null && (googleApiClient2.isConnected() || googleApiClient.isConnecting())) {
googleApiClient.disconnect();
}
googleApiClient = new GoogleApiClient.Builder(this).addConnectionCallbacks(this).addOnConnectionFailedListener(this).addApi(Wearable.API).build();
Wearable.MessageApi.addListener(googleApiClient, this);
if (googleApiClient.isConnected()) {
Log.d("WatchUpdater", "API client is connected");
} else {
googleApiClient.connect();
}
}
private void forceGoogleApiConnect() {
GoogleApiClient googleApiClient2 = googleApiClient;
if ((googleApiClient2 == null || googleApiClient2.isConnected() || googleApiClient.isConnecting()) && googleApiClient != null) {
return;
}
try {
Log.d("jamorham watchupdater", "forceGoogleApiConnect: forcing google api reconnection");
googleApiConnect();
Thread.sleep(2000L);
} catch (InterruptedException e) {
Log.d("jamorham watchupdater", "forceGoogleApiConnect: exception:" + e);
}
}
@Override
public void onPeerConnected(Node node) {
super.onPeerConnected(node);
String id = node.getId();
Log.d("jamorham watchupdater", "onPeerConnected peer name & ID: " + node.getDisplayName() + "|" + id);
sendPrefSettings();
if (this.mPrefs.getBoolean("enable_wearG5", false)) {
Log.d("jamorham watchupdater", "onPeerConnected call initWearData for node=" + node.getDisplayName());
initWearData();
if (this.mPrefs.getBoolean("force_wearG5", false)) {
Log.d("jamorham watchupdater", "onPeerConnected force_wearG5=true Phone stopBtService and continue to use Wear G5 BT Collector");
stopBtService();
} else {
Log.d("jamorham watchupdater", "onPeerConnected onPeerConnected force_wearG5=false Phone startBtService");
startBtService();
}
}
}
@Override
public void onPeerDisconnected(Node node) {
super.onPeerDisconnected(node);
String id = node.getId();
Log.d("jamorham watchupdater", "onPeerDisconnected peer name & ID: " + node.getDisplayName() + "|" + id);
if (PreferenceManager.getDefaultSharedPreferences(getApplicationContext()).getBoolean("watch_integration", false)) {
Log.d("jamorham watchupdater", "onPeerDisconnected watch_integration=true Phone startBtService");
startBtService();
}
}
private boolean isServiceRunning(Class<?> cls) {
if (cls == null) {
return false;
}
Iterator<ActivityManager.RunningServiceInfo> it = ((ActivityManager) getSystemService("activity")).getRunningServices(Integer.MAX_VALUE).iterator();
while (it.hasNext()) {
if (cls.getName().equals(it.next().service.getClassName())) {
return true;
}
}
return false;
}
private boolean isCollectorRunning() {
Class<?> collectorServiceClass = DexCollectionType.getCollectorServiceClass();
if (collectorServiceClass == null) {
return false;
}
Log.d("jamorham watchupdater", "DexCollectionType.getCollectorServiceClass(): " + collectorServiceClass.getName());
return isServiceRunning(collectorServiceClass);
}
public void startBtService() {
Log.d("jamorham watchupdater", "startBtService");
boolean hasBluetooth = DexCollectionType.hasBluetooth();
this.is_using_bt = hasBluetooth;
if (hasBluetooth) {
if (!isCollectorRunning()) {
CollectionServiceStarter.startBtService(getApplicationContext());
Log.d("jamorham watchupdater", "startBtService startService");
return;
} else {
Log.d("jamorham watchupdater", "startBtService collector already running!");
return;
}
}
Log.d("jamorham watchupdater", "Not starting any BT Collector service as it is not our data source");
}
public void stopBtService() {
Log.d("jamorham watchupdater", "stopService call stopService");
CollectionServiceStarter.stopBtService(getApplicationContext());
Log.d("jamorham watchupdater", "stopBtService should have called onDestroy");
}
public static void startSelf() {
Inevitable.task("wear-startself", 2000L, new Runnable() {
@Override
public final void run() {
WatchUpdaterService.lambda$startSelf$0();
}
});
}
public static void lambda$startSelf$0() {
if (JoH.ratelimit("start-wear", 5)) {
startServiceAndResendData(0L);
}
}
public static void startServiceAndResendData(long j) {
UserError.Log.d("jamorham watchupdater", "Requesting to resend data");
xdrip.getAppContext().startService(new Intent(xdrip.getAppContext(), (Class<?>) WatchUpdaterService.class).setAction(ACTION_RESEND).putExtra("resend-since", j));
}
public static void startServiceAndResendDataIfNeeded(long j) {
if (isEnabled() && JoH.ratelimit("wear-resend-data", 60)) {
startServiceAndResendData(j);
}
}
@Override
public int onStartCommand(Intent intent, int i, int i2) {
PowerManager.WakeLock wakeLock = JoH.getWakeLock("watchupdate-onstart", UsbId.SILABS_CP2102);
this.wear_integration = this.mPrefs.getBoolean("wear_sync", false);
String action = intent != null ? intent.getAction() : null;
if (this.wear_integration) {
this.is_using_bt = DexCollectionType.hasBluetooth();
GoogleApiClient googleApiClient2 = googleApiClient;
if (googleApiClient2 != null) {
if (googleApiClient2.isConnected()) {
if (ACTION_RESEND.equals(action)) {
resendData(intent.getLongExtra("resend-since", 0L));
} else if (ACTION_OPEN_SETTINGS.equals(action)) {
Log.d("jamorham watchupdater", "onStartCommand Action=ACTION_OPEN_SETTINGS");
sendNotification("/openwearsettings", "openSettings");
} else if (ACTION_SEND_TOAST.equals(action)) {
Log.d("jamorham watchupdater", "onStartCommand Action=ACTION_SEND_TOAST msg=" + intent.getStringExtra("msg"));
sendWearLocalToast(intent.getStringExtra("msg"), 1);
} else {
String str = ACTION_SEND_STATUS;
if (str.equals(action)) {
Log.d("jamorham watchupdater", "onStartCommand Action=" + str + " externalStatusString=" + intent.getStringExtra("externalStatusString"));
sendRequestExtra("/sendstatustowear", "externalStatusString", intent.getStringExtra("externalStatusString"));
} else {
String str2 = ACTION_SNOOZE_ALERT;
if (str2.equals(action)) {
Log.d("jamorham watchupdater", "onStartCommand Action=" + str2 + " repeatTime=" + intent.getStringExtra("repeatTime"));
sendRequestExtra("/xdrip_plus_snooze_payload", "repeatTime", intent.getStringExtra("repeatTime"));
} else {
String str3 = ACTION_SYNC_DB;
if (str3.equals(action)) {
Log.d("jamorham watchupdater", "onStartCommand Action=" + str3 + " Path=/xdrip_plus_syncweardb");
sendNotification("/xdrip_plus_syncweardb", "syncDB");
initWearData();
} else {
String str4 = ACTION_RESET_DB;
if (str4.equals(action)) {
Log.d("jamorham watchupdater", "onStartCommand Action=" + str4 + " Path=/xdrip_plus_resetweardb");
sendNotification("/xdrip_plus_resetweardb", "resetDB");
initWearData();
} else {
if (ACTION_DISABLE_FORCE_WEAR.equals(action)) {
int readPrefsInt = readPrefsInt(this.mPrefs, "disable_wearG5_on_missedreadings_level", 30);
Log.d("jamorham watchupdater", "onStartCommand Action=ACTION_DISABLE_FORCE_WEAR");
Pref.setBoolean("force_wearG5", false);
String string = getResources().getString(2131755939, Integer.valueOf(readPrefsInt));
JoH.static_toast_long(string);
Log.e("jamorham watchupdater", "wearIsConnected disable force_wearG5:" + Pref.getBooleanDefaultFalse("force_wearG5") + " msg=" + string);
sendWearLocalToast(string, 1);
} else {
String str5 = ACTION_START_COLLECTOR;
if (str5.equals(action)) {
Log.d("jamorham watchupdater", "onStartCommand Action=" + str5 + " Path=/xdrip_plus_startcollector");
sendNotification("/xdrip_plus_startcollector", "startCOLLECTOR");
} else if (ACTION_STATUS_COLLECTOR.equals(action)) {
Log.d("jamorham watchupdater", "onStartCommand Action=ACTION_STATUS_COLLECTOR Path=STATUS_COLLECTOR_PATH getBatteryStatusNow=" + intent.getBooleanExtra("getBatteryStatusNow", false));
sendRequestExtra("/xdrip_plus_statuscollector", "getBatteryStatusNow", intent.getBooleanExtra("getBatteryStatusNow", false));
} else if (ACTION_SYNC_LOGS.equals(action)) {
long j = syncLogsRequested;
long j2 = j == 0 ? 2L : j * 10;
Log.d("jamorham watchupdater", "onStartCommand Action ACTION_SYNC_LOGS=ACTION_SYNC_LOGS SYNC_LOGS_PATH syncLogsRequested=" + syncLogsRequested);
if (JoH.ratelimit("sync-logs-requested", (int) j2)) {
long j3 = syncLogsRequested + 1;
syncLogsRequested = j3;
sendRequestExtra("/xdrip_plus_syncwearlogs", "syncLogsRequested", String.valueOf(j3));
}
Log.d("jamorham watchupdater", "onStartCommand Action ACTION_SYNC_LOGS=ACTION_SYNC_LOGS SYNC_LOGS_PATH syncLogsRequested=" + syncLogsRequested + " ratelimit=" + j2);
} else {
String str6 = ACTION_CLEAR_LOGS;
if (str6.equals(action)) {
Log.d("jamorham watchupdater", "onStartCommand Action=" + str6 + " Path=/xdrip_plus_clearwearlogs");
sendNotification("/xdrip_plus_clearwearlogs", "clearLOG");
} else {
String str7 = ACTION_SYNC_SENSOR;
if (str7.equals(action)) {
Log.d("jamorham watchupdater", "onStartCommand Action=" + str7 + " Path=/xdrip_plus_watch_sensor_data");
sendSensorData();
} else {
String str8 = ACTION_SYNC_ACTIVEBTDEVICE;
if (str8.equals(action)) {
Log.d("jamorham watchupdater", "onStartCommand Action=" + str8 + " Path=/xdrip_plus_watch_activebtdevice_data");
sendActiveBtDeviceData();
} else {
String str9 = ACTION_SYNC_ALERTTYPE;
if (str9.equals(action)) {
Log.d("jamorham watchupdater", "onStartCommand Action=" + str9 + " Path=/xdrip_plus_watch_alerttype_data");
sendAlertTypeData();
} else {
String str10 = ACTION_SYNC_CALIBRATION;
if (str10.equals(action)) {
Log.d("jamorham watchupdater", "onStartCommand Action=" + str10 + " Path=/xdrip_plus_watch_cal_data");
sendWearCalibrationData(sendCalibrationCount);
boolean z = this.mPrefs.getBoolean("rewrite_history", false);
Log.d("jamorham watchupdater", "onStartCommand adjustRecentBgReadings for rewrite_history=" + z);
sendWearBgData(Integer.valueOf(z ? 30 : 2));
sendData();
} else {
String str11 = ACTION_SEND_G5_QUEUE;
if (str11.equals(action)) {
Log.d("jamorham watchupdater", "onStartCommand Action = " + str11 + " PAth= /xdrip_plus_watch_g5_queue");
sendG5QueueData(intent.getStringExtra("queueData"));
} else {
Log.d("jamorham watchupdater", "onStartCommand Action= Path=/nightscout_watch_data");
sendData();
}
}
}
}
}
}
}
}
}
}
}
}
}
} else {
googleApiClient.connect();
}
} else {
Log.wtf("jamorham watchupdater", "GoogleAPI client is null!");
}
}
if (this.pebble_integration) {
sendData();
}
if (!this.wear_integration) {
Log.i("jamorham watchupdater", "Stopping service");
startBtService();
stopSelf();
JoH.releaseWakeLock(wakeLock);
return 2;
}
JoH.releaseWakeLock(wakeLock);
return 1;
}
public void updateWearSyncBgsCapability() {
CapabilityInfo capability;
CapabilityApi.GetCapabilityResult await = Wearable.CapabilityApi.getCapability(googleApiClient, "wear_app_sync_bgs", 1).await(5000L, TimeUnit.MILLISECONDS);
if (!await.getStatus().isSuccess()) {
Log.e("jamorham watchupdater", "updateWearSyncBgsCapability Failed to get capabilities, status: " + await.getStatus().getStatusMessage());
capability = null;
} else {
capability = await.getCapability();
}
if (capability == null || capability.getNodes().size() <= 0) {
return;
}
Log.d("jamorham watchupdater", "Updating wear sync nodes");
updateWearSyncBgsCapability(capability);
}
public void updateWearSyncBgsCapability(CapabilityInfo capabilityInfo) {
this.mWearNodeId = pickBestNodeId(capabilityInfo.getNodes());
}
private String pickBestNodeId(Set<Node> set) {
String str = null;
for (Node node : set) {
if (node.isNearby()) {
return node.getId();
}
str = node.getId();
}
return str;
}
public void setLocalNodeName() {
String str;
forceGoogleApiConnect();
Node node = Wearable.NodeApi.getLocalNode(googleApiClient).await(60L, TimeUnit.SECONDS).getNode();
if (node != null) {
str = node.getDisplayName() + "|" + node.getId();
} else {
str = "";
}
localnode = str;
UserError.Log.d("jamorham watchupdater", "setLocalNodeName. localnode=" + localnode);
}
@Override
public void onConnected(Bundle bundle) {
Log.d("jamorham watchupdater", "onConnected entered");
sendData();
}
@Override
public void onCapabilityChanged(CapabilityInfo capabilityInfo) {
updateWearSyncBgsCapability(capabilityInfo);
Log.d("jamorham watchupdater", "onConnected onCapabilityChanged mWearNodeID:" + this.mWearNodeId);
new CheckWearableConnected(this, null).execute(new Void[0]);
}
private class CheckWearableConnected extends AsyncTask<Void, Void, Void> {
private CheckWearableConnected() {
}
CheckWearableConnected(WatchUpdaterService watchUpdaterService, AnonymousClass1 anonymousClass1) {
this();
}
@Override
public Void doInBackground(Void... voidArr) {
CapabilityInfo capability;
if (!WatchUpdaterService.googleApiClient.isConnected()) {
Log.d("jamorham watchupdater", "Not connected for sending");
WatchUpdaterService.googleApiClient.connect();
} else if (System.currentTimeMillis() - WatchUpdaterService.lastRequest > 20000) {
long unused = WatchUpdaterService.lastRequest = System.currentTimeMillis();
if (WatchUpdaterService.localnode == null || (WatchUpdaterService.localnode != null && WatchUpdaterService.localnode.isEmpty())) {
WatchUpdaterService.this.setLocalNodeName();
}
boolean z = true;
CapabilityApi.GetCapabilityResult await = Wearable.CapabilityApi.getCapability(WatchUpdaterService.googleApiClient, "wear_app_sync_bgs", 1).await(5000L, TimeUnit.MILLISECONDS);
if (!await.getStatus().isSuccess()) {
Log.e("jamorham watchupdater", "doInBackground Failed to get capabilities, status: " + await.getStatus().getStatusMessage());
capability = null;
} else {
capability = await.getCapability();
}
SharedPreferences defaultSharedPreferences = PreferenceManager.getDefaultSharedPreferences(WatchUpdaterService.this.getApplicationContext());
SharedPreferences.Editor edit = PreferenceManager.getDefaultSharedPreferences(WatchUpdaterService.this.getApplicationContext()).edit();
boolean z2 = defaultSharedPreferences.getBoolean("enable_wearG5", false);
boolean z3 = defaultSharedPreferences.getBoolean("force_wearG5", false);
String string = WatchUpdaterService.this.mPrefs.getString("node_wearG5", "");
if (capability != null && capability.getNodes().size() > 0) {
WatchUpdaterService.this.updateWearSyncBgsCapability(capability);
int size = capability.getNodes().size();
StringBuilder sb = new StringBuilder();
sb.append("doInBackground connected. CapabilityApi.GetCapabilityResult mWearNodeID=");
sb.append(WatchUpdaterService.this.mWearNodeId != null ? WatchUpdaterService.this.mWearNodeId : "");
sb.append(" count=");
sb.append(size);
Log.d("jamorham watchupdater", sb.toString());
Iterator<Node> it = capability.getNodes().iterator();
while (true) {
if (!it.hasNext()) {
z = false;
break;
}
Node next = it.next();
String str = next.getDisplayName() + "|" + next.getId();
Log.d("jamorham watchupdater", "CheckWearableConnected onPeerConnected peer name & ID: " + str);
if (str.equals(string)) {
WatchUpdaterService.this.sendPrefSettings();
break;
}
if (string.equals("")) {
edit.putString("node_wearG5", str);
edit.apply();
break;
}
}
WatchUpdaterService.this.sendPrefSettings();
WatchUpdaterService.this.initWearData();
if (z2) {
if (z3 && z) {
Log.d("jamorham watchupdater", "CheckWearableConnected onPeerConnected force_wearG5=true Phone stopBtService and continue to use Wear BT Collector");
WatchUpdaterService.this.stopBtService();
} else {
Log.d("jamorham watchupdater", "CheckWearableConnected onPeerConnected force_wearG5=false Phone startBtService");
WatchUpdaterService.this.startBtService();
}
}
} else {
Log.d("jamorham watchupdater", "CheckWearableConnected onPeerDisconnected");
if (defaultSharedPreferences.getBoolean("wear_sync", false)) {
Log.d("jamorham watchupdater", "CheckWearableConnected onPeerDisconnected wear_sync=true Phone startBtService");
WatchUpdaterService.this.startBtService();
}
}
} else {
Log.d("jamorham watchupdater", "Debounce limit hit - not sending");
}
return null;
}
}
@Override
public void onDataChanged(DataEventBuffer dataEventBuffer) {
Iterator<DataEvent> it = dataEventBuffer.iterator();
while (it.hasNext()) {
DataEvent next = it.next();
if (next.getType() == 1) {
String path = next.getDataItem().getUri().getPath();
path.hashCode();
if (path.equals("/xdrip_plus_watch_pref_data")) {
DataMap dataMap = DataMapItem.fromDataItem(next.getDataItem()).getDataMap();
if (dataMap != null) {
Log.d("jamorham watchupdater", "onDataChanged WEARABLE_PREF_DATA_PATH dataMap=" + dataMap);
syncPrefData(dataMap);
}
} else {
Log.d("jamorham watchupdater", "Unknown wearable path: " + path);
}
}
}
}
@Override
public void onMessageReceived(MessageEvent messageEvent) {
int i;
String str;
String str2;
DataMap fromByteArray;
DataMap fromByteArray2;
DataMap fromByteArray3;
DataMap fromByteArray4;
DataMap fromByteArray5;
Log.d("jamorham watchupdater", "onMessageReceived enter");
if (this.wear_integration) {
PowerManager.WakeLock wakeLock = JoH.getWakeLock("watchupdate-msgrec", UsbId.SILABS_CP2102);
if (messageEvent != null) {
Log.d("jamorham watchupdater", "onMessageReceived wearable event path: " + messageEvent.getPath());
String path = messageEvent.getPath();
path.hashCode();
i = 30;
switch (path) {
case "/xdrip_plus_approve_treatment":
approveTreatment(getApplicationContext(), "");
break;
case "/xdrip_plus_syncwearbgs_BM_RAND_COMPRESS":
case "/xdrip_plus_syncwearlogs_BM_RAND_COMPRESS":
Log.d("jamorham watchupdater", "onMessageReceived Ignore, just for test!");
decompressBytes(messageEvent.getPath(), messageEvent.getData(), true);
break;
case "/xdrip_plus_syncwearlogs_BM_COMPRESS":
case "/xdrip_plus_syncwearlogs_BM_DUP_COMPRESS":
Log.d("jamorham watchupdater", "onMessageReceived Ignore, just for test!");
DataMap fromByteArray6 = DataMap.fromByteArray(decompressBytes(messageEvent.getPath(), messageEvent.getData(), true));
if (fromByteArray6 != null) {
syncLogData(fromByteArray6, true);
break;
}
break;
case "/xdrip_plus_syncwearlogs_BM_DUP":
case "/xdrip_plus_syncwearlogs_BM_RAND":
case "/xdrip_plus_syncwearbgs_BM":
case "/xdrip_plus_syncwearlogs_BM":
case "/xdrip_plus_syncwearbgs_BM_DUP":
case "/xdrip_plus_syncwearbgs_BM_RAND":
Log.d("jamorham watchupdater", "onMessageReceived Ignore, just for test!");
messageEvent.getData();
break;
case "/xdrip_plus_syncwearbgs2":
Log.d("jamorham watchupdater", "onMessageReceived /xdrip_plus_syncwearbgs2");
final DataMap fromByteArray7 = DataMap.fromByteArray(decompressBytes(messageEvent.getPath(), messageEvent.getData(), false));
if (fromByteArray7 != null) {
new LowPriorityThread(new Runnable() {
@Override
public final void run() {
WatchUpdaterService.this.lambda$onMessageReceived$1(fromByteArray7);
}
}, "inbound-precalculated-bg").start();
break;
}
break;
case "/xdrip_plus_syncwearlogs":
Log.d("jamorham watchupdater", "onMessageReceived SYNC_LOGS_PATH");
if (messageEvent.getData() != null && (fromByteArray = DataMap.fromByteArray(decompressBytes(messageEvent.getPath(), messageEvent.getData(), false))) != null) {
Log.d("jamorham watchupdater", "onMessageReceived SYNC_LOGS_PATH");
syncLogData(fromByteArray, false);
break;
}
break;
case "/xdrip_plus_battery_payload":
DataMap fromByteArray8 = DataMap.fromByteArray(messageEvent.getData());
if (fromByteArray8 != null) {
Log.d("jamorham watchupdater", "onMessageReceived WEARABLE_FIELD_SENDPATH dataMap=" + fromByteArray8);
syncFieldData(fromByteArray8);
break;
}
break;
case "/xdrip_plus_watch_data_replymsg":
Log.d("jamorham watchupdater", "onMessageReceived WEARABLE_REPLYMSG_PATH");
DataMap fromByteArray9 = DataMap.fromByteArray(messageEvent.getData());
if (fromByteArray9 != null) {
Log.d("jamorham watchupdater", "onMessageReceived WEARABLE_REPLYMSG_PATH dataMap=" + fromByteArray9);
String string = fromByteArray9.getString("action_path", "");
if (string != null && !string.isEmpty()) {
if (!string.equals("/xdrip_plus_startcollector")) {
if (string.equals("/xdrip_plus_statuscollector")) {
Log.d("jamorham watchupdater", "onMessageReceived WEARABLE_REPLYMSG_PATH send LocalBroadcastManager ACTION_BLUETOOTH_COLLECTION_SERVICE_UPDATE=com.eveningoutpost.dexdrip.BLUETOOTH_COLLECTION_SERVICE_UPDATE");
Intent intent = new Intent("com.eveningoutpost.dexdrip.BLUETOOTH_COLLECTION_SERVICE_UPDATE");
intent.putExtra("data", fromByteArray9.toBundle());
LocalBroadcastManager.getInstance(xdrip.getAppContext()).sendBroadcast(intent);
break;
}
} else {
JoH.static_toast_short(fromByteArray9.getString("msg", ""));
break;
}
}
}
break;
case "/xdrip_plus_syncwearstepsensor":
Log.d("jamorham watchupdater", "onMessageReceived SYNC_STEP_SENSOR_PATH");
if (messageEvent.getData() != null && (fromByteArray2 = DataMap.fromByteArray(messageEvent.getData())) != null) {
Log.d("jamorham watchupdater", "onMessageReceived SYNC_STEP_SENSOR_PATH dataMap=" + fromByteArray2);
syncStepSensorData(fromByteArray2, false);
break;
}
break;
case "/xdrip_plus_watch_data_inittreatments":
Log.d("jamorham watchupdater", "onMessageReceived WEARABLE_INITTREATMENTS_PATH");
initWearTreatments();
break;
case "/xdrip_plus_locale_changed_data":
Log.d("jamorham watchupdater", "onMessageReceived WEARABLE_LOCALE_CHANGED_PATH");
sendLocale();
break;
case "/xdrip_plus_syncwearbgs_BM_DUP_COMPRESS":
case "/xdrip_plus_syncwearbgs_BM_COMPRESS":
Log.d("jamorham watchupdater", "onMessageReceived Ignore, just for test!");
DataMap fromByteArray10 = DataMap.fromByteArray(decompressBytes(messageEvent.getPath(), messageEvent.getData(), true));
if (fromByteArray10 != null) {
syncTransmitterData(fromByteArray10, true);
break;
}
break;
case "/xdrip_plus_cancel_treatment":
cancelTreatment(getApplicationContext(), "");
break;
case "/xdrip_plus_snooze_payload":
try {
str = new String(messageEvent.getData(), "UTF-8");
} catch (UnsupportedEncodingException unused) {
str = "30";
}
try {
i = Integer.parseInt(str);
} catch (NumberFormatException unused2) {
}
Log.d("jamorham watchupdater", "Received wearable: snooze payload: " + i);
AlertPlayer.getPlayer().Snooze(xdrip.getAppContext(), i, true);
JoH.static_toast_long(getResources().getString(2131755111));
break;
case "/xdrip_plus_voice_payload":
try {
str2 = new String(messageEvent.getData(), "UTF-8");
} catch (UnsupportedEncodingException unused3) {
str2 = "error";
}
Log.d("jamorham watchupdater", "Received wearable: voice payload: " + str2);
if (str2.length() > 1) {
receivedText(getApplicationContext(), str2);
break;
}
break;
case "/xdrip_plus_watch_data_initprefs":
Log.d("jamorham watchupdater", "onMessageReceived WEARABLE_INITPREFS_PATH");
sendPrefSettings();
break;
case "/xdrip_plus_watch_pref_data":
DataMap fromByteArray11 = DataMap.fromByteArray(messageEvent.getData());
if (fromByteArray11 != null) {
Log.d("jamorham watchupdater", "onMessageReceived WEARABLE_PREF_DATA_PATH dataMap=" + fromByteArray11);
syncPrefData(fromByteArray11);
break;
}
break;
case "/xdrip_plus_syncwearbgs":
Log.d("jamorham watchupdater", "onMessageReceived SYNC_BGS_PATH");
if (messageEvent.getData() != null && (fromByteArray3 = DataMap.fromByteArray(messageEvent.getData())) != null) {
Log.d("jamorham watchupdater", "onMessageReceived SYNC_BGS_PATH dataMap=" + fromByteArray3);
syncTransmitterData(fromByteArray3, false);
break;
}
break;
case "/xdrip_plus_syncwearlogsrequested":
DataMap fromByteArray12 = DataMap.fromByteArray(messageEvent.getData());
if (fromByteArray12 != null) {
syncLogsRequested = fromByteArray12.getLong("syncLogsRequested", -1L);
Log.d("jamorham watchupdater", "onMessageReceived SYNC_LOGS_REQUESTED_PATH syncLogsRequested=" + syncLogsRequested);
break;
}
break;
case "/xdrip_plus_watch_data_initdb":
Log.d("jamorham watchupdater", "onMessageReceived WEARABLE_INITDB_PATH");
initWearData();
break;
case "/nightscout_watch_data_resend":
resendData(0L);
break;
case "/xdrip_plus_syncwearheartsensor":
Log.d("jamorham watchupdater", "onMessageReceived SYNC_HEART_SENSOR_PATH");
if (messageEvent.getData() != null && (fromByteArray4 = DataMap.fromByteArray(messageEvent.getData())) != null) {
Log.d("jamorham watchupdater", "onMessageReceived SYNC_HEART_SENSOR_PATH dataMap=" + fromByteArray4);
syncHeartSensorData(fromByteArray4, false);
break;
}
break;
case "/xdrip_plus_syncweartreatments":
Log.d("jamorham watchupdater", "onMessageReceived SYNC_TREATMENTS_PATH");
if (messageEvent.getData() != null && (fromByteArray5 = DataMap.fromByteArray(messageEvent.getData())) != null) {
Log.d("jamorham watchupdater", "onMessageReceived SYNC_TREATMENTS_PATH dataMap=" + fromByteArray5);
syncTreatmentsData(fromByteArray5, false);
break;
}
break;
default:
if (messageEvent.getPath().startsWith("/xdrip_plus_can_i_has_apk")) {
if (JoH.ratelimit("/xdrip_plus_can_i_has_apk", 15)) {
JoH.static_toast_short("Updating wear app");
String[] split = messageEvent.getPath().split("\\^");
int parseInt = split.length == 2 ? Integer.parseInt(split[1]) : 0;
if (parseInt == 0) {
UserError.Log.uel("jamorham watchupdater", "VUP: Sending latest apk version to watch");
JoH.static_toast_long("Sending latest version to watch");
}
new Thread(new AnonymousClass2(parseInt)).start();
break;
}
} else {
Log.d("jamorham watchupdater", "Unknown wearable path: " + messageEvent.getPath());
super.onMessageReceived(messageEvent);
break;
}
break;
}
}
JoH.releaseWakeLock(wakeLock);
return;
}
super.onMessageReceived(messageEvent);
}
public void lambda$onMessageReceived$1(DataMap dataMap) {
syncBgReadingsData(dataMap);
Home.staticRefreshBGCharts();
}
class AnonymousClass2 implements Runnable {
final int val$finalStartAt;
AnonymousClass2(int i) {
this.val$finalStartAt = i;
}
@Override
public void run() {
if (WatchUpdaterService.this.mWearNodeId == null) {
UserError.Log.d("jamorham watchupdater", "VUP: nodeid is null");
WatchUpdaterService.this.updateWearSyncBgsCapability();
}
if (WatchUpdaterService.this.mWearNodeId != null) {
UserError.Log.d("jamorham watchupdater", "VUP: nodeid is now not null");
if (WatchUpdaterService.apkBytes == null) {
UserError.Log.d("jamorham watchupdater", "VUP: getting bytes");
byte[] unused = WatchUpdaterService.apkBytes = GetWearApk.getBytes();
}
if (WatchUpdaterService.apkBytes != null) {
UserError.Log.d("jamorham watchupdater", "VUP: Trying to open channel to send apk");
final Channel channel = Wearable.ChannelApi.openChannel(WatchUpdaterService.googleApiClient, WatchUpdaterService.this.mWearNodeId, "/updated-apk").await().getChannel();
if (channel != null) {
channel.getOutputStream(WatchUpdaterService.googleApiClient).setResultCallback(new ResultCallback<Channel.GetOutputStreamResult>() {
@Override
public void onResult(final Channel.GetOutputStreamResult getOutputStreamResult) {
Log.d("jamorham watchupdater", "VUP: channel get outputstream onResult:");
new Thread(new Runnable() {
@Override
public void run() {
OutputStream outputStream = null;
try {
try {
outputStream = getOutputStreamResult.getOutputStream();
Log.d("jamorham watchupdater", "VUP: output stream opened");
outputStream.write("0463377-2025.07.16\n".getBytes("UTF-8"));
outputStream.write((WatchUpdaterService.apkBytes.length + "\n").getBytes("UTF-8"));
outputStream.write((AnonymousClass2.this.val$finalStartAt + "\n").getBytes("UTF-8"));
JoH.threadSleep(5000L);
Log.d("jamorham watchupdater", "VUP: sending data");
outputStream.write(WatchUpdaterService.apkBytes, AnonymousClass2.this.val$finalStartAt, WatchUpdaterService.apkBytes.length - AnonymousClass2.this.val$finalStartAt);
outputStream.flush();
outputStream.write(new byte[64000]);
JoH.threadSleep(5000L);
Log.d("jamorham watchupdater", "VUP: sent bytes: " + (WatchUpdaterService.apkBytes.length - AnonymousClass2.this.val$finalStartAt));
try {
try {
Log.w("jamorham watchupdater", "VUP: Closing output stream");
outputStream.close();
} catch (IOException e) {
Log.w("jamorham watchupdater", "VUP: could not close Output Stream: Node ID: " + channel.getNodeId() + " Path: " + channel.getPath() + " Error message: " + e.getMessage() + " Error cause: " + e.getCause());
}
} finally {
}
} catch (IOException e2) {
Log.w("jamorham watchupdater", "VUP: could not send message: Node: " + channel.getNodeId() + "Path: " + channel.getPath() + " Error message: " + e2.getMessage() + " Error cause: " + e2.getCause());
try {
try {
Log.w("jamorham watchupdater", "VUP: Closing output stream");
if (outputStream != null) {
outputStream.close();
}
} finally {
}
} catch (IOException e3) {
Log.w("jamorham watchupdater", "VUP: could not close Output Stream: Node ID: " + channel.getNodeId() + " Path: " + channel.getPath() + " Error message: " + e3.getMessage() + " Error cause: " + e3.getCause());
}
}
} catch (Throwable th) {
try {
try {
Log.w("jamorham watchupdater", "VUP: Closing output stream");
if (outputStream != null) {
outputStream.close();
}
} catch (IOException e4) {
Log.w("jamorham watchupdater", "VUP: could not close Output Stream: Node ID: " + channel.getNodeId() + " Path: " + channel.getPath() + " Error message: " + e4.getMessage() + " Error cause: " + e4.getCause());
}
throw th;
} finally {
}
}
}
}).start();
}
});
return;
} else {
UserError.Log.d("jamorham watchupdater", "VUP: Could not send wearable apk as Channel result was null!");
return;
}
}
return;
}
Log.d("jamorham watchupdater", "VUP: Could not send wearable apk as nodeid is currently null");
}
}
private byte[] decompressBytes(String str, byte[] bArr, boolean z) {
if (bArr.length <= 8 || bArr[0] != 31 || bArr[1] != -117 || bArr[2] != 8 || bArr[3] != 0) {
Log.d("jamorham watchupdater", "Benchmark: decompressBytesToBytes DataMap is not compressed! Process as normal. length=" + bArr.length);
return bArr;
}
if (z) {
double ts = JoH.ts();
JoH.benchmark(null);
byte[] decompressBytesToBytes = JoH.decompressBytesToBytes(bArr);
String str2 = str + " JoH.decompressBytesToBytes from length=" + bArr.length + " to length=" + decompressBytesToBytes.length;
JoH.benchmark(str2);
sendDataReceived("/xdrip_plus_data-item-received", str2 + " " + (JoH.ts() - ts) + " ms", 1L, "BM", -1L);
return decompressBytesToBytes;
}
byte[] decompressBytesToBytes2 = JoH.decompressBytesToBytes(bArr);
Log.d("jamorham watchupdater", str + " JoH.decompressBytesToBytes from length=" + bArr.length + " to length=" + decompressBytesToBytes2.length);
return decompressBytesToBytes2;
}
private void sendG5QueueData(String str) {
if (!this.wear_integration || str == null) {
return;
}
forceGoogleApiConnect();
new SendToDataLayerThread("/xdrip_plus_watch_g5_queue", googleApiClient).executeOnExecutor(xdrip.executor, dataMap("queueData", str));
}
private void sendData() {
BgReading last = BgReading.last();
if (last != null) {
forceGoogleApiConnect();
if (this.wear_integration) {
new SendToDataLayerThread("/nightscout_watch_data", googleApiClient).executeOnExecutor(xdrip.executor, dataMap(last, this.mPrefs, new BgGraphBuilder(getApplicationContext()), PowerStateReceiver.getBatteryLevel(getApplicationContext())));
}
}
}
private void resendData(long j) {
Log.d("jamorham watchupdater", "resendData ENTER");
forceGoogleApiConnect();
if (j == 0) {
j = new Date().getTime() - 86400000;
}
Log.d("jamorham watchupdater", "resendData googleApiClient connected ENTER, sending since: " + JoH.dateTimeText(j));
BgReading last = BgReading.last();
if (last != null) {
List<BgReading> latestForGraph = BgReading.latestForGraph(60, j);
BgGraphBuilder bgGraphBuilder = new BgGraphBuilder(getApplicationContext());
if (latestForGraph.isEmpty()) {
return;
}
int batteryLevel = PowerStateReceiver.getBatteryLevel(getApplicationContext());
DataMap dataMap = dataMap(last, this.mPrefs, bgGraphBuilder, batteryLevel);
ArrayList<DataMap> arrayList = new ArrayList<>(latestForGraph.size());
Iterator<BgReading> it = latestForGraph.iterator();
while (it.hasNext()) {
arrayList.add(dataMap(it.next(), this.mPrefs, bgGraphBuilder, batteryLevel));
}
dataMap.putLong("time", new Date().getTime());
dataMap.putDataMapArrayList("entries", arrayList);
if (this.mPrefs.getBoolean("extra_status_line", false)) {
dataMap.putString("extra_status_line", StatusLine.extraStatusLine());
}
new SendToDataLayerThread("/nightscout_watch_data", googleApiClient).executeOnExecutor(xdrip.executor, dataMap);
}
}
private void sendNotification(String str, String str2) {
forceGoogleApiConnect();
if (googleApiClient.isConnected()) {
Log.d("jamorham watchupdater", "sendNotification Notification=" + str2 + " Path=" + str);
PutDataMapRequest create = PutDataMapRequest.create(str);
create.setUrgent();
create.getDataMap().putDouble("timestamp", (double) System.currentTimeMillis());
create.getDataMap().putString(str2, str2);
Wearable.DataApi.putDataItem(googleApiClient, create.asPutDataRequest());
return;
}
Log.e("jamorham watchupdater", "sendNotification No connection to wearable available!");
}
private void sendRequestExtra(String str, String str2, String str3) {
forceGoogleApiConnect();
if (googleApiClient.isConnected()) {
PutDataMapRequest create = PutDataMapRequest.create(str);
create.getDataMap().putDouble("timestamp", System.currentTimeMillis());
create.getDataMap().putString(str2, str3);
Wearable.DataApi.putDataItem(googleApiClient, create.asPutDataRequest());
return;
}
Log.e("sendRequestExtra", "No connection to wearable available!");
}
private void sendRequestExtra(String str, String str2, boolean z) {
forceGoogleApiConnect();
if (googleApiClient.isConnected()) {
PutDataMapRequest create = PutDataMapRequest.create(str);
create.getDataMap().putDouble("timestamp", System.currentTimeMillis());
create.getDataMap().putBoolean(str2, z);
Wearable.DataApi.putDataItem(googleApiClient, create.asPutDataRequest());
return;
}
Log.e("sendRequestExtra", "No connection to wearable available!");
}
private DataMap dataMap(BgReading bgReading, SharedPreferences sharedPreferences, BgGraphBuilder bgGraphBuilder, int i) {
Double valueOf = Double.valueOf(Double.parseDouble(sharedPreferences.getString("highValue", "170")));
Double valueOf2 = Double.valueOf(Double.parseDouble(sharedPreferences.getString("lowValue", "70")));
DataMap dataMap = new DataMap();
BestGlucose.DisplayGlucose displayGlucose = BestGlucose.getDisplayGlucose();
dataMap.putString("sgvString", (displayGlucose == null || bgReading.dg_mgdl <= BgReading.BESTOFFSET) ? bgGraphBuilder.unitized_string(bgReading.calculated_value) : displayGlucose.unitized);
dataMap.putString("slopeArrow", bgReading.slopeArrow());
dataMap.putDouble("timestamp", bgReading.timestamp);
if (displayGlucose != null) {
dataMap.putString("delta", displayGlucose.unitized_delta);
} else {
dataMap.putString("delta", bgGraphBuilder.unitizedDeltaString(true, true, true));
}
dataMap.putString("battery", "" + i);
double d = bgReading.dg_mgdl;
if (d <= BgReading.BESTOFFSET) {
d = bgReading.calculated_value;
}
dataMap.putLong("sgvLevel", sgvLevel(d, sharedPreferences, bgGraphBuilder));
dataMap.putInt("batteryLevel", i < 30 ? 0 : 1);
double d2 = bgReading.dg_mgdl;
if (d2 <= BgReading.BESTOFFSET) {
d2 = bgReading.calculated_value;
}
dataMap.putDouble("sgvDouble", d2);
dataMap.putDouble("high", inMgdl(valueOf.doubleValue(), sharedPreferences));
dataMap.putDouble("low", inMgdl(valueOf2.doubleValue(), sharedPreferences));
dataMap.putInt("bridge_battery", this.mPrefs.getInt("bridge_battery", -1));
return dataMap;
}
private void sendLocale() {
String str;
Locale locale = Locale.getDefault();
Log.d("jamorham watchupdater", "ACTION_LOCALE_CHANGED Locale changed to " + locale);
String country = locale.getCountry();
StringBuilder sb = new StringBuilder();
sb.append(locale.getLanguage());
if (country == null || country.isEmpty()) {
str = "";
} else {
str = "_" + country;
}
sb.append(str);
sendRequestExtra("/xdrip_plus_locale_changed_data", "locale", sb.toString());
}
public void sendPrefSettings() {
String str;
boolean z;
boolean z2;
String str2;
forceGoogleApiConnect();
DataMap dataMap = new DataMap();
List<String> booleansToSync = WearSyncBooleans.getBooleansToSync();
List<String> persistentStrings = WearSyncPersistentStrings.getPersistentStrings();
boolean z3 = this.mPrefs.getBoolean("wear_sync", false);
this.wear_integration = z3;
String str3 = "";
if (z3) {
Log.d("jamorham watchupdater", "sendPrefSettings wear_sync=true");
str = this.mPrefs.getString("dex_collection_method", "DexcomG5");
z = this.mPrefs.getBoolean("enable_wearG5", false);
z2 = this.mPrefs.getBoolean("force_wearG5", false);
str2 = this.mPrefs.getString("node_wearG5", "");
dataMap.putString("dex_collection_method", str);
dataMap.putBoolean("rewrite_history", this.mPrefs.getBoolean("rewrite_history", false));
dataMap.putBoolean("enable_wearG5", z);
dataMap.putBoolean("force_wearG5", z2);
dataMap.putString("node_wearG5", str2);
dataMap.putString("share_key", this.mPrefs.getString("share_key", "SM00000000"));
dataMap.putBoolean("use_transmiter_pl_bluetooth", this.mPrefs.getBoolean("use_transmiter_pl_bluetooth", false));
dataMap.putBoolean("use_rfduino_bluetooth", this.mPrefs.getBoolean("use_rfduino_bluetooth", false));
dataMap.putBoolean("automatically_turn_bluetooth_on", this.mPrefs.getBoolean("automatically_turn_bluetooth_on", true));
dataMap.putBoolean("bluetooth_excessive_wakelocks", this.mPrefs.getBoolean("bluetooth_excessive_wakelocks", true));
dataMap.putBoolean("close_gatt_on_ble_disconnect", this.mPrefs.getBoolean("close_gatt_on_ble_disconnect", true));
dataMap.putBoolean("bluetooth_frequent_reset", this.mPrefs.getBoolean("bluetooth_frequent_reset", false));
dataMap.putBoolean("bluetooth_watchdog", this.mPrefs.getBoolean("bluetooth_watchdog", false));
dataMap.putString("bluetooth_watchdog_timer", this.mPrefs.getString("bluetooth_watchdog_timer", "20"));
dataMap.putInt("bridge_battery", this.mPrefs.getInt("bridge_battery", -1));
dataMap.putInt("nfc_sensor_age", this.mPrefs.getInt("nfc_sensor_age", -1));
dataMap.putBoolean("sync_wear_logs", this.mPrefs.getBoolean("sync_wear_logs", false));
dataMap.putString("persistent_high_repeat_mins", this.mPrefs.getString("persistent_high_repeat_mins", "20"));
dataMap.putString("persistent_high_threshold_mins", this.mPrefs.getString("persistent_high_threshold_mins", "60"));
dataMap.putBoolean("falling_alert", this.mPrefs.getBoolean("falling_alert", false));
dataMap.putString("falling_bg_val", this.mPrefs.getString("falling_bg_val", "2"));
dataMap.putBoolean("rising_alert", this.mPrefs.getBoolean("rising_alert", false));
dataMap.putString("rising_bg_val", this.mPrefs.getString("rising_bg_val", "2"));
dataMap.putBoolean("aggressive_service_restart", this.mPrefs.getBoolean("aggressive_service_restart", false));
dataMap.putBoolean("extra_status_line", this.mPrefs.getBoolean("extra_status_line", false));
dataMap.putBoolean("extra_status_stats_24h", Pref.getBooleanDefaultFalse("extra_status_stats_24h"));
dataMap.putBoolean("status_line_calibration_long", this.mPrefs.getBoolean("status_line_calibration_long", false));
dataMap.putBoolean("status_line_calibration_short", this.mPrefs.getBoolean("status_line_calibration_short", false));
dataMap.putBoolean("status_line_avg", this.mPrefs.getBoolean("status_line_avg", false));
dataMap.putBoolean("status_line_a1c_dcct", this.mPrefs.getBoolean("status_line_a1c_dcct", false));
dataMap.putBoolean("status_line_a1c_ifcc", this.mPrefs.getBoolean("status_line_a1c_ifcc", false));
dataMap.putBoolean("status_line_in", this.mPrefs.getBoolean("status_line_in", false));
dataMap.putBoolean("status_line_high", this.mPrefs.getBoolean("status_line_high", false));
dataMap.putBoolean("status_line_low", this.mPrefs.getBoolean("status_line_low", false));
dataMap.putBoolean("status_line_carbs", this.mPrefs.getBoolean("status_line_carbs", false));
dataMap.putBoolean("status_line_insulin", this.mPrefs.getBoolean("status_line_insulin", false));
dataMap.putBoolean("status_line_stdev", this.mPrefs.getBoolean("status_line_stdev", false));
dataMap.putBoolean("status_line_royce_ratio", this.mPrefs.getBoolean("status_line_royce_ratio", false));
dataMap.putBoolean("status_line_capture_percentage", this.mPrefs.getBoolean("status_line_capture_percentage", false));
dataMap.putBoolean("status_line_realtime_capture_percentage", this.mPrefs.getBoolean("status_line_realtime_capture_percentage", false));
dataMap.putBoolean("extra_status_calibration_plugin", this.mPrefs.getBoolean("extra_status_calibration_plugin", false));
dataMap.putBoolean("display_glucose_from_plugin", Pref.getBooleanDefaultFalse("display_glucose_from_plugin"));
dataMap.putBoolean("use_pluggable_alg_as_primary", Pref.getBooleanDefaultFalse("use_pluggable_alg_as_primary"));
if (Pref.getBooleanDefaultFalse("engineering_mode")) {
dataMap.putBoolean("old_school_calibration_mode", Pref.getBooleanDefaultFalse("old_school_calibration_mode"));
}
dataMap.putBoolean("show_wear_treatments", Pref.getBooleanDefaultFalse("show_wear_treatments"));
dataMap.putBoolean("use_ob1_g5_collector_service", Pref.getBooleanDefaultFalse("use_ob1_g5_collector_service"));
dataMap.putString("Blukon-bluetooth-pin", Pref.getStringDefaultBlank("Blukon-bluetooth-pin"));
String extractDexTime = Ob1G5StateMachine.extractDexTime();
if (extractDexTime != null) {
dataMap.putString("dex-timekeeping", extractDexTime);
}
} else {
str = "None";
z = false;
z2 = false;
str2 = "";
}
dataMap.putBoolean("use_wear_health", this.mPrefs.getBoolean("use_pebble_health", true));
this.is_using_bt = DexCollectionType.hasBluetooth();
Double valueOf = Double.valueOf(Double.parseDouble(this.mPrefs.getString("highValue", "170")));
Double valueOf2 = Double.valueOf(Double.parseDouble(this.mPrefs.getString("lowValue", "70")));
Log.d("jamorham watchupdater", "sendPrefSettings enable_wearG5: " + z + " force_wearG5:" + z2 + " node_wearG5:" + str2 + " dex_collection_method:" + str);
dataMap.putLong("time", new Date().getTime());
dataMap.putString("dex_txid", this.mPrefs.getString("dex_txid", "ABCDEF"));
dataMap.putString("units", this.mPrefs.getString("units", "mgdl"));
dataMap.putDouble("high", valueOf.doubleValue());
dataMap.putDouble("low", valueOf2.doubleValue());
dataMap.putBoolean("g5_non_raw_method", this.mPrefs.getBoolean("g5_non_raw_method", false));
dataMap.putString("extra_tags_for_logging", Pref.getStringDefaultBlank("extra_tags_for_logging"));
dataMap.putBoolean("bridge_battery_alerts", Pref.getBooleanDefaultFalse("bridge_battery_alerts"));
dataMap.putString("bridge_battery_alert_level", Pref.getString("bridge_battery_alert_level", "30"));
Locale locale = Locale.getDefault();
String country = locale.getCountry();
StringBuilder sb = new StringBuilder();
sb.append(locale.getLanguage());
if (country != null && !country.isEmpty()) {
str3 = "_" + country;
}
sb.append(str3);
dataMap.putString("locale", sb.toString());
dataMap.putString("build-version-name", getVersionID());
for (String str4 : booleansToSync) {
dataMap.putBoolean(str4, Pref.getBooleanDefaultFalse(str4));
}
for (String str5 : persistentStrings) {
dataMap.putString(str5, PersistentStore.getString(str5));
}
new SendToDataLayerThread("/xdrip_plus_watch_pref_data", googleApiClient).executeOnExecutor(xdrip.executor, dataMap);
}
private boolean sendSensorData() {
try {
GoogleApiClient googleApiClient2 = googleApiClient;
if (googleApiClient2 != null && !googleApiClient2.isConnected() && !googleApiClient.isConnecting()) {
googleApiClient.connect();
}
if (googleApiClient != null) {
Sensor currentSensor = Sensor.currentSensor();
if (currentSensor != null) {
if (this.wear_integration) {
DataMap dataMap = new DataMap();
Log.d("jamorham watchupdater", "Sensor sendSensorData uuid=" + currentSensor.uuid + " started_at=" + currentSensor.started_at + " active=" + Sensor.isActive() + " battery=" + currentSensor.latest_battery_level + " location=" + currentSensor.sensor_location + " stopped_at=" + currentSensor.stopped_at);
String s = currentSensor.toS();
StringBuilder sb = new StringBuilder();
sb.append("dataMap sendSensorData GSON: ");
sb.append(s);
Log.d("jamorham watchupdater", sb.toString());
dataMap.putLong("time", new Date().getTime());
dataMap.putString("dex_txid", this.mPrefs.getString("dex_txid", "ABCDEF"));
dataMap.putLong("started_at", currentSensor.started_at);
dataMap.putString("uuid", currentSensor.uuid);
dataMap.putInt("latest_battery_level", currentSensor.latest_battery_level);
dataMap.putString("sensor_location", currentSensor.sensor_location);
new SendToDataLayerThread("/xdrip_plus_watch_sensor_data", googleApiClient).executeOnExecutor(xdrip.executor, dataMap);
return true;
}
} else {
Log.e("jamorham watchupdater", "sendSensorData current sensor is null!");
}
return true;
}
Log.e("jamorham watchupdater", "sendSensorData No connection to wearable available for send Sensor!");
return false;
} catch (NullPointerException e) {
Log.e("jamorham watchupdater", "Nullpointer exception in sendWearCalibrationData: " + e);
return false;
}
}
private void sendActiveBtDeviceData() {
if (this.is_using_bt) {
forceGoogleApiConnect();
ActiveBluetoothDevice first = ActiveBluetoothDevice.first();
if (first == null || !this.wear_integration) {
return;
}
DataMap dataMap = new DataMap();
Log.d("jamorham watchupdater", "sendActiveBtDeviceData name=" + first.name + " address=" + first.address + " connected=" + first.connected);
dataMap.putLong("time", new Date().getTime());
dataMap.putString("name", first.name);
dataMap.putString("address", first.address);
dataMap.putBoolean("connected", first.connected);
new SendToDataLayerThread("/xdrip_plus_watch_activebtdevice_data", googleApiClient).executeOnExecutor(xdrip.executor, dataMap);
return;
}
Log.d("jamorham watchupdater", "Not sending activebluetoothdevice data as we are not using bt");
}
private void sendAlertTypeData() {
try {
forceGoogleApiConnect();
List<AlertType> allActive = AlertType.getAllActive();
if (allActive != null) {
if (this.wear_integration) {
Log.d("jamorham watchupdater", "sendAlertTypeData latest count = " + allActive.size());
DataMap dataMap = new DataMap();
ArrayList<DataMap> arrayList = new ArrayList<>(allActive.size());
for (AlertType alertType : allActive) {
if (alertType != null) {
arrayList.add(dataMap(alertType, "alert"));
}
}
dataMap.putLong("time", new Date().getTime());
dataMap.putDataMapArrayList("entries", arrayList);
new SendToDataLayerThread("/xdrip_plus_watch_alerttype_data", googleApiClient).executeOnExecutor(xdrip.executor, dataMap);
return;
}
Log.d("jamorham watchupdater", "sendAlertTypeData latest count = 0");
}
} catch (NullPointerException e) {
Log.e("jamorham watchupdater", "Nullpointer exception in sendAlertTypeData: " + e);
}
}
private DataMap dataMap(String str, String str2) {
DataMap dataMap = new DataMap();
dataMap.putString(str, str2);
return dataMap;
}
private DataMap dataMap(AlertType alertType, String str) {
DataMap dataMap = new DataMap();
String s = alertType.toS();
Log.d("jamorham watchupdater", "dataMap BG GSON: " + s);
dataMap.putString(str, s);
return dataMap;
}
public static boolean sendWearUpload(List<BgReading> list, List<Calibration> list2, List<BloodTest> list3, List<Treatments> list4, List<String> list5) {
return sendWearCalibrationData(0, 0L, list2) && sendWearBloodTestData(0, 0L, list3) && sendWearTreatmentsData(0, 0L, list4) && sendWearTreatmentsDataDelete(list5) && sendWearBgData(0, 0L, list);
}
public static boolean sendWearTreatmentsDataDelete(List<String> list) {
GoogleApiClient googleApiClient2 = googleApiClient;
if (googleApiClient2 != null && !googleApiClient2.isConnected() && !googleApiClient.isConnecting()) {
googleApiClient.connect();
}
if (googleApiClient != null) {
if (!list.isEmpty()) {
Log.d("jamorham watchupdater", "sendWearTreatmentsDataDelete graph size=" + list.size());
DataMap dataMap = new DataMap();
dataMap.putLong("time", new Date().getTime());
dataMap.putString("action", "delete");
dataMap.putStringArrayList("entries", new ArrayList<>(list));
new SendToDataLayerThread("/xdrip_plus_watch_treatments_data", googleApiClient).executeOnExecutor(xdrip.executor, dataMap);
} else {
Log.d("jamorham watchupdater", "sendWearTreatmentsDataDelete treatments count = 0");
}
return true;
}
Log.e("jamorham watchupdater", "sendWearTreatmentsData No connection to wearable available for send treatment!");
return false;
}
public static boolean sendWearTreatmentsData(Integer num, long j) {
return sendWearTreatmentsData(num, j, null);
}
public static boolean sendWearTreatmentsData(Integer num, long j, List<Treatments> list) {
try {
GoogleApiClient googleApiClient2 = googleApiClient;
if (googleApiClient2 != null && !googleApiClient2.isConnected() && !googleApiClient.isConnecting()) {
googleApiClient.connect();
}
if (googleApiClient != null) {
Treatments last = (list == null || list.size() <= 0) ? Treatments.last() : list.get(0);
if (last != null) {
Log.d("jamorham watchupdater", "sendWearTreatmentsData last.timestamp:" + JoH.dateTimeText(last.timestamp));
if (list == null) {
if (j == 0) {
list = Treatments.latest(num.intValue());
} else {
list = Treatments.latestForGraph(num.intValue(), j);
}
}
if (!list.isEmpty()) {
Log.d("jamorham watchupdater", "sendWearTreatmentsData graph size=" + list.size());
ArrayList<DataMap> arrayList = new ArrayList<>(list.size());
DataMap dataMap = dataMap(last);
Iterator<Treatments> it = list.iterator();
while (it.hasNext()) {
arrayList.add(dataMap(it.next()));
}
Log.d("jamorham watchupdater", "sendWearTreatmentsData entries=" + dataMap);
dataMap.putLong("time", new Date().getTime());
dataMap.putString("action", "insert");
dataMap.putDataMapArrayList("entries", arrayList);
new SendToDataLayerThread("/xdrip_plus_watch_treatments_data", googleApiClient).executeOnExecutor(xdrip.executor, dataMap);
} else {
Log.d("jamorham watchupdater", "sendWearTreatmentsData treatments count = 0");
}
return true;
}
Log.d("jamorham watchupdater", "sendWearTreatmentsData no treatments exist");
return true;
}
Log.e("jamorham watchupdater", "sendWearTreatmentsData No connection to wearable available for send treatment!");
return false;
} catch (NullPointerException e) {
Log.e("jamorham watchupdater", "Nullpointer exception in sendWearTreatmentsData: " + e);
return false;
}
}
private static DataMap dataMap(Treatments treatments) {
DataMap dataMap = new DataMap();
String s = treatments.toS();
Log.d("jamorham watchupdater", "dataMap BG GSON: " + s);
dataMap.putString("data", s);
return dataMap;
}
public static boolean sendWearBloodTestData(Integer num, long j) {
return sendWearBloodTestData(num, j, null);
}
public static boolean sendWearBloodTestData(Integer num, long j, List<BloodTest> list) {
try {
GoogleApiClient googleApiClient2 = googleApiClient;
if (googleApiClient2 != null && !googleApiClient2.isConnected() && !googleApiClient.isConnecting()) {
googleApiClient.connect();
}
if (googleApiClient != null) {
BloodTest last = (list == null || list.size() <= 0) ? BloodTest.last() : list.get(0);
if (last != null) {
Log.d("jamorham watchupdater", "sendWearBloodTestData last.timestamp:" + JoH.dateTimeText(last.timestamp));
if (list == null) {
if (j == 0) {
list = BloodTest.last(num.intValue());
} else {
list = BloodTest.latestForGraph(num.intValue(), j);
}
}
if (!list.isEmpty()) {
Log.d("jamorham watchupdater", "sendWearBloodTestData graph size=" + list.size());
ArrayList<DataMap> arrayList = new ArrayList<>(list.size());
DataMap dataMap = dataMap(last);
Iterator<BloodTest> it = list.iterator();
while (it.hasNext()) {
arrayList.add(dataMap(it.next()));
}
Log.d("jamorham watchupdater", "sendWearBloodTestData entries=" + dataMap);
dataMap.putLong("time", new Date().getTime());
dataMap.putDataMapArrayList("entries", arrayList);
new SendToDataLayerThread("/xdrip_plus_watch_bloodtest_data", googleApiClient).executeOnExecutor(xdrip.executor, dataMap);
} else {
Log.d("jamorham watchupdater", "sendWearBloodTestData BloodTest count = 0");
}
return true;
}
Log.d("jamorham watchupdater", "sendWearBloodTestData no BloodTest exist");
return true;
}
Log.e("jamorham watchupdater", "sendWearBloodTestData No connection to wearable available for send BloodTest!");
return false;
} catch (NullPointerException e) {
Log.e("jamorham watchupdater", "Nullpointer exception in sendWearBloodTestData: " + e);
return false;
}
}
private static DataMap dataMap(BloodTest bloodTest) {
DataMap dataMap = new DataMap();
String s = bloodTest.toS();
Log.d("jamorham watchupdater", "dataMap BG GSON: " + s);
dataMap.putString("data", s);
return dataMap;
}
private boolean sendWearCalibrationData(Integer num) {
return sendWearCalibrationData(num, 0L);
}
private boolean sendWearCalibrationData(Integer num, long j) {
return sendWearCalibrationData(num, j, null);
}
private static boolean sendWearCalibrationData(Integer num, long j, List<Calibration> list) {
String str;
try {
GoogleApiClient googleApiClient2 = googleApiClient;
if (googleApiClient2 != null && !googleApiClient2.isConnected() && !googleApiClient.isConnecting()) {
googleApiClient.connect();
}
if (googleApiClient != null) {
Log.d("jamorham watchupdater", "sendWearCalibrationData");
Sensor currentSensor = Sensor.currentSensor();
Calibration last = (list == null || list.size() <= 0) ? Calibration.last() : list.get(0);
BgReading last2 = BgReading.last();
if (list == null) {
if (j != 0) {
list = Calibration.latestForGraphSensor(num.intValue(), j, Long.MAX_VALUE);
} else if (last2 != null && last2.calibration != null && last2.calibration_flag) {
Log.d("jamorham watchupdater", "sendWearCalibrationData lastBgReading.calibration_flag=" + last2.calibration_flag + " lastBgReading.timestamp: " + last2.timestamp + " lastBgReading.calibration.timestamp: " + last2.calibration.timestamp);
list = Calibration.allForSensor();
} else {
list = Calibration.latest(num.intValue());
}
}
if (currentSensor != null && last != null && list != null && !list.isEmpty()) {
Log.d("jamorham watchupdater", "sendWearCalibrationData latest count = " + list.size());
DataMap dataMap = dataMap(last);
ArrayList<DataMap> arrayList = new ArrayList<>(list.size());
if (currentSensor.uuid != null) {
for (Calibration calibration : list) {
if (calibration != null && (str = calibration.sensor_uuid) != null && str.equals(currentSensor.uuid)) {
arrayList.add(dataMap(calibration));
}
}
}
dataMap.putLong("time", new Date().getTime());
dataMap.putDataMapArrayList("entries", arrayList);
new SendToDataLayerThread("/xdrip_plus_watch_cal_data", googleApiClient).executeOnExecutor(xdrip.executor, dataMap);
} else {
Log.d("jamorham watchupdater", "sendWearCalibrationData latest count = 0");
}
return true;
}
Log.e("jamorham watchupdater", "sendWearCalibrationData No connection to wearable available for send treatment!");
return false;
} catch (NullPointerException e) {
Log.e("jamorham watchupdater", "Nullpointer exception in sendWearCalibrationData: " + e);
return false;
}
}
private static DataMap dataMap(Calibration calibration) {
DataMap dataMap = new DataMap();
String s = calibration.toS();
Log.d("jamorham watchupdater", "dataMap Calibration GSON: " + s);
dataMap.putString("bgs", s);
return dataMap;
}
private boolean sendWearBgData(Integer num) {
return sendWearBgData(num, 0L);
}
private boolean sendWearBgData(Integer num, long j) {
return sendWearBgData(num, j, null);
}
private static boolean sendWearBgData(Integer num, long j, List<BgReading> list) {
String str;
try {
GoogleApiClient googleApiClient2 = googleApiClient;
if (googleApiClient2 != null && !googleApiClient2.isConnected() && !googleApiClient.isConnecting()) {
googleApiClient.connect();
}
if (googleApiClient != null) {
Log.d("jamorham watchupdater", "sendWearBgData");
BgReading last = BgReading.last();
if (list == null) {
if (j != 0) {
list = BgReading.latestForGraphSensor(num.intValue(), j, Long.MAX_VALUE);
} else {
list = BgReading.latest(num.intValue());
}
}
if (last != null && list != null && !list.isEmpty()) {
int batteryLevel = PowerStateReceiver.getBatteryLevel(xdrip.getAppContext());
Log.d("jamorham watchupdater", "sendWearBgData latest count = " + list.size() + " battery=" + batteryLevel);
DataMap dataMap = dataMap(last);
ArrayList<DataMap> arrayList = new ArrayList<>(list.size());
Sensor currentSensor = Sensor.currentSensor();
if (currentSensor != null && currentSensor.uuid != null) {
for (BgReading bgReading : list) {
if (bgReading != null && bgReading.sensor_uuid == null) {
bgReading.sensor_uuid = currentSensor.uuid;
}
if (bgReading != null && (str = bgReading.sensor_uuid) != null && str.equals(currentSensor.uuid) && bgReading.calibration_uuid != null) {
arrayList.add(dataMap(bgReading));
} else {
if (bgReading.sensor_uuid == null) {
Log.d("jamorham watchupdater", "sendWearBgData: sensor uuid is null on record to send");
}
if (bgReading.calibration_uuid == null) {
Log.d("jamorham watchupdater", "sendWearBgData: calibration uuid is null on record to send");
}
}
}
} else {
StringBuilder sb = new StringBuilder();
sb.append("sendWearBgData Not queueing data due to sensor: ");
sb.append(currentSensor != null ? currentSensor.uuid : "null sensor object");
Log.d("jamorham watchupdater", sb.toString());
}
dataMap.putLong("time", new Date().getTime());
dataMap.putInt("battery", batteryLevel);
dataMap.putDataMapArrayList("entries", arrayList);
new SendToDataLayerThread("/xdrip_plus_watch_bg_data", googleApiClient).executeOnExecutor(xdrip.executor, dataMap);
} else {
Log.d("jamorham watchupdater", "sendWearBgData lastest count = 0");
}
return true;
}
Log.e("jamorham watchupdater", "sendWearBgData No connection to wearable available for send BG!");
return false;
} catch (NullPointerException e) {
Log.e("jamorham watchupdater", "Nullpointer exception in sendWearBgData: " + e);
return false;
}
}
private static DataMap dataMap(BgReading bgReading) {
DataMap dataMap = new DataMap();
try {
dataMap.putString("calibrationUuid", bgReading.calibration.uuid);
} catch (NullPointerException unused) {
Log.d("jamorham watchupdater", "Calibration uuid is not set in dataMap(BgReading)");
}
String s = bgReading.toS();
Log.d("jamorham watchupdater", "dataMap BG GSON: " + s);
dataMap.putString("bgs", s);
return dataMap;
}
public void initWearData() {
if (JoH.ratelimit("watch_init_wear_data", R$styleable.AppCompatTheme_windowFixedWidthMajor)) {
boolean z = this.mPrefs.getBoolean("wear_sync", false);
this.wear_integration = z;
if (z) {
Log.d("jamorham watchupdater", "***initWearData***");
sendSensorData();
sendActiveBtDeviceData();
sendAlertTypeData();
if (this.mPrefs.getBoolean("show_wear_treatments", false)) {
initWearTreatments();
} else {
sendWearCalibrationData(sendCalibrationCount);
sendWearBgData(sendBgCount);
}
sendData();
return;
}
Log.d("jamorham watchupdater", "Skip initWearData as wear integration is disabled");
return;
}
Log.d("jamorham watchupdater", "Skip initWearData due to exceeding ratelimit");
}
private void initWearTreatments() {
long time = new Date().getTime() - 259200000;
if (JoH.ratelimit("watch_init_wear_treatments_data", 60)) {
Log.d("jamorham watchupdater", "initWearTreatments clear treatments and re-init from startTime=" + JoH.dateTimeText(time));
sendNotification("/xdrip_plus_clearweartreatments", "clearTreatments");
Integer num = sendTreatmentsCount;
sendWearTreatmentsData(num, time);
sendWearBloodTestData(num, time);
sendWearCalibrationData(num, time);
sendWearBgData(num, time);
return;
}
Log.d("jamorham watchupdater", "Skip initWearTreatments due to exceeding ratelimit");
}
private long sgvLevel(double d, SharedPreferences sharedPreferences, BgGraphBuilder bgGraphBuilder) {
Double valueOf = Double.valueOf(Double.parseDouble(sharedPreferences.getString("highValue", "170")));
Double valueOf2 = Double.valueOf(Double.parseDouble(sharedPreferences.getString("lowValue", "70")));
if (bgGraphBuilder.unitized(d) >= valueOf.doubleValue()) {
return 1L;
}
return bgGraphBuilder.unitized(d) >= valueOf2.doubleValue() ? 0L : -1L;
}
private double inMgdl(double d, SharedPreferences sharedPreferences) {
return !doMgdl(sharedPreferences) ? d * 18.0182d : d;
}
public static int readPrefsInt(SharedPreferences sharedPreferences, String str, int i) {
try {
return Integer.parseInt(sharedPreferences.getString(str, "" + i));
} catch (Exception unused) {
return i;
}
}
@Override
public void onDestroy() {
SharedPreferences.OnSharedPreferenceChangeListener onSharedPreferenceChangeListener;
GoogleApiClient googleApiClient2 = googleApiClient;
if (googleApiClient2 != null && googleApiClient2.isConnected()) {
googleApiClient.disconnect();
}
SharedPreferences sharedPreferences = this.mPrefs;
if (sharedPreferences == null || (onSharedPreferenceChangeListener = this.mPreferencesListener) == null) {
return;
}
sharedPreferences.unregisterOnSharedPreferenceChangeListener(onSharedPreferenceChangeListener);
}
public static boolean isEnabled() {
return Pref.getBooleanDefaultFalse("wear_sync");
}
}