nixo
/
GadgetBridge
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Pebble: Get Morpheuz sleep data visualize through SleepMonitorActivity 

This very very experimental, and needs a complete overhaul.
But it is a start ;)
This commit is contained in:
Andreas Shimokawa 2015-05-21 18:17:39 +02:00
parent cb2a95398b
commit 68b76aa5c5
10 changed files with 409 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
app/src/main/AndroidManifest.xml
View File

@ -55,6 +55,13 @@
android:name="android.support.PARENT_ACTIVITY"
android:value=".ControlCenter" />
</activity>
<activity
android:name=".SleepMonitorActivity"
android:label="@string/title_activity_sleepmonitor" >
<meta-data
android:name="android.support.PARENT_ACTIVITY"
android:value=".ControlCenter" />
</activity>
<activity
android:name=".pebble.PebbleAppInstallerActivity"
android:label="@string/title_activity_appinstaller" >

14
app/src/main/java/nodomain/freeyourgadget/gadgetbridge/AppManagerActivity.java
View File

@ -22,6 +22,7 @@ import java.util.List;
import java.util.UUID;
import nodomain.freeyourgadget.gadgetbridge.adapter.GBDeviceAppAdapter;
import nodomain.freeyourgadget.gadgetbridge.pebble.MorpheuzSupport;
public class AppManagerActivity extends Activity {
@ -67,10 +68,15 @@ public class AppManagerActivity extends Activity {
appListView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
@Override
public void onItemClick(AdapterView parent, View v, int position, long id) {
Intent startIntent = new Intent(AppManagerActivity.this, BluetoothCommunicationService.class);
startIntent.setAction(BluetoothCommunicationService.ACTION_STARTAPP);
startIntent.putExtra("app_uuid", appList.get(position).getUUID().toString());
startService(startIntent);
UUID uuid = appList.get(position).getUUID();
Intent startAppIntent = new Intent(AppManagerActivity.this, BluetoothCommunicationService.class);
startAppIntent.setAction(BluetoothCommunicationService.ACTION_STARTAPP);
startAppIntent.putExtra("app_uuid", uuid.toString());
startService(startAppIntent);
if (MorpheuzSupport.uuid.equals(uuid)) {
Intent startIntent = new Intent(AppManagerActivity.this, SleepMonitorActivity.class);
startActivity(startIntent);
}
}
});

116
app/src/main/java/nodomain/freeyourgadget/gadgetbridge/SleepMonitorActivity.java Normal file
View File

@ -0,0 +1,116 @@
package nodomain.freeyourgadget.gadgetbridge;
import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Path;
import android.os.Bundle;
import android.support.v4.app.NavUtils;
import android.support.v4.content.LocalBroadcastManager;
import android.view.MenuItem;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.widget.TextView;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
public class SleepMonitorActivity extends Activity {
public static final String ACTION_REFRESH
= "nodomain.freeyourgadget.gadgetbride.sleepmonitor.action.refresh";
private static final Logger LOG = LoggerFactory.getLogger(SleepMonitorActivity.class);
private SurfaceView surfaceView;
private TextView textView;
private BroadcastReceiver mReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (action.equals(ControlCenter.ACTION_QUIT)) {
finish();
} else if (action.equals(ACTION_REFRESH)) {
int smartalarm_from = intent.getIntExtra("smartalarm_from", -1);
int smartalarm_to = intent.getIntExtra("smartalarm_to", -1);
int recording_base_timestamp = intent.getIntExtra("recording_base_timestamp", -1);
int alarm_gone_off = intent.getIntExtra("alarm_gone_off", -1);
Calendar cal = Calendar.getInstance();
cal.setTimeInMillis((long) recording_base_timestamp * 1000L);
Date date = cal.getTime();
String dateString = new SimpleDateFormat("dd.MM.yyyy HH:mm").format(date);
textView.setText(dateString + " till " + alarm_gone_off / 60 + ":" + alarm_gone_off % 60);
short[] points = intent.getShortArrayExtra("points");
SurfaceHolder surfaceHolder = surfaceView.getHolder();
if (surfaceHolder.getSurface().isValid() && points.length > 1) {
Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
Canvas canvas = surfaceHolder.lockCanvas();
paint.setColor(Color.WHITE);
paint.setStrokeWidth(2);
canvas.drawRGB(100, 100, 100);
int width = canvas.getWidth();
int height = canvas.getHeight();
Path path = new Path();
path.moveTo(0.0f, height);
float x = 0.0f;
for (int i = 0; i < points.length; i++) {
float y = (1.0f - (float) points[i] / 5000.0f) * height;
x = (float) i / (points.length - 1) * width;
path.lineTo(x, y);
}
path.lineTo(x, height);
path.close();
canvas.drawPath(path, paint);
surfaceHolder.unlockCanvasAndPost(canvas);
}
}
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_sleepmonitor);
textView = (TextView) findViewById(R.id.textView);
surfaceView = (SurfaceView) findViewById(R.id.surfaceView);
getActionBar().setDisplayHomeAsUpEnabled(true);
IntentFilter filter = new IntentFilter();
filter.addAction(ControlCenter.ACTION_QUIT);
filter.addAction(ACTION_REFRESH);
LocalBroadcastManager.getInstance(this).registerReceiver(mReceiver, filter);
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case android.R.id.home:
NavUtils.navigateUpFromSameTask(this);
return true;
}
return super.onOptionsItemSelected(item);
}
@Override
protected void onDestroy() {
LocalBroadcastManager.getInstance(this).unregisterReceiver(mReceiver);
super.onDestroy();
}
}

