successfulUploads = new ArrayList<>();
91 | int apiVersion = 0;
92 | if (baseURI.endsWith("/v1/")) apiVersion = 1;
93 |
94 | String baseURL = null;
95 | String secret = null;
96 | String[] uriParts = baseURI.split("@");
97 |
98 | if (uriParts.length == 1 && apiVersion == 0) {
99 | baseURL = uriParts[0];
100 | } else if (uriParts.length == 1 && apiVersion > 0) {
101 | throw new Exception("Starting with API v1, a pass phase is required");
102 | } else if (uriParts.length == 2 && apiVersion > 0) {
103 | secret = uriParts[0];
104 | baseURL = uriParts[1];
105 | } else {
106 | throw new Exception("Unexpected baseURI");
107 | }
108 |
109 | String postURL = baseURL + "entries";
110 | Log.i(TAG, "postURL: " + postURL);
111 |
112 | HttpParams params = new BasicHttpParams();
113 | HttpConnectionParams.setSoTimeout(params, SOCKET_TIMEOUT);
114 | HttpConnectionParams.setConnectionTimeout(params, CONNECTION_TIMEOUT);
115 |
116 | DefaultHttpClient httpclient = new DefaultHttpClient(params);
117 |
118 | HttpPost post = new HttpPost(postURL);
119 |
120 | Header apiSecretHeader = null;
121 |
122 | if (apiVersion > 0) {
123 | if (secret == null || secret.isEmpty()) {
124 | throw new Exception("Starting with API v1, a pass phase is required");
125 | } else {
126 | MessageDigest digest = MessageDigest.getInstance("SHA-1");
127 | byte[] bytes = secret.getBytes("UTF-8");
128 | digest.update(bytes, 0, bytes.length);
129 | bytes = digest.digest();
130 | StringBuilder sb = new StringBuilder(bytes.length * 2);
131 | for (byte b: bytes) {
132 | sb.append(String.format("%02x", b & 0xff));
133 | }
134 | String token = sb.toString();
135 | apiSecretHeader = new BasicHeader("api-secret", token);
136 | }
137 | }
138 |
139 | if (apiSecretHeader != null) {
140 | post.setHeader(apiSecretHeader);
141 | }
142 |
143 | for (PredictionData record : glucoseDataSets) {
144 | JSONObject json = new JSONObject();
145 |
146 | try {
147 | if (apiVersion >= 1)
148 | populateV1APIBGEntry(json, record);
149 | else
150 | populateLegacyAPIEntry(json, record);
151 | } catch (Exception e) {
152 | Log.w(TAG, "Unable to populate entry");
153 | continue;
154 | }
155 |
156 | String jsonString = json.toString();
157 |
158 | Log.i(TAG, "SGV JSON: " + jsonString);
159 |
160 | StringEntity se = null;
161 | se = new StringEntity(jsonString);
162 | post.setEntity(se);
163 | post.setHeader("Accept", "application/json");
164 | post.setHeader("Content-type", "application/json");
165 |
166 | ResponseHandler responseHandler = new BasicResponseHandler();
167 | try {
168 | httpclient.execute(post, responseHandler);
169 | successfulUploads.add(record);
170 | } catch (IOException e) {
171 | Log.i(TAG, "ioexception: " + e);
172 | break;
173 | }
174 | }
175 | return successfulUploads;
176 | }
177 |
178 | private void populateV1APIBGEntry(JSONObject json, GlucoseData record) throws Exception {
179 | SimpleDateFormat format = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss a");
180 | format.setTimeZone(TimeZone.getDefault());
181 | json.put("device", "librealarm");
182 | json.put("date", record.realDate);
183 | json.put("dateString", format.format(record.realDate));
184 | json.put("sgv", record.glucoseLevel);
185 | json.put("direction", getSlopeName(record));
186 | json.put("type", "sgv");
187 | json.put("rssi", 100);
188 | }
189 |
190 | private void populateLegacyAPIEntry(JSONObject json, GlucoseData record) throws Exception {
191 | SimpleDateFormat format = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss a");
192 | format.setTimeZone(TimeZone.getDefault());
193 | json.put("device", "librealarm");
194 | json.put("date", record.realDate);
195 | json.put("dateString", format.format(record.realDate));
196 | json.put("sgv", record.glucoseLevel);
197 | json.put("direction", getSlopeName(record));
198 | }
199 |
200 | private String getSlopeName(GlucoseData data) {
201 | AlgorithmUtil.TrendArrow arrow = AlgorithmUtil.getTrendArrow(data);
202 | switch (arrow) {
203 | case UP:
204 | return "SingleUp";
205 | case DOWN:
206 | return "SingleDown";
207 | case SLIGHTLY_DOWN:
208 | return "FortyFiveDown";
209 | case SLIGHTLY_UP:
210 | return "FortyFiveUp";
211 | case FLAT:
212 | return "Flat";
213 | default:
214 | return "NONE";
215 | }
216 | }
217 | }
--------------------------------------------------------------------------------
/Application/src/main/res/values-sv/strings.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | Öppna drawer
5 |
6 |
7 | Stäng drawer
8 |
9 |
10 | ERR betyder att klockan misslyckats hämta glukosvärden.\n\nSe till att klockan sitter direkt på sensorn med klockskärmen mot sensorn.\n\nSe också till att NFC är igång på klockan. Kolla detta genom att öppna \"NFC configuration\" på klockan. Om det inte går att sätta igång NFC, starta om klockan och försök igen.
11 |
12 |
13 | Läs genom detta, det är viktigt!\n\n1, Detta är en inofficiell app som inte har godkänts av Abbott.\n\n2, Glukosvärderna från appen är inte exakta och går ej att lita på. Den enda meningen med appen är att larma vid för högt eller för lågt glukosvärde. Alla värden bör verifieras mot Abbotts egna verktyg.\n\n3, Lita inte på att appen alltid fungerar. Den kan sluta fungera utan varning eller ge felaktiga resultat.
14 |
15 |
16 | Disclaimer
17 |
18 |
19 | ERR
20 |
21 |
22 | STOPPA
23 |
24 |
25 | LARMA AV
26 |
27 |
28 | STARTA
29 |
30 |
31 | VÄNTA
32 |
33 |
34 | Kolla nu
35 |
36 |
37 | Detta är första gången ni öppar appen. Appen kanske inte har installerats på klockan ännu. V.g. vänta en kort stund och starta sen om appen.
38 |
39 |
40 | LARM!!
41 |
42 |
43 | "Försök %d/%d"
44 |
45 |
46 | "Försök %d/%d misslyckades"
47 |
48 |
49 | "Nästa koll: %s"
50 |
51 |
52 | Inte igång
53 |
54 |
55 | Nightscout
56 |
57 |
58 | Sätt igång Nightscout Rest API
59 |
60 |
61 | Sätt URL
62 |
63 |
64 | Aktivera
65 |
66 |
67 | Avaktivera %d min
68 |
69 |
70 | Stäng av
71 |
72 |
73 | Misslyckades att stänga av alarm
74 |
75 |
76 | Lågt blodsocker larm snoozat: %s
77 |
78 |
79 | Högt blodsocker larm snoozat: %s
80 |
81 |
82 | Använd mmol/l
83 |
84 |
85 | Gräns högt blodsocker
86 |
87 |
88 | Gräns lågt blodsocker
89 |
90 |
91 | Använd larm på telefon
92 |
93 |
94 | Snooza högt blodsocker
95 |
96 |
97 | Snooza lågt blodsocker
98 |
99 |
100 | Larm vid ERR
101 |
102 |
103 | Hur många ERR i rad krävs
104 |
105 |
106 | Värde på klocka: %s
107 |
108 |
109 | Inställningar
110 |
111 |
112 | Snooze
113 |
114 |
115 | Inställningar uppdaterade på klockan
116 |
117 |
118 | Generella inställningar
119 |
120 |
121 | Text-to-speech
122 |
123 |
124 | Använd Text-to-speech
125 |
126 |
127 | Få dina blodsockervärden upplästa
128 |
129 |
130 | Använd endast Text-to-speech vid larm
131 |
132 |
133 | Kunde inte initialisera Text-to-speech
134 |
135 |
136 | Blodsocker värdet är %s. Värdet %s
137 |
138 |
139 | går upp snabbt
140 |
141 |
142 | går upp långsamt
143 |
144 |
145 | är stabilt
146 |
147 |
148 | går ner snabbt
149 |
150 |
151 | går ner långsamt
152 |
153 |
154 | trend är okänt
155 |
156 |
157 | Det gick inte att mäta blodsockret
158 |
159 |
160 | Skicka data till xDrip+ som kör på samma enhet
161 |
162 |
163 | Avaktivera alla klock- och LibreAlarm larm och använd xDrip+ istället!
164 |
165 |
166 | Sätt blodsocker läsnings intervall
167 |
168 |
169 | Klocka ner CPU
170 |
171 |
172 | Kör klockan på lägsta processor hastighet för att spara batteri.
173 |
174 |
175 | Stäng av touchscreen helt
176 |
177 |
178 | För att åter aktivera touchscreen, stäng av detta och tryck på klockans power knapp tills den startar om
179 |
180 |
181 | Aktivera root funktioner
182 |
183 |
184 | Kräver rootad klocka
185 |
186 |
187 |
--------------------------------------------------------------------------------
/Application/src/main/res/values-es/strings.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | abrir carpeta
5 |
6 |
7 | cerar carpeta
8 |
9 |
10 | ERR significa el reloj no pudo leer valor de glucosa.\n\nProura mantener reloj justo encima del sensor con la superficie hacia el sensor.\n\Tambien procura tener nfc activado. Controla esto abriendo la aplicacion \"NFC configuration\" en el reloj. Si es posible activar nfc, vuelve a iniciar el reloj.
11 |
12 |
13 | Por favor lee esto, \'es importante!\n\n1, Esto es una aplicacion no oficial y no ha sido aprobado en ningun sentido por Abbott.\n\n2, Los valores de glucosa producidos por esta aplicacion no son exactos. La unica intencion de esta aplicacion es para alarmar el usario cuando el nivel de glucosa es muy alto o muy bajo. Todos los datos deben ser controlados usando las herramientas oficiales de Abbott.\n\n3, No te fies de la aplicacion para evitar fallos. Podria dejar de funcionar sin avisar o / y producir resultados no fiables.
14 |
15 |
16 | exclusion de resposabilidad
17 |
18 |
19 | ERR
20 |
21 |
22 | STOP
23 |
24 |
25 | ALARMA
26 |
27 |
28 | INICIO
29 |
30 |
31 | ESPERA
32 |
33 |
34 | escanear ahora
35 |
36 |
37 | Esto es el primer inicio. El reloj a lo mejor no esta instalado todavia. Por favor espere un momento, luego vuelve an iniciar el reloj.
38 |
39 |
40 | ALARMA!!
41 |
42 |
43 | "Intentos %d/%d"
44 |
45 |
46 | "Intentos %d/%d fallados"
47 |
48 |
49 | "Proximo escan: %s"
50 |
51 |
52 | No funcionando
53 |
54 |
55 | Nightscout
56 |
57 |
58 | Activar Nightscout Rest API
59 |
60 |
61 | Set URL
62 |
63 |
64 | activar
65 |
66 |
67 | apagar %d min
68 |
69 |
70 | Apagar
71 |
72 |
73 | Apagar fallado
74 |
75 |
76 | glucosa baja alarma apagado: %s
77 |
78 |
79 | glucosa alta alarma apagado: %s
80 |
81 |
82 | Usa mmol/l
83 |
84 |
85 | Limite glucosa alta
86 |
87 |
88 | Limite glucosa baja
89 |
90 |
91 | Usa sonido de alarma del movil
92 |
93 |
94 | apagar alarma glucosa alta
95 |
96 |
97 | apagar alarma glucosa baja
98 |
99 |
100 | Alarma on ERR
101 |
102 |
103 | Cuantos ERR seguidos necesarios
104 |
105 |
106 | Datos en reloj: %s
107 |
108 |
109 | Preferencias
110 |
111 |
112 | dormir/apagar
113 |
114 |
115 | Valores actualizados en el reloj
116 |
117 |
118 | Valores generales
119 |
120 |
121 | Texto-en-voz
122 |
123 |
124 | Usa Texto-en-voz
125 |
126 |
127 | Deja leer tu valor de glucosa en voz alta
128 |
129 |
130 | Usa texto-en-voz solo con alarmas
131 |
132 |
133 | Iniciar texto-en-voz fallado
134 |
135 |
136 | Valor de glucosa es %s. Tendencia es %s
137 |
138 |
139 | aumentando rapido
140 |
141 |
142 | aumentando despacio
143 |
144 |
145 | estable
146 |
147 |
148 | bajando rapido
149 |
150 |
151 | bajando despacio
152 |
153 |
154 | tendencia no clara
155 |
156 |
157 | escan de glucosa fallado
158 |
159 |
160 | Manda datos a xDrip+ funcionando en el mismo aparato
161 |
162 |
163 | apagar todos alarmas del reloj y de LibreAlarm y usar xDrip+ para alarmas!
164 |
165 |
166 | editar interval de escan de glucosa
167 |
168 |
169 | reducir CPU del reloj
170 |
171 |
172 | poner reloj a velocidad minima del procesor para ahorar bateria.
173 |
174 |
175 | Apagar pantalla tactil del reloj completamente
176 |
177 |
178 | Para volver a encender pantalla tactil del reloj, apagar reloj y apretar boton hasta re-inicio
179 |
180 |
181 | Activar root funcionamiento
182 |
183 |
184 | Se necesita rooted reloj
185 |
186 |
187 |
--------------------------------------------------------------------------------
/Wearable/src/main/java/com/pimpimmobile/librealarm/WearIntentService.java:
--------------------------------------------------------------------------------
1 | package com.pimpimmobile.librealarm;
2 |
3 | import android.app.IntentService;
4 | import android.content.Intent;
5 | import android.content.Context;
6 | import android.nfc.NfcAdapter;
7 | import android.nfc.NfcManager;
8 | import android.os.Bundle;
9 | import android.os.PowerManager;
10 | import android.util.Log;
11 |
12 | import com.google.android.gms.common.api.GoogleApiClient;
13 | import com.google.android.gms.wearable.MessageApi;
14 | import com.google.android.gms.wearable.Wearable;
15 | import com.pimpimmobile.librealarm.shareddata.PreferencesUtil;
16 | import com.pimpimmobile.librealarm.shareddata.Status;
17 |
18 | /**
19 | * An {@link IntentService} subclass for handling asynchronous task requests in
20 | * a service on a separate handler thread.
21 | *
22 | * TODO: Customize class - update intent actions, extra parameters and static
23 | * helper methods.
24 | */
25 | public class WearIntentService extends IntentService implements GoogleApiClient.ConnectionCallbacks {
26 |
27 | private static final String TAG = "LibreIntent";
28 |
29 | // TODO: Rename actions, choose action names that describe tasks that this
30 | // IntentService can perform, e.g. ACTION_FETCH_NEW_ITEMS
31 | private static final String ACTION_FOO = "com.pimpimmobile.librealarm.action.FOO";
32 | private static final String ACTION_BAZ = "com.pimpimmobile.librealarm.action.BAZ";
33 |
34 | // TODO: Rename parameters
35 | private static final String EXTRA_PARAM1 = "com.pimpimmobile.librealarm.extra.PARAM1";
36 | private static final String EXTRA_PARAM2 = "com.pimpimmobile.librealarm.extra.PARAM2";
37 |
38 | public static GoogleApiClient mGoogleApiClient;
39 | private static MessageApi.MessageListener remoteListener;
40 |
41 | public WearIntentService() {
42 | super("WearIntentService");
43 | }
44 |
45 | /**
46 | * Starts this service to perform action Foo with the given parameters. If
47 | * the service is already performing a task this action will be queued.
48 | *
49 | * @see IntentService
50 | */
51 | // TODO: Customize helper method
52 | public static void startActionFoo(Context context, String param1, String param2) {
53 | Intent intent = new Intent(context, WearIntentService.class);
54 | intent.setAction(ACTION_FOO);
55 | intent.putExtra(EXTRA_PARAM1, param1);
56 | intent.putExtra(EXTRA_PARAM2, param2);
57 | context.startService(intent);
58 | }
59 |
60 | public static void startActionDefault(Context context) {
61 | Intent intent = new Intent(context, WearIntentService.class);
62 | context.startService(intent);
63 | }
64 |
65 | /**
66 | * Starts this service to perform action Baz with the given parameters. If
67 | * the service is already performing a task this action will be queued.
68 | *
69 | * @see IntentService
70 | */
71 | // TODO: Customize helper method
72 | public static void startActionBaz(Context context, String param1, String param2) {
73 | Intent intent = new Intent(context, WearIntentService.class);
74 | intent.setAction(ACTION_BAZ);
75 | intent.putExtra(EXTRA_PARAM1, param1);
76 | intent.putExtra(EXTRA_PARAM2, param2);
77 | context.startService(intent);
78 | }
79 |
80 | @Override
81 | protected void onHandleIntent(Intent intent) {
82 | final PowerManager.WakeLock wl = JoH.getWakeLock(this, "intent-service", 30000);
83 | Log.e(TAG, "IntentService Triggered!");
84 | try {
85 | if (intent != null) {
86 | final String action = intent.getAction();
87 | if (ACTION_FOO.equals(action)) {
88 | final String param1 = intent.getStringExtra(EXTRA_PARAM1);
89 | final String param2 = intent.getStringExtra(EXTRA_PARAM2);
90 | handleActionFoo(param1, param2);
91 | } else if (ACTION_BAZ.equals(action)) {
92 | final String param1 = intent.getStringExtra(EXTRA_PARAM1);
93 | final String param2 = intent.getStringExtra(EXTRA_PARAM2);
94 | handleActionBaz(param1, param2);
95 | }
96 | }
97 |
98 |
99 | if (libreAlarm.noNFC()) {
100 | Log.e(TAG, "Device has no NFC! - not doing anything");
101 | } else {
102 |
103 | reconnectGoogle();
104 |
105 | if (PreferencesUtil.shouldUseRoot(this)) {
106 | Log.d(TAG, "Using ROOT options!");
107 | RootTools.executeScripts(true); // turn it on
108 | } else {
109 | Log.d(TAG, "Not using root options");
110 | }
111 | final NfcManager nfcManager =
112 | (NfcManager) this.getSystemService(Context.NFC_SERVICE);
113 | NfcAdapter mNfcAdapter = nfcManager.getDefaultAdapter(); // could be static?
114 | // mNfcAdapter.disableForegroundDispatch(this);
115 | if (mNfcAdapter != null) {
116 | Log.d(TAG, "Got NFC adpater - intent service");
117 | int counter = 0;
118 | try {
119 | // null pointer can trigger here from the systemapi
120 | while (((!mNfcAdapter.isEnabled() || (!mGoogleApiClient.isConnected())) && counter < 9)) {
121 | Log.d(TAG, "intent service nfc turned on (" + mNfcAdapter.isEnabled() + ") wait: " + counter + " google: " + mGoogleApiClient.isConnected());
122 | try {
123 | // quick and very dirty
124 | Thread.sleep(1000);
125 | } catch (Exception e) {
126 | //
127 | }
128 | counter++;
129 | }
130 |
131 | } catch (NullPointerException e) {
132 | Log.wtf(TAG, "Null pointer exception from NFC subsystem: " + e.toString());
133 | // TODO do we actually need to reboot watch here after some counter of failures without resolution?
134 | }
135 | } else {
136 | Log.e(TAG, "nfcAdapter is NULL!!");
137 | }
138 |
139 | // fire up the activity
140 | final Intent i = new Intent(this, WearActivity.class);
141 | i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
142 | startActivity(i);
143 | }
144 | } finally {
145 | JoH.releaseWakeLock(wl);
146 | }
147 | }
148 |
149 | /**
150 | * Handle action Foo in the provided background thread with the provided
151 | * parameters.
152 | */
153 | private void handleActionFoo(String param1, String param2) {
154 | // TODO: Handle action Foo
155 | throw new UnsupportedOperationException("Not yet implemented");
156 | }
157 |
158 | /**
159 | * Handle action Baz in the provided background thread with the provided
160 | * parameters.
161 | */
162 | private void handleActionBaz(String param1, String param2) {
163 | // TODO: Handle action Baz
164 | throw new UnsupportedOperationException("Not yet implemented");
165 | }
166 |
167 | private void reconnectGoogle() {
168 | Log.d(TAG, "Reconnect google called");
169 | if ((mGoogleApiClient == null) || (!mGoogleApiClient.isConnected())) {
170 | Log.d(TAG, "Attempting to connect to google api");
171 | mGoogleApiClient = new GoogleApiClient.Builder(this)
172 | .addApi(Wearable.API)
173 | .addConnectionCallbacks(this)
174 | // .addOnConnectionFailedListener(this)
175 | .build();
176 |
177 | mGoogleApiClient.connect();
178 |
179 | } else {
180 | Log.d(TAG, "Already connected google api");
181 | onConnected(null);
182 | }
183 | }
184 |
185 | @Override
186 | public void onConnected(Bundle connectionHint) {
187 | Log.i(TAG, "google api is connected!! - not adding listener yet or sending status update!?");
188 | //Wearable.MessageApi.addListener(mGoogleApiClient, this);
189 | //sendStatusUpdate(Status.Type.ATTEMPTING);
190 | }
191 |
192 | @Override
193 | public void onConnectionSuspended(int cause) {
194 | Log.d(TAG, "onConnectionSuspended(): Connection to Google API client was suspended");
195 | }
196 |
197 | public synchronized static void tryToAddListener(MessageApi.MessageListener listener) {
198 | // TODO check nulls
199 | if (mGoogleApiClient.isConnected()) {
200 | removeExistingListener();
201 | Log.d(TAG, "Adding remote listener!");
202 | Wearable.MessageApi.addListener(mGoogleApiClient, listener);
203 | } else {
204 | Log.e(TAG, "Can't add listener as we are not connected!");
205 | }
206 | }
207 |
208 | public synchronized static void tryToRemoveListener(MessageApi.MessageListener listener) {
209 | // TODO check nulls - check if we should remove even if not connected
210 | // if (mGoogleApiClient.isConnected()) {
211 | if (mGoogleApiClient != null) {
212 | try {
213 | removeExistingListener();
214 | } catch (Exception e) {
215 | Log.e(TAG, "Got exception removing remote listener: " + e);
216 | }
217 | try {
218 | Wearable.MessageApi.removeListener(mGoogleApiClient, listener);
219 | } catch (Exception e) {
220 | Log.e(TAG, "Got exception removing listener: " + e);
221 | }
222 | }
223 | }
224 |
225 | private static void removeExistingListener() {
226 | if (remoteListener != null) {
227 | Log.e(TAG, "First removing remote listener!");
228 | Wearable.MessageApi.removeListener(mGoogleApiClient, remoteListener);
229 | remoteListener = null;
230 | }
231 | }
232 |
233 | }
234 |
--------------------------------------------------------------------------------
/shareddata/src/main/java/com/pimpimmobile/librealarm/shareddata/PreferencesUtil.java:
--------------------------------------------------------------------------------
1 | package com.pimpimmobile.librealarm.shareddata;
2 |
3 | import android.content.Context;
4 | import android.preference.PreferenceManager;
5 | import android.util.Log;
6 |
7 | import com.google.gson.JsonObject;
8 |
9 | import org.json.JSONException;
10 | import org.json.JSONObject;
11 |
12 | import java.util.HashMap;
13 | import java.util.Iterator;
14 |
15 | public class PreferencesUtil {
16 |
17 | public static final String TRUE_MARKER = "___TRUE___";
18 | public static final String FALSE_MARKER = "___FALSE___";
19 |
20 | private static final String TAG = "LibrePrefUtil";
21 |
22 | public static int battery_threshold = -1;
23 |
24 | // Used on phone
25 | public static Boolean isNsRestEnabled(Context context) {
26 | return getBoolean(context, "ns_rest");
27 | }
28 |
29 | // Used on phone
30 | public static Boolean isXdripPlusEnabled(Context context) {
31 | return getBoolean(context, "xdrip_plus_broadcast");
32 | }
33 |
34 | public static String getNsRestUrl(Context context) {
35 | return getString(context, "ns_rest_uri");
36 | }
37 | // End used on phone
38 |
39 | // Used on watch
40 | public static void setIsStarted(Context context, boolean started) {
41 | setBoolean(context, "startstopflag", started);
42 | }
43 |
44 | public static boolean getIsStarted(Context context) {
45 | return getBoolean(context, "startstopflag");
46 | }
47 |
48 | // Used on phone
49 | public static void setIsStartedPhone(Context context, boolean started) {
50 | setBoolean(context, "phone-startstopflag", started);
51 | }
52 |
53 | public static boolean getIsStartedPhone(Context context) {
54 | return getBoolean(context, "phone-startstopflag", true);
55 | }
56 |
57 | public static void setRetries(Context context, int attempts) {
58 | setInt(context, "retries", attempts);
59 | }
60 |
61 | public static int getRetries(Context context) {
62 | return getInt(context, "retries", 1);
63 | }
64 |
65 | public static long getLastBoot(Context context) {
66 | return getLong(context, "last_boot");
67 | }
68 |
69 | public static void setLastBoot(Context context, long time) {
70 | setLong(context, "last_boot", time);
71 | }
72 |
73 | public static Status.Type getCurrentType(Context context) {
74 | return Status.Type.values()[getInt(context, "current_type", Status.Type.NOT_RUNNING.ordinal())];
75 | }
76 |
77 | public static void setCurrentType(Context context, Status.Type type) {
78 | setInt(context, "current_type", type.ordinal());
79 | }
80 |
81 | public static long errInRowForAlarm(Context context) {
82 | if ("true".equals(getString(context, context.getString(R.string.pref_key_err_alarm_enabled), "false"))) {
83 | return Long.valueOf(getString(context, context.getString(R.string.pref_key_err_alarm), "2"));
84 | }
85 | return Long.MAX_VALUE;
86 | }
87 |
88 | public static int increaseErrorsInARow(Context context) {
89 | int errorsInRow = getInt(context, "errors_in_a_row", 0) + 1;
90 | setInt(context, "errors_in_a_row", errorsInRow);
91 | return errorsInRow;
92 | }
93 |
94 | public static void resetErrorsInARow(Context context) {
95 | setInt(context, "errors_in_a_row", 0);
96 | }
97 |
98 | public static Boolean slowCpu(Context context) {
99 | return getBoolean(context, context.getString(R.string.pref_key_clock_speed), false);
100 | }
101 |
102 | public static Boolean disableTouchscreen(Context context) {
103 | return getBoolean(context, context.getString(R.string.pref_key_disable_touchscreen), false);
104 | }
105 |
106 | public static Boolean toggleNFC(Context context) {
107 | return getBoolean(context, context.getString(R.string.pref_key_switch_nfc), false);
108 | }
109 |
110 | public static Boolean toggleNFConError(Context context) {
111 | return getBoolean(context, context.getString(R.string.pref_key_switch_nfc_on_error), true);
112 | }
113 |
114 | public static Boolean automaticallyEnableTheatreMode(Context context) {
115 | return getBoolean(context, context.getString(R.string.pref_key_auto_theatre_mode), false);
116 | }
117 |
118 | public static Boolean useHalfSpeed(Context context) {
119 | return getBoolean(context, context.getString(R.string.pref_key_auto_half_speed), false);
120 | }
121 |
122 | public static Boolean uninstallxDrip(Context context) {
123 | return getBoolean(context, context.getString(R.string.pref_key_uninstall_xdrip), false);
124 | }
125 |
126 | public static String getCheckGlucoseInterval(Context context) {
127 | return getString(context, context.getString(R.string.pref_key_glucose_interval), "5");
128 | }
129 |
130 | public static String getHalfThreshold(Context context) {
131 | return getString(context, context.getString(R.string.pref_key_half_percent), "30");
132 | }
133 |
134 | public static int getHalfThresholdNumber(Context context) {
135 | final String val = getHalfThreshold(context);
136 | try {
137 | final int value = Integer.parseInt(val);
138 | if (value < 2 || value > 90) return 30;
139 | return value;
140 | } catch (Exception e) {
141 | return 30;
142 | }
143 | }
144 |
145 | public static void updateBatteryThresholdCache(Context context) {
146 | battery_threshold = getHalfThresholdNumber(context);
147 | }
148 |
149 | public static Boolean shouldUseRoot(Context context) {
150 | return getBoolean(context, context.getString(R.string.pref_key_root));
151 | }
152 |
153 | public static boolean shouldGoHalfSpeed(Context context, int battery_level) {
154 | if (battery_threshold < 1) {
155 | battery_threshold = getHalfThresholdNumber(context);
156 | }
157 | if ((battery_level < 1) || (battery_level > battery_threshold)) {
158 | return false;
159 | } else {
160 | return useHalfSpeed(context);
161 | }
162 | }
163 |
164 | /// / End used in watch
165 |
166 | public static void setBoolean(Context context, String key, boolean value) {
167 | PreferenceManager.getDefaultSharedPreferences(context).edit().putBoolean(key, value).apply();
168 | }
169 |
170 | public static boolean getBoolean(Context context, String key) {
171 | return getBoolean(context, key, false);
172 | }
173 |
174 | public static boolean getBoolean(Context context, String key, boolean default_) {
175 | // booleans get stored on watch as strings due to the way data is synced
176 | try {
177 | return PreferenceManager.getDefaultSharedPreferences(context).getBoolean(key, default_);
178 | } catch (ClassCastException e) {
179 | return PreferencesUtil.getString(context, key).equals("true");
180 | }
181 | }
182 |
183 | public static void setInt(Context context, String key, int value) {
184 | PreferenceManager.getDefaultSharedPreferences(context).edit().putInt(key, value).apply();
185 | }
186 |
187 | public static int getInt(Context context, int id) {
188 | return getInt(context, context.getString(id), -1);
189 | }
190 |
191 | public static int getInt(Context context, String key, int default_) {
192 | return PreferenceManager.getDefaultSharedPreferences(context).getInt(key, default_);
193 | }
194 |
195 | public static void setLong(Context context, String key, long value) {
196 | PreferenceManager.getDefaultSharedPreferences(context).edit().putLong(key, value).apply();
197 | }
198 |
199 | public static long getLong(Context context, int id) {
200 | return getLong(context, context.getString(id));
201 | }
202 |
203 | public static long getLong(Context context, String key) {
204 | return PreferenceManager.getDefaultSharedPreferences(context).getLong(key, -1);
205 | }
206 |
207 | public static String getString(Context context, int id) {
208 | return getString(context, context.getString(id));
209 | }
210 |
211 | public static String getString(Context context, String key) {
212 | return getString(context, key, "-1");
213 | }
214 |
215 | public static String getString(Context context, int keyId, String default_) {
216 | return PreferenceManager.getDefaultSharedPreferences(context).getString(context.getString(keyId), default_);
217 | }
218 |
219 | public static String getString(Context context, String key, String default_) {
220 | return PreferenceManager.getDefaultSharedPreferences(context).getString(key, default_);
221 | }
222 |
223 | public static void putString(Context context, String key, String value) {
224 | PreferenceManager.getDefaultSharedPreferences(context).edit().putString(key, value).apply();
225 | }
226 |
227 | public static void putBoolean(Context context, String key, boolean value) {
228 | PreferenceManager.getDefaultSharedPreferences(context).edit().putBoolean(key, value).apply();
229 | }
230 |
231 | public static float getFloat(Context context, int id) {
232 | return getFloat(context, context.getString(id));
233 | }
234 |
235 | public static float getFloat(Context context, String key) {
236 | return PreferenceManager.getDefaultSharedPreferences(context).getFloat(key, -1);
237 | }
238 |
239 | public static String toString(HashMap prefs) {
240 | JsonObject object = new JsonObject();
241 | for (String key : prefs.keySet()) {
242 | object.addProperty(key, prefs.get(key));
243 | }
244 | return object.toString();
245 | }
246 |
247 | public static HashMap toMap(String prefs) {
248 | HashMap map = new HashMap<>();
249 | try {
250 | JSONObject object = new JSONObject(prefs);
251 | Iterator iterator = object.keys();
252 | while (iterator.hasNext()) {
253 | String key = iterator.next();
254 | map.put(key, object.getString(key));
255 | }
256 | } catch (JSONException e) {
257 | throw new RuntimeException("Something wrong with JSON");
258 | }
259 | return map;
260 | }
261 | }
262 |
--------------------------------------------------------------------------------
/Application/src/main/res/values/strings.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | open drawer
5 |
6 |
7 | close drawer
8 |
9 |
10 | ERR means the watch has failed to fetch glucose data.\n\nMake sure the watch is right above the sensor with the watch screen facing the sensor.\n\nMake sure also that the watch has NFC turned on. Check this by opening the app \"NFC configuration\" on the watch. Should it be impossible to turn on NFC, restart the watch and try again.
11 |
12 |
13 | Please read through these points, it\'s important!\n\n1, This is an unofficial app and has not been approved in any way by Abbott.\n\n2, The glucose values produced by this app are not accurate. The only purpose with this app is to alarm the user when his or her glucose level is too high or too low. All values should be confirmed using official Abbott tools.\n\n3, Do not rely on the app to be fail safe. It may stop working without warning and/or produce unreliable results.
14 |
15 |
16 | Disclaimer
17 |
18 |
19 | ERR
20 |
21 |
22 | STOP
23 |
24 |
25 | ALARM
26 |
27 |
28 | START
29 |
30 |
31 | WAIT
32 |
33 |
34 | Check now
35 |
36 |
37 | This is the first startup. The watch app might not be installed yet. Please wait a moment, then restart the app.
38 |
39 |
40 | ALARM!!
41 |
42 |
43 | "Attempt %d/%d"
44 |
45 |
46 | "Attempt %d/%d failed"
47 |
48 |
49 | "Next check: %s"
50 |
51 |
52 | Not running
53 |
54 |
55 | Nightscout
56 |
57 |
58 | Enable Nightscout Rest API
59 |
60 |
61 | Set URL
62 |
63 |
64 | Enable
65 |
66 |
67 | Disable %d min
68 |
69 |
70 | Turn off
71 |
72 |
73 | Failed to turn off alarm
74 |
75 |
76 | Low glucose alarm snoozed: %s
77 |
78 |
79 | High glucose alarm snoozed: %s
80 |
81 |
82 | Use mmol/l
83 |
84 |
85 | High glucose limit
86 |
87 |
88 | Low glucose limit
89 |
90 |
91 | Use alarm sound from phone
92 |
93 |
94 | Snooze high glucose
95 |
96 |
97 | Snooze low glucose
98 |
99 |
100 | Alarm on ERR
101 |
102 |
103 | How many ERR in a row required
104 |
105 |
106 | Value on watch: %s
107 |
108 |
109 | Preferences
110 |
111 |
112 | Snooze
113 |
114 |
115 | Settings updated on watch
116 |
117 |
118 | General settings
119 |
120 |
121 | Text-to-speech
122 |
123 |
124 | Use Text-to-speech
125 |
126 |
127 | Have your glucose values read out
128 |
129 |
130 | Only use Text-to-speech on alarms
131 |
132 |
133 | Failed to initialize Text-to-speech
134 |
135 |
136 | Glucose value is %s. Trend is %s
137 |
138 |
139 | rising fast
140 |
141 |
142 | rising slowly
143 |
144 |
145 | stable
146 |
147 |
148 | going down fast
149 |
150 |
151 | going down slowly
152 |
153 |
154 | unknown
155 |
156 |
157 | Failed to fetch glucose value
158 |
159 |
160 | Send data to xDrip+ running on the same handset
161 |
162 |
163 | Disable all Watch and LibreAlarm alerts and use xDrip+ for alarms!
164 |
165 |
166 | Set glucose reading interval
167 |
168 |
169 | Slow down watch CPU
170 |
171 |
172 | Run watch at slowest processing speed to save battery. (Not recommended)
173 |
174 |
175 | Completely disable watch touchscreen
176 |
177 |
178 | (Recommended) Use app reboot menu item or hold watch button to reverse
179 |
180 |
181 | Enable root functionality
182 |
183 |
184 | Requires rooted watch (Recommended)
185 | Uninstall xDrip watchface
186 | Remove the xDrip watchface from the collector watch
187 | Toggle NFC
188 | Try to turn NFC off when not in use (Not recommended)
189 | Reboot watch (needs root)
190 | Clear Statistics
191 | Toggle NFC on error
192 | Turn NFC off and on if we get read errors (Recommended)
193 | Enables theatre mode periodically, which disables notifications from the phone activating the watch
194 | Always-On Theatre Mode
195 | 5 minute (best) or 10 (battery saver)
196 | Power save features
197 | xDrip+ Settings
198 | Download xDrip+
199 | Scan half as often when watch battery is less than
200 | Slow interval when power low
201 | Power Low percentage
202 |
203 |
204 |
--------------------------------------------------------------------------------
/Wearable/src/main/java/com/pimpimmobile/librealarm/RootTools.java:
--------------------------------------------------------------------------------
1 | package com.pimpimmobile.librealarm;
2 |
3 | import android.content.Context;
4 | import android.nfc.NfcAdapter;
5 | import android.nfc.NfcManager;
6 | import android.os.PowerManager;
7 | import android.util.Log;
8 |
9 | import com.pimpimmobile.librealarm.shareddata.AlgorithmUtil;
10 | import com.pimpimmobile.librealarm.shareddata.PreferencesUtil;
11 |
12 | import java.io.BufferedReader;
13 | import java.io.File;
14 | import java.io.FileOutputStream;
15 | import java.io.IOException;
16 | import java.io.InputStreamReader;
17 | import java.nio.charset.Charset;
18 |
19 | class RootTools {
20 |
21 | private static final String TAG = "LibreAlarm" + RootTools.class.getSimpleName();
22 | private static final boolean DEBUG = AlgorithmUtil.DEBUG;
23 |
24 | private static Boolean sHasRoot = null;
25 | private static boolean sScriptsCreated = false;
26 | private static boolean mNfcDestinationState = false;
27 |
28 |
29 | private static PowerManager.WakeLock mWakeLock;
30 |
31 |
32 | public static synchronized boolean isHasRoot() {
33 | if (sHasRoot == null) {
34 | sHasRoot = (new File("/system/xbin/su").exists());
35 | }
36 | return sHasRoot;
37 | }
38 |
39 | private static synchronized void createScripts() {
40 | if (sScriptsCreated) return;
41 | // switches to lowest possible power levels on cpu
42 | final File file_dir = libreAlarm.getAppContext().getFilesDir();
43 | if (!file_dir.exists()) {
44 | Log.d(TAG, "Creating folder for: " + file_dir);
45 | file_dir.mkdirs();
46 | }
47 |
48 | String script_name = file_dir + "/powersave.sh";
49 | writeToFile(script_name, "echo powersave > /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor\necho 0 >/sys/devices/system/cpu/cpu1/online\n");
50 | //writeToFile(script_name, "echo powersave > /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor\n\n");
51 |
52 | // restore cpu speed somewhat
53 | script_name = file_dir + "/performance.sh";
54 | // seems to crash sometimes waking up the second cpu so lets not do that
55 | //writeToFile(script_name, "echo interactive > /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor\necho 1 >/sys/devices/system/cpu/cpu1/online\n");
56 | writeToFile(script_name, "echo interactive > /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor\n\n");
57 |
58 |
59 | // disables the touch sense on the keypad by nuking the driver
60 | script_name = file_dir + "/killtouch.sh";
61 | writeToFile(script_name, "echo synaptics_dsx.0 >/sys/bus/platform/drivers/synaptics_dsx/unbind\n" +
62 | "a=`grep -l ^/system/bin/key_sleep_vibrate_service /proc/*/cmdline`\n" +
63 | "if [ \"$a\" != \"\" ]\n" +
64 | "then\n" +
65 | "let p=6\n" +
66 | "while [ $p -lt 14 ] && [ \"${a:$p:1}\" != \"/\" ] \n" +
67 | "do\n" +
68 | "let p=$p+1\n" +
69 | "done\n" +
70 | "let l=$p-6\n" +
71 | "b=\"${a:6:$l}\"\n" +
72 | "echo \"$b\"\n" +
73 | "kill \"$b\"\n" +
74 | "fi\n" +
75 | "setprop ctl.stop key_vibrate\n" +
76 | "setprop ctl.stop gpsd\n\n" +
77 | "\n");
78 |
79 | // removes xdrip watchface if present
80 | script_name = file_dir + "/uninstallxdrip.sh";
81 | writeToFile(script_name, "pm uninstall com.eveningoutpost.xdrip\n" +
82 | "\n");
83 |
84 |
85 | sScriptsCreated = true;
86 | }
87 |
88 | private static void writeToFile(String filename, String data) {
89 | try {
90 | File the_file = new File(filename);
91 | // if (!the_file.exists())
92 | // {
93 | FileOutputStream out = new FileOutputStream(the_file);
94 | out.write(data.getBytes(Charset.forName("UTF-8")));
95 | out.close();
96 | // }
97 | } catch (IOException e) {
98 | Log.e(TAG, "File write failed: " + e.toString());
99 | }
100 | }
101 |
102 | public static void executeScripts(boolean state) {
103 | executeScripts(state, 0);
104 | }
105 |
106 | // platform specific method for enabling/disabling nfc - not sure if there is a better api based method
107 | public static void executeScripts(final boolean state, final long delay) {
108 | if (!isHasRoot()) return;
109 | createScripts();
110 | if (delay > 0) {
111 | JoH.runOnUiThreadDelayed(new Runnable() {
112 | @Override
113 | public void run() {
114 | new Thread() {
115 | @Override
116 | public void run() {
117 | runRootScripts(state);
118 | }
119 | }.start();
120 | }
121 | }, delay);
122 | } else {
123 | new Thread(new Runnable() {
124 | @Override
125 | public void run() {
126 | runRootScripts(state);
127 | }
128 | }
129 | ).start();
130 | }
131 | }
132 |
133 | private static synchronized void runRootScripts(boolean state) {
134 | if ((mWakeLock != null) && (mWakeLock.isHeld())) mWakeLock.release();
135 | mWakeLock = JoH.getWakeLock("run-root-scripts", 30000);
136 | final Context mContext = libreAlarm.getAppContext();
137 | try {
138 | if (mNfcDestinationState == state) {
139 | Log.e(TAG, "Destination state changed from: " + state + " to " + mNfcDestinationState + " .. skipping switch!");
140 | } else {
141 | //final boolean needs_root = true; // unclear at the moment whether we need root for this
142 |
143 | /*if (state) {
144 | if (JoH.quietratelimit("speedup-cpu", PreferencesUtil.slowCpu(mContext) ? 1 : 3600)) {
145 | if (DEBUG) Log.d(TAG, "Switching to higher performance cpu speed");
146 | final Process execute4 = Runtime.getRuntime().exec("su -c sh " + mContext.getFilesDir() + "/performance.sh");
147 | }
148 | }*/
149 |
150 | if (state || PreferencesUtil.toggleNFC(mContext)) {
151 | final NfcManager nfcManager =
152 | (NfcManager) libreAlarm.getAppContext().getSystemService(Context.NFC_SERVICE);
153 | final NfcAdapter mNfcAdapter = nfcManager.getDefaultAdapter(); // could be static?
154 | if (mNfcAdapter != null) {
155 | if (mNfcAdapter.isEnabled() != state) {
156 | for (int counter = 0; counter < 5; counter++) {
157 | Log.i(TAG, "Trying to switch nfc " + (state ? "on" : "off"));
158 | // static version of this is duplicated below
159 | final Process execute = Runtime.getRuntime().exec("su -c service call nfc " + (state ? "6" : "5")); // turn NFC on or off
160 | if (showProcessOutput(execute) != null) {
161 | Log.e(TAG, "Got error- retrying.." + counter);
162 | } else {
163 | break;
164 | }
165 | }
166 | } else {
167 | Log.d(TAG, "Nfc adapter is already in desired state of: " + (state ? "on" : "off"));
168 | }
169 | } else {
170 | Log.e(TAG, "No NFC adapter found!!");
171 | }
172 | }
173 |
174 | if (!state) {
175 | if (PreferencesUtil.automaticallyEnableTheatreMode(mContext)) {
176 | if (JoH.quietratelimit("enable-theatre-mode", 3600)) {
177 | enterTheatreMode();
178 | }
179 | }
180 |
181 | if (PreferencesUtil.disableTouchscreen(mContext)) {
182 | // TODO check if already disabled
183 | if (JoH.quietratelimit("disable-touchscreen", 7200)) {
184 | if (DEBUG) Log.d(TAG, "Disabling touchscreen!");
185 | final Process execute1 = Runtime.getRuntime().exec("su -c sh " + mContext.getFilesDir() + "/killtouch.sh");
186 | if (DEBUG) showProcessOutput(execute1);
187 | }
188 | }
189 |
190 | if ((WearActivity.got_tag_data) && (PreferencesUtil.uninstallxDrip(mContext))) {
191 | if (JoH.quietratelimit("uninstall-xdrip", 60000)) {
192 | Log.d(TAG, "Attempting to uninstall xdrip");
193 | final Process execute1 = Runtime.getRuntime().exec("su -c sh " + mContext.getFilesDir() + "/uninstallxdrip.sh");
194 | if (DEBUG) showProcessOutput(execute1);
195 | }
196 | }
197 |
198 | if (PreferencesUtil.slowCpu(mContext)) {
199 | if (DEBUG) Log.d(TAG, "Switching to lower powersave cpu speed");
200 | final Process execute2 = Runtime.getRuntime().exec("su -c sh " + mContext.getFilesDir() + "/powersave.sh");
201 | if (DEBUG) showProcessOutput(execute2);
202 | }
203 | }
204 | }
205 |
206 | } catch (Exception e) {
207 | Log.e(TAG, "Got exception executing root nfc off: " + e.toString());
208 | } finally {
209 | if (mWakeLock.isHeld()) mWakeLock.release();
210 | }
211 | mNfcDestinationState = state;
212 | }
213 |
214 |
215 | private static String showProcessOutput(Process execute) {
216 | try {
217 | execute.waitFor();
218 | if (DEBUG)
219 | Log.d(TAG, "PROCESS OUTPUT: " + (new BufferedReader(new InputStreamReader(execute.getInputStream())).readLine()));
220 | String error = (new BufferedReader(new InputStreamReader(execute.getErrorStream())).readLine());
221 | if (DEBUG) Log.d(TAG, " PROCESS ERROR: " + error);
222 | return error;
223 | } catch (InterruptedException | IOException e) {
224 | Log.d(TAG, "Got error showing process output: " + e.toString());
225 | }
226 | return "other error";
227 | }
228 |
229 | public static Process enterTheatreMode() {
230 | // Thanks to Alan Haverty for the idea and implementation of how to do this
231 | try {
232 | if (DEBUG) Log.d(TAG, "Enabling theatre mode");
233 | final Process executeTheatreMode = Runtime.getRuntime().exec("su -c settings put global theater_mode_on 1");
234 | if (DEBUG) showProcessOutput(executeTheatreMode);
235 | } catch (Exception e) {
236 | Log.e(TAG, "Got exception changing theatre state: " + e);
237 | }
238 | return null;
239 | }
240 |
241 | public static Process swichNFCState(boolean state) {
242 | Log.i(TAG, "Trying to switch nfc " + (state ? "on" : "off"));
243 | try {
244 | return Runtime.getRuntime().exec("su -c service call nfc " + (state ? "6" : "5"));
245 | } catch (Exception e) {
246 | Log.e(TAG, "Got exception changing nfc state: " + e);
247 | }
248 | return null;
249 | }
250 |
251 | public static Process reboot() {
252 | Log.i(TAG, "Trying to reboot");
253 | try {
254 | return Runtime.getRuntime().exec("su -c svc power reboot");
255 | } catch (Exception e) {
256 | Log.e(TAG, "Got exception trying reboot " + e);
257 | }
258 | return null;
259 | }
260 |
261 | }
262 |
--------------------------------------------------------------------------------