144
app/src/main/java/nodomain/freeyourgadget/gadgetbridge/pebble/MorpheuzSupport.java Normal file
View File

@ -0,0 +1,144 @@
package nodomain.freeyourgadget.gadgetbridge.pebble;
import android.util.Pair;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.SimpleTimeZone;
import java.util.TimeZone;
import java.util.UUID;
import nodomain.freeyourgadget.gadgetbridge.protocol.GBDeviceCommand;
import nodomain.freeyourgadget.gadgetbridge.protocol.GBDeviceCommandSendBytes;
import nodomain.freeyourgadget.gadgetbridge.protocol.GBDeviceCommandSleepMonitorResult;
public class MorpheuzSupport {
public static final int KEY_POINT = 1;
public static final int KEY_CTRL = 2;
public static final int KEY_FROM = 3;
public static final int KEY_TO = 4;
public static final int KEY_BASE = 5;
public static final int KEY_VERSION = 6;
public static final int KEY_GONEOFF = 7;
public static final int KEY_TRANSMIT = 8;
public static final int CTRL_TRANSMIT_DONE = 1;
public static final int CTRL_VERSION_DONE = 2;
public static final int CTRL_GONEOFF_DONE = 4;
public static final int CTRL_DO_NEXT = 8;
public static final int CTRL_SET_LAST_SENT = 16;
public static final UUID uuid = UUID.fromString("5be44f1d-d262-4ea6-aa30-ddbec1e3cab2");
private final PebbleProtocol mPebbleProtocol;
private boolean sent_to_gadgetbridge = false;
// data received from Morpheuz in native format
private short[] points = new short[54];
private int points_last_valid = -1;
private int smartalarm_from = -1; // time in minutes relative from 0:00 for smart alarm (earliest)
private int smartalarm_to = -1;// time in minutes relative from 0:00 for smart alarm (latest)
private int recording_base_timestamp = -1; // timestamp for the first "point", all folowing are +10 minutes offset each
private int alarm_gone_off = -1; // time in minutes relative from 0:00 when alarm gone off
private static final Logger LOG = LoggerFactory.getLogger(MorpheuzSupport.class);
public MorpheuzSupport(PebbleProtocol pebbleProtocol) {
mPebbleProtocol = pebbleProtocol;
}
private byte[] encodeMorpheuzMessage(int key, int value) {
ArrayList<Pair<Integer, Object>> pairs = new ArrayList<>();
pairs.add(new Pair<Integer, Object>(key, value));
byte[] ackMessage = mPebbleProtocol.encodeApplicationMessageAck(uuid, mPebbleProtocol.last_id);
byte[] testMessage = mPebbleProtocol.encodeApplicationMessagePush(PebbleProtocol.ENDPOINT_APPLICATIONMESSAGE, uuid, pairs);
ByteBuffer buf = ByteBuffer.allocate(ackMessage.length + testMessage.length);
// encode ack and put in front of push message (hack for acknowledging the last message)
buf.put(ackMessage);
buf.put(testMessage);
return buf.array();
}
public GBDeviceCommand handleMessage(ArrayList<Pair<Integer, Object>> pairs) {
for (Pair<Integer, Object> pair : pairs) {
int ctrl_message = 0;
switch (pair.first) {
case KEY_GONEOFF:
alarm_gone_off = (int) pair.second;
LOG.info("got gone off: " + alarm_gone_off / 60 + ":" + alarm_gone_off % 60);
/* super-ugly hack: if if did not notice GadgetBridge yet, do so and delay confirmation so Morpheuz
* will resend gone off data. The second time, we acknowledge it.
*
* this can be fixed by allowing to return multiple GBDeviceCommands
*/
if (sent_to_gadgetbridge) {
ctrl_message = MorpheuzSupport.CTRL_VERSION_DONE | MorpheuzSupport.CTRL_GONEOFF_DONE | MorpheuzSupport.CTRL_TRANSMIT_DONE | MorpheuzSupport.CTRL_SET_LAST_SENT;
} else {
GBDeviceCommandSleepMonitorResult sleepMonitorResult = new GBDeviceCommandSleepMonitorResult();
sleepMonitorResult.points = new short[points_last_valid + 1];
System.arraycopy(points, 0, sleepMonitorResult.points, 0, points_last_valid + 1);
sleepMonitorResult.smartalarm_from = smartalarm_from;
sleepMonitorResult.smartalarm_to = smartalarm_to;
sleepMonitorResult.alarm_gone_off = alarm_gone_off;
sleepMonitorResult.recording_base_timestamp = recording_base_timestamp;
sent_to_gadgetbridge = true;
return sleepMonitorResult;
}
break;
case KEY_POINT:
if (recording_base_timestamp == -1) {
// we have no base timestamp but received points, stop this
ctrl_message = MorpheuzSupport.CTRL_VERSION_DONE | MorpheuzSupport.CTRL_GONEOFF_DONE | MorpheuzSupport.CTRL_TRANSMIT_DONE | MorpheuzSupport.CTRL_SET_LAST_SENT;
} else {
short index = (short) ((int) pair.second >> 16);
short data = (short) ((int) pair.second & 0xffff);
LOG.info("got point:" + index + " " + data);
if (index >= 0 && index < 54) {
points[index] = data;
points_last_valid = index;
}
ctrl_message = MorpheuzSupport.CTRL_VERSION_DONE | MorpheuzSupport.CTRL_SET_LAST_SENT | MorpheuzSupport.CTRL_DO_NEXT;
}
break;
case KEY_FROM:
smartalarm_from = (int) pair.second;
LOG.info("got from: " + smartalarm_from / 60 + ":" + smartalarm_from % 60);
ctrl_message = MorpheuzSupport.CTRL_VERSION_DONE | MorpheuzSupport.CTRL_SET_LAST_SENT | MorpheuzSupport.CTRL_DO_NEXT;
break;
case KEY_TO:
smartalarm_to = (int) pair.second;
LOG.info("got from: " + smartalarm_to / 60 + ":" + smartalarm_to % 60);
ctrl_message = MorpheuzSupport.CTRL_VERSION_DONE | MorpheuzSupport.CTRL_SET_LAST_SENT | MorpheuzSupport.CTRL_DO_NEXT;
break;
case KEY_VERSION:
LOG.info("got version: " + ((float) ((int) pair.second) / 10.0f));
ctrl_message = MorpheuzSupport.CTRL_VERSION_DONE | MorpheuzSupport.CTRL_SET_LAST_SENT;
sent_to_gadgetbridge = false;
break;
case KEY_BASE:
// fix timestamp
TimeZone tz = SimpleTimeZone.getDefault();
recording_base_timestamp = (int) pair.second - (tz.getOffset(System.currentTimeMillis())) / 1000;
LOG.info("got base: " + recording_base_timestamp);
ctrl_message = MorpheuzSupport.CTRL_VERSION_DONE | MorpheuzSupport.CTRL_SET_LAST_SENT | MorpheuzSupport.CTRL_DO_NEXT;
break;
default:
LOG.info("unhandled key: " + pair.first);
break;
}
if (ctrl_message > 0) {
GBDeviceCommandSendBytes sendBytes = new GBDeviceCommandSendBytes();
sendBytes.encodedBytes = encodeMorpheuzMessage(MorpheuzSupport.KEY_CTRL, ctrl_message);
return sendBytes;
}
}
GBDeviceCommandSendBytes sendBytes = new GBDeviceCommandSendBytes();
sendBytes.encodedBytes = mPebbleProtocol.encodeApplicationMessageAck(uuid, mPebbleProtocol.last_id);
return sendBytes;
}
}

56
app/src/main/java/nodomain/freeyourgadget/gadgetbridge/pebble/PebbleIoThread.java
View File

@ -31,33 +31,21 @@ import nodomain.freeyourgadget.gadgetbridge.GBDevice;
import nodomain.freeyourgadget.gadgetbridge.GBDeviceIoThread;
import nodomain.freeyourgadget.gadgetbridge.GBMusicControlReceiver;
import nodomain.freeyourgadget.gadgetbridge.R;
import nodomain.freeyourgadget.gadgetbridge.SleepMonitorActivity;
import nodomain.freeyourgadget.gadgetbridge.protocol.GBDeviceCommand;
import nodomain.freeyourgadget.gadgetbridge.protocol.GBDeviceCommandAppInfo;
import nodomain.freeyourgadget.gadgetbridge.protocol.GBDeviceCommandAppManagementResult;
import nodomain.freeyourgadget.gadgetbridge.protocol.GBDeviceCommandCallControl;
import nodomain.freeyourgadget.gadgetbridge.protocol.GBDeviceCommandMusicControl;
import nodomain.freeyourgadget.gadgetbridge.protocol.GBDeviceCommandSendBytes;
import nodomain.freeyourgadget.gadgetbridge.protocol.GBDeviceCommandSleepMonitorResult;
import nodomain.freeyourgadget.gadgetbridge.protocol.GBDeviceCommandVersionInfo;
import nodomain.freeyourgadget.gadgetbridge.protocol.GBDeviceProtocol;
public class PebbleIoThread extends GBDeviceIoThread {
private static final Logger LOG = LoggerFactory.getLogger(PebbleIoThread.class);
private static final int NOTIFICATION_ID = 2;
private enum PebbleAppInstallState {
UNKNOWN,
APP_WAIT_SLOT,
APP_START_INSTALL,
APP_WAIT_TOKEN,
APP_UPLOAD_CHUNK,
APP_UPLOAD_COMMIT,
APP_WAIT_COMMIT,
APP_UPLOAD_COMPLETE,
APP_REFRESH,
}
private final PebbleProtocol mPebbleProtocol;
private BluetoothAdapter mBtAdapter = null;
private BluetoothSocket mBtSocket = null;
private InputStream mInStream = null;
@ -66,7 +54,6 @@ public class PebbleIoThread extends GBDeviceIoThread {
private boolean mIsConnected = false;
private boolean mIsInstalling = false;
private int mConnectionAttempts = 0;
/* app installation */
private Uri mInstallURI = null;
private PBWReader mPBWReader = null;
@ -80,6 +67,12 @@ public class PebbleIoThread extends GBDeviceIoThread {
private int mBinarySize = -1;
private int mBytesWritten = -1;
public PebbleIoThread(GBDevice gbDevice, GBDeviceProtocol gbDeviceProtocol, BluetoothAdapter btAdapter, Context context) {
super(gbDevice, context);
mPebbleProtocol = (PebbleProtocol) gbDeviceProtocol;
mBtAdapter = btAdapter;
}
public static Notification createInstallNotification(String text, boolean ongoing,
int percentage, Context context) {
Intent notificationIntent = new Intent(context, AppManagerActivity.class);
@ -111,12 +104,6 @@ public class PebbleIoThread extends GBDeviceIoThread {
nm.notify(NOTIFICATION_ID, notification);
}
public PebbleIoThread(GBDevice gbDevice, GBDeviceProtocol gbDeviceProtocol, BluetoothAdapter btAdapter, Context context) {
super(gbDevice, context);
mPebbleProtocol = (PebbleProtocol) gbDeviceProtocol;
mBtAdapter = btAdapter;
}
@Override
protected boolean connect(String btDeviceAddress) {
BluetoothDevice btDevice = mBtAdapter.getRemoteDevice(btDeviceAddress);
@ -368,7 +355,7 @@ public class PebbleIoThread extends GBDeviceIoThread {
case APP_INFO:
LOG.info("Got command for APP_INFO");
GBDeviceCommandAppInfo appInfoCmd = (GBDeviceCommandAppInfo) deviceCmd;
setInstallSlot(appInfoCmd.freeSlot);
setInstallSlot(appInfoCmd.freeSlot); // FIXME: Pebble specific
Intent appInfoIntent = new Intent(AppManagerActivity.ACTION_REFRESH_APPLIST);
int appCount = appInfoCmd.apps.length;
@ -381,6 +368,19 @@ public class PebbleIoThread extends GBDeviceIoThread {
}
LocalBroadcastManager.getInstance(context).sendBroadcast(appInfoIntent);
break;
case SLEEP_MONITOR_RES:
LOG.info("Got command for SLEEP_MONIOR_RES");
GBDeviceCommandSleepMonitorResult sleepMonitorResult = (GBDeviceCommandSleepMonitorResult) deviceCmd;
Intent sleepMontiorIntent = new Intent(SleepMonitorActivity.ACTION_REFRESH);
sleepMontiorIntent.putExtra("smartalarm_from", sleepMonitorResult.smartalarm_from);
sleepMontiorIntent.putExtra("smartalarm_to", sleepMonitorResult.smartalarm_to);
sleepMontiorIntent.putExtra("recording_base_timestamp", sleepMonitorResult.recording_base_timestamp);
sleepMontiorIntent.putExtra("alarm_gone_off", sleepMonitorResult.alarm_gone_off);
sleepMontiorIntent.putExtra("points", sleepMonitorResult.points);
LocalBroadcastManager.getInstance(context).sendBroadcast(sleepMontiorIntent);
break;
case SEND_BYTES:
GBDeviceCommandSendBytes sendBytes = (GBDeviceCommandSendBytes) deviceCmd;
write(sendBytes.encodedBytes);
@ -492,4 +492,16 @@ public class PebbleIoThread extends GBDeviceIoThread {
}
}
}
private enum PebbleAppInstallState {
UNKNOWN,
APP_WAIT_SLOT,
APP_START_INSTALL,
APP_WAIT_TOKEN,
APP_UPLOAD_CHUNK,
APP_UPLOAD_COMMIT,
APP_WAIT_COMMIT,
APP_UPLOAD_COMPLETE,
APP_REFRESH,
}
}

85
app/src/main/java/nodomain/freeyourgadget/gadgetbridge/pebble/PebbleProtocol.java
View File

@ -8,6 +8,7 @@ import org.slf4j.LoggerFactory;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Random;
import java.util.SimpleTimeZone;
import java.util.TimeZone;
@ -146,6 +147,10 @@ public class PebbleProtocol extends GBDeviceProtocol {
static final byte PHONEVERSION_REMOTE_OS_LINUX = 4;
static final byte PHONEVERSION_REMOTE_OS_WINDOWS = 5;
static final byte TYPE_BYTEARRAY = 0;
static final byte TYPE_CSTRING = 1;
static final byte TYPE_UINT32 = 2;
static final byte TYPE_INT32 = 3;
static final short LENGTH_PREFIX = 4;
static final short LENGTH_SETTIME = 5;
@ -164,9 +169,10 @@ public class PebbleProtocol extends GBDeviceProtocol {
private static Random mRandom = new Random();
private byte last_id = -1;
byte last_id = -1;
private ArrayList<UUID> tmpUUIDS = new ArrayList<>();
private MorpheuzSupport mMorpheuzSupport = new MorpheuzSupport(PebbleProtocol.this);
// FIXME: this does not belong here
static final UUID WeatherNeatUUID = UUID.fromString("3684003b-a685-45f9-a713-abc6364ba051");
@ -539,33 +545,69 @@ public class PebbleProtocol extends GBDeviceProtocol {
return buf.array();
}
private byte[] encodeApplicationMessageTest() {
private byte[] encodeApplicationMessageWeatherNeatTest() {
// encode push message for WeatherNeat
ArrayList<Pair<Integer, Object>> pairs = new ArrayList<>();
pairs.add(new Pair<>(1, (Object) "Berlin")); // city
pairs.add(new Pair<>(2, (Object) "22 C")); // temperature
pairs.add(new Pair<>(3, (Object) "windy")); // condition
pairs.add(new Pair<>(1, (Object) "Gadgetbridge")); // city
pairs.add(new Pair<>(2, (Object) "-22C")); // temperature
pairs.add(new Pair<>(3, (Object) "this is just a stupid test")); // condition
pairs.add(new Pair<>(5, (Object) 3)); // seconds for backlight on shake
byte[] testMessage = encodeApplicationMessagePush(ENDPOINT_APPLICATIONMESSAGE, WeatherNeatUUID, pairs);
ByteBuffer buf = ByteBuffer.allocate(testMessage.length + LENGTH_PREFIX + 18); // +ACK
// encode ack and put in front of push message (hack for acknowledgeing the last message)
buf.order(ByteOrder.BIG_ENDIAN);
buf.putShort((short) 18);
buf.putShort(ENDPOINT_APPLICATIONMESSAGE);
buf.put(APPLICATIONMESSAGE_ACK);
buf.put((byte) (last_id - 1));
buf.putLong(WeatherNeatUUID.getMostSignificantBits());
buf.putLong(WeatherNeatUUID.getLeastSignificantBits());
// encode ack and put in front of push message (hack for acknowledging the last message)
buf.put(encodeApplicationMessageAck(WeatherNeatUUID, (byte) (last_id - 1)));
buf.put(testMessage);
return buf.array();
}
byte[] encodeApplicationMessageAck(UUID uuid, byte id) {
ByteBuffer buf = ByteBuffer.allocate(LENGTH_PREFIX + 18); // +ACK
public byte[] encodeApplicationMessagePush(short endpoint, UUID uuid, ArrayList<Pair<Integer, Object>> pairs) {
buf.order(ByteOrder.BIG_ENDIAN);
buf.putShort((short) 18);
buf.putShort(ENDPOINT_APPLICATIONMESSAGE);
buf.put(APPLICATIONMESSAGE_ACK);
buf.put(id);
buf.putLong(uuid.getMostSignificantBits());
buf.putLong(uuid.getMostSignificantBits());
return buf.array();
}
private ArrayList<Pair<Integer, Object>> decodeDict(ByteBuffer buf) {
ArrayList<Pair<Integer, Object>> dict = new ArrayList<Pair<Integer, Object>>();
buf.order(ByteOrder.LITTLE_ENDIAN);
byte dictSize = buf.get();
while (dictSize-- > 0) {
Integer key = buf.getInt();
byte type = buf.get();
short length = buf.getShort(); // length
switch (type) {
case TYPE_INT32:
case TYPE_UINT32:
dict.add(new Pair<Integer, Object>(key, buf.getInt()));
break;
case TYPE_CSTRING:
case TYPE_BYTEARRAY:
byte[] bytes = new byte[length];
buf.get(bytes);
if (type == TYPE_BYTEARRAY) {
dict.add(new Pair<Integer, Object>(key, bytes));
} else {
dict.add(new Pair<Integer, Object>(key, Arrays.toString(bytes)));
}
break;
default:
}
}
return dict;
}
byte[] encodeApplicationMessagePush(short endpoint, UUID uuid, ArrayList<Pair<Integer, Object>> pairs) {
int length = 16 + 3; // UUID + (PUSH + id + length of dict)
for (Pair<Integer, Object> pair : pairs) {
length += 7; // key + type + length
@ -589,11 +631,11 @@ public class PebbleProtocol extends GBDeviceProtocol {
for (Pair<Integer, Object> pair : pairs) {
buf.putInt(pair.first);
if (pair.second instanceof Integer) {
buf.put((byte) 0);
buf.put(TYPE_INT32);
buf.putShort((short) 4); // length of int
buf.putInt((int) pair.second);
} else if (pair.second instanceof String) {
buf.put((byte) 1);
buf.put(TYPE_CSTRING);
buf.putShort((short) (((String) pair.second).length() + 1));
buf.put(((String) pair.second).getBytes());
buf.put((byte) 0);
@ -761,16 +803,19 @@ public class PebbleProtocol extends GBDeviceProtocol {
last_id = buf.get();
long uuid_high = buf.getLong();
long uuid_low = buf.getLong();
byte dictSize = buf.get();
switch (pebbleCmd) {
case APPLICATIONMESSAGE_PUSH:
UUID uuid = new UUID(uuid_high, uuid_low);
LOG.info("got APPLICATIONMESSAGE PUSH from UUID " + uuid + " , dict size " + dictSize);
LOG.info("got APPLICATIONMESSAGE PUSH from UUID " + uuid);
if (WeatherNeatUUID.equals(uuid)) {
LOG.info("We know you, you are WeatherNeat");
GBDeviceCommandSendBytes sendBytes = new GBDeviceCommandSendBytes();
sendBytes.encodedBytes = encodeApplicationMessageTest();
sendBytes.encodedBytes = encodeApplicationMessageWeatherNeatTest();
cmd = sendBytes;
} else if (MorpheuzSupport.uuid.equals(uuid)) {
ArrayList<Pair<Integer, Object>> dict = decodeDict(buf);
cmd = mMorpheuzSupport.handleMessage(dict);
}
break;
case APPLICATIONMESSAGE_ACK:

1
app/src/main/java/nodomain/freeyourgadget/gadgetbridge/protocol/GBDeviceCommand.java
View File

@ -12,6 +12,7 @@ public abstract class GBDeviceCommand {
VERSION_INFO,
APP_MANAGEMENT_RES,
SEND_BYTES,
SLEEP_MONITOR_RES,
}
}

14
app/src/main/java/nodomain/freeyourgadget/gadgetbridge/protocol/GBDeviceCommandSleepMonitorResult.java Normal file
View File

@ -0,0 +1,14 @@
package nodomain.freeyourgadget.gadgetbridge.protocol;
public class GBDeviceCommandSleepMonitorResult extends GBDeviceCommand {
// FIXME: this is just the low-level data from Morpheuz, we need something generic
public short[] points;
public int smartalarm_from = -1; // time in minutes relative from 0:00 for smart alarm (earliest)
public int smartalarm_to = -1;// time in minutes relative from 0:00 for smart alarm (latest)
public int recording_base_timestamp = -1; // timestamp for the first "point", all folowing are +10 minutes offset each
public int alarm_gone_off = -1; // time in minutes relative from 0:00 when alarm gone off
public GBDeviceCommandSleepMonitorResult() {
commandClass = CommandClass.SLEEP_MONITOR_RES;
}
}

16
app/src/main/res/layout/activity_sleepmonitor.xml Normal file
View File

@ -0,0 +1,16 @@
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical" android:layout_width="match_parent"
android:layout_height="match_parent"
android:weightSum="1">
<SurfaceView
android:layout_width="match_parent"
android:layout_height="200dp"
android:id="@+id/surfaceView" />
<TextView
android:layout_width="match_parent"
android:layout_height="match_parent"
android:id="@+id/textView" />
</LinearLayout>

2
app/src/main/res/values/strings.xml
View File

@ -100,4 +100,6 @@
<string name="miband_prefs_weight_kg">Weight in kg</string>
<string name="pref_header_vibration_count">Vibration Count</string>
<string name="title_activity_sleepmonitor">Sleep Monitor</string>
</resources>