*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
* USA.
*
* Project home page: https://github.com/mik3y/usb-serial-for-android
*/
package com.eveningoutpost.dexdrip.ImportedLibraries.usbserial.driver;
import android.hardware.usb.UsbConstants;
import android.hardware.usb.UsbDevice;
import android.hardware.usb.UsbDeviceConnection;
import android.hardware.usb.UsbEndpoint;
import android.hardware.usb.UsbRequest;
import android.util.Log;
import com.eveningoutpost.dexdrip.ImportedLibraries.usbserial.util.HexDump;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* A {@link CommonUsbSerialPort} implementation for a variety of FTDI devices
*
* This driver is based on libftdi, and is
* copyright and subject to the following terms:
*
*
* Copyright (C) 2003 by Intra2net AG
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License
* version 2.1 as published by the Free Software Foundation;
*
* opensource@intra2net.com
* http://www.intra2net.com/en/developer/libftdi
*
*
*
*
* Some FTDI devices have not been tested; see later listing of supported and
* unsupported devices. Devices listed as "supported" support the following
* features:
*
* - Read and write of serial data (see
* {@link CommonUsbSerialPort#read(byte[], int)} and
* {@link CommonUsbSerialPort#write(byte[], int)}.
* - Setting serial line parameters (see
* {@link CommonUsbSerialPort#setParameters(int, int, int, int)}.
*
*
*
* Supported and tested devices:
*
* - {@value DeviceType#TYPE_R}
*
*
*
* Unsupported but possibly working devices (please contact the author with
* feedback or patches):
*
* - {@value DeviceType#TYPE_2232C}
* - {@value DeviceType#TYPE_2232H}
* - {@value DeviceType#TYPE_4232H}
* - {@value DeviceType#TYPE_AM}
* - {@value DeviceType#TYPE_BM}
*
*
*
* @author mike wakerly (opensource@hoho.com)
* @see USB Serial
* for Android project page
* @see FTDI Homepage
* @see libftdi
*/
public class FtdiSerialDriver implements UsbSerialDriver {
private final UsbDevice mDevice;
private final UsbSerialPort mPort;
/**
* FTDI chip types.
*/
private static enum DeviceType {
TYPE_BM, TYPE_AM, TYPE_2232C, TYPE_R, TYPE_2232H, TYPE_4232H;
}
public FtdiSerialDriver(UsbDevice device) {
mDevice = device;
mPort = new FtdiSerialPort(mDevice, 0);
}
@Override
public UsbDevice getDevice() {
return mDevice;
}
@Override
public List getPorts() {
return Collections.singletonList(mPort);
}
private class FtdiSerialPort extends CommonUsbSerialPort {
public static final int USB_TYPE_STANDARD = 0x00 << 5;
public static final int USB_TYPE_CLASS = 0x00 << 5;
public static final int USB_TYPE_VENDOR = 0x00 << 5;
public static final int USB_TYPE_RESERVED = 0x00 << 5;
public static final int USB_RECIP_DEVICE = 0x00;
public static final int USB_RECIP_INTERFACE = 0x01;
public static final int USB_RECIP_ENDPOINT = 0x02;
public static final int USB_RECIP_OTHER = 0x03;
public static final int USB_ENDPOINT_IN = 0x80;
public static final int USB_ENDPOINT_OUT = 0x00;
public static final int USB_WRITE_TIMEOUT_MILLIS = 5000;
public static final int USB_READ_TIMEOUT_MILLIS = 5000;
// From ftdi.h
/**
* Reset the port.
*/
private static final int SIO_RESET_REQUEST = 0;
/**
* Set the modem control register.
*/
private static final int SIO_MODEM_CTRL_REQUEST = 1;
/**
* Set flow control register.
*/
private static final int SIO_SET_FLOW_CTRL_REQUEST = 2;
/**
* Set baud rate.
*/
private static final int SIO_SET_BAUD_RATE_REQUEST = 3;
/**
* Set the data characteristics of the port.
*/
private static final int SIO_SET_DATA_REQUEST = 4;
private static final int SIO_RESET_SIO = 0;
private static final int SIO_RESET_PURGE_RX = 1;
private static final int SIO_RESET_PURGE_TX = 2;
public static final int FTDI_DEVICE_OUT_REQTYPE =
UsbConstants.USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_OUT;
public static final int FTDI_DEVICE_IN_REQTYPE =
UsbConstants.USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN;
/**
* Length of the modem status header, transmitted with every read.
*/
private static final int MODEM_STATUS_HEADER_LENGTH = 2;
private final String TAG = FtdiSerialDriver.class.getSimpleName();
private DeviceType mType;
private int mInterface = 0; /* INTERFACE_ANY */
private int mMaxPacketSize = 64; // TODO(mikey): detect
/**
* Due to http://b.android.com/28023 , we cannot use UsbRequest async reads
* since it gives no indication of number of bytes read. Set this to
* {@code true} on platforms where it is fixed.
*/
private static final boolean ENABLE_ASYNC_READS = false;
public FtdiSerialPort(UsbDevice device, int portNumber) {
super(device, portNumber);
}
@Override
public UsbSerialDriver getDriver() {
return FtdiSerialDriver.this;
}
/**
* Filter FTDI status bytes from buffer
* @param src The source buffer (which contains status bytes)
* @param dest The destination buffer to write the status bytes into (can be src)
* @param totalBytesRead Number of bytes read to src
* @param maxPacketSize The USB endpoint max packet size
* @return The number of payload bytes
*/
private final int filterStatusBytes(byte[] src, byte[] dest, int totalBytesRead, int maxPacketSize) {
final int packetsCount = totalBytesRead / maxPacketSize + (totalBytesRead % maxPacketSize == 0 ? 0 : 1);
for (int packetIdx = 0; packetIdx < packetsCount; ++packetIdx) {
final int count = (packetIdx == (packetsCount - 1))
? (totalBytesRead % maxPacketSize) - MODEM_STATUS_HEADER_LENGTH
: maxPacketSize - MODEM_STATUS_HEADER_LENGTH;
if (count > 0) {
System.arraycopy(src,
packetIdx * maxPacketSize + MODEM_STATUS_HEADER_LENGTH,
dest,
packetIdx * (maxPacketSize - MODEM_STATUS_HEADER_LENGTH),
count);
}
}
return totalBytesRead - (packetsCount * 2);
}
public int read(byte[] dest, int timeoutMillis, UsbDeviceConnection connection) throws IOException {
if (false) {
final UsbRequest request = new UsbRequest();
try {
request.initialize(connection, null);
final ByteBuffer buf = ByteBuffer.wrap(dest);
if (!request.queue(buf, dest.length)) {
throw new IOException("Error queueing request.");
}
final UsbRequest response = connection.requestWait();
if (response == null) {
throw new IOException("Null response");
}
final int nread = buf.position();
if (nread > 0) {
//Log.d(TAG, HexDump.dumpHexString(dest, 0, Math.min(32, dest.length)));
return nread;
} else {
return 0;
}
} finally {
request.close();
}
}
final int numBytesRead;
synchronized (mReadBufferLock) {
int readAmt = Math.min(dest.length, mReadBuffer.length);
numBytesRead = connection.bulkTransfer(null, mReadBuffer, readAmt,
timeoutMillis);
if (numBytesRead < 0) {
// This sucks: we get -1 on timeout, not 0 as preferred.
// We *should* use UsbRequest, except it has a bug/api oversight
// where there is no way to determine the number of bytes read
// in response :\ -- http://b.android.com/28023
if (timeoutMillis == Integer.MAX_VALUE) {
// Hack: Special case "~infinite timeout" as an error.
return -1;
}
return 0;
}
System.arraycopy(mReadBuffer, 0, dest, 0, numBytesRead);
}
return numBytesRead;
}
public void reset() throws IOException {
int result = mConnection.controlTransfer(FTDI_DEVICE_OUT_REQTYPE, SIO_RESET_REQUEST,
SIO_RESET_SIO, 0 /* index */, null, 0, USB_WRITE_TIMEOUT_MILLIS);
if (result != 0) {
throw new IOException("Reset failed: result=" + result);
}
// TODO(mikey): autodetect.
mType = DeviceType.TYPE_R;
}
@Override
public void open(UsbDeviceConnection connection) throws IOException {
if (mConnection != null) {
throw new IOException("Already open");
}
mConnection = connection;
boolean opened = false;
try {
for (int i = 0; i < mDevice.getInterfaceCount(); i++) {
if (connection.claimInterface(mDevice.getInterface(i), true)) {
Log.d(TAG, "claimInterface " + i + " SUCCESS");
} else {
throw new IOException("Error claiming interface " + i);
}
}
reset();
opened = true;
} finally {
if (!opened) {
close();
mConnection = null;
}
}
}
@Override
public void close() throws IOException {
if (mConnection == null) {
throw new IOException("Already closed");
}
try {
mConnection.close();
} finally {
mConnection = null;
}
}
@Override
public int read(byte[] dest, int timeoutMillis) throws IOException {
final UsbEndpoint endpoint = mDevice.getInterface(0).getEndpoint(0);
if (ENABLE_ASYNC_READS) {
final int readAmt;
synchronized (mReadBufferLock) {
// mReadBuffer is only used for maximum read size.
readAmt = Math.min(dest.length, mReadBuffer.length);
}
final UsbRequest request = new UsbRequest();
request.initialize(mConnection, endpoint);
final ByteBuffer buf = ByteBuffer.wrap(dest);
if (!request.queue(buf, readAmt)) {
throw new IOException("Error queueing request.");
}
final UsbRequest response = mConnection.requestWait();
if (response == null) {
throw new IOException("Null response");
}
final int payloadBytesRead = buf.position() - MODEM_STATUS_HEADER_LENGTH;
if (payloadBytesRead > 0) {
Log.d(TAG, HexDump.dumpHexString(dest, 0, Math.min(32, dest.length)));
return payloadBytesRead;
} else {
return 0;
}
} else {
final int totalBytesRead;
synchronized (mReadBufferLock) {
final int readAmt = Math.min(dest.length, mReadBuffer.length);
totalBytesRead = mConnection.bulkTransfer(endpoint, mReadBuffer,
readAmt, timeoutMillis);
if (totalBytesRead < MODEM_STATUS_HEADER_LENGTH) {
throw new IOException("Expected at least " + MODEM_STATUS_HEADER_LENGTH + " bytes");
}
return filterStatusBytes(mReadBuffer, dest, totalBytesRead, endpoint.getMaxPacketSize());
}
}
}
@Override
public int write(byte[] src, int timeoutMillis) throws IOException {
final UsbEndpoint endpoint = mDevice.getInterface(0).getEndpoint(1);
int offset = 0;
while (offset < src.length) {
final int writeLength;
final int amtWritten;
synchronized (mWriteBufferLock) {
final byte[] writeBuffer;
writeLength = Math.min(src.length - offset, mWriteBuffer.length);
if (offset == 0) {
writeBuffer = src;
} else {
// bulkTransfer does not support offsets, make a copy.
System.arraycopy(src, offset, mWriteBuffer, 0, writeLength);
writeBuffer = mWriteBuffer;
}
amtWritten = mConnection.bulkTransfer(endpoint, writeBuffer, writeLength,
timeoutMillis);
}
if (amtWritten <= 0) {
throw new IOException("Error writing " + writeLength
+ " bytes at offset " + offset + " length=" + src.length);
}
Log.d(TAG, "Wrote amtWritten=" + amtWritten + " attempted=" + writeLength);
offset += amtWritten;
}
return offset;
}
private int setBaudRate(int baudRate) throws IOException {
long[] vals = convertBaudrate(baudRate);
long actualBaudrate = vals[0];
long index = vals[1];
long value = vals[2];
int result = mConnection.controlTransfer(FTDI_DEVICE_OUT_REQTYPE,
SIO_SET_BAUD_RATE_REQUEST, (int) value, (int) index,
null, 0, USB_WRITE_TIMEOUT_MILLIS);
if (result != 0) {
throw new IOException("Setting baudrate failed: result=" + result);
}
return (int) actualBaudrate;
}
@Override
public void setParameters(int baudRate, int dataBits, int stopBits, int parity)
throws IOException {
setBaudRate(baudRate);
int config = dataBits;
switch (parity) {
case PARITY_NONE:
config |= (0x00 << 8);
break;
case PARITY_ODD:
config |= (0x01 << 8);
break;
case PARITY_EVEN:
config |= (0x02 << 8);
break;
case PARITY_MARK:
config |= (0x03 << 8);
break;
case PARITY_SPACE:
config |= (0x04 << 8);
break;
default:
throw new IllegalArgumentException("Unknown parity value: " + parity);
}
switch (stopBits) {
case STOPBITS_1:
config |= (0x00 << 11);
break;
case STOPBITS_1_5:
config |= (0x01 << 11);
break;
case STOPBITS_2:
config |= (0x02 << 11);
break;
default:
throw new IllegalArgumentException("Unknown stopBits value: " + stopBits);
}
int result = mConnection.controlTransfer(FTDI_DEVICE_OUT_REQTYPE,
SIO_SET_DATA_REQUEST, config, 0 /* index */,
null, 0, USB_WRITE_TIMEOUT_MILLIS);
if (result != 0) {
throw new IOException("Setting parameters failed: result=" + result);
}
}
private long[] convertBaudrate(int baudrate) {
// TODO(mikey): Braindead transcription of libfti method. Clean up,
// using more idiomatic Java where possible.
int divisor = 24000000 / baudrate;
int bestDivisor = 0;
int bestBaud = 0;
int bestBaudDiff = 0;
int fracCode[] = {
0, 3, 2, 4, 1, 5, 6, 7
};
for (int i = 0; i < 2; i++) {
int tryDivisor = divisor + i;
int baudEstimate;
int baudDiff;
if (tryDivisor <= 8) {
// Round up to minimum supported divisor
tryDivisor = 8;
} else if (mType != DeviceType.TYPE_AM && tryDivisor < 12) {
// BM doesn't support divisors 9 through 11 inclusive
tryDivisor = 12;
} else if (divisor < 16) {
// AM doesn't support divisors 9 through 15 inclusive
tryDivisor = 16;
} else {
if (mType == DeviceType.TYPE_AM) {
// TODO
} else {
if (tryDivisor > 0x1FFFF) {
// Round down to maximum supported divisor value (for
// BM)
tryDivisor = 0x1FFFF;
}
}
}
// Get estimated baud rate (to nearest integer)
baudEstimate = (24000000 + (tryDivisor / 2)) / tryDivisor;
// Get absolute difference from requested baud rate
if (baudEstimate < baudrate) {
baudDiff = baudrate - baudEstimate;
} else {
baudDiff = baudEstimate - baudrate;
}
if (i == 0 || baudDiff < bestBaudDiff) {
// Closest to requested baud rate so far
bestDivisor = tryDivisor;
bestBaud = baudEstimate;
bestBaudDiff = baudDiff;
if (baudDiff == 0) {
// Spot on! No point trying
break;
}
}
}
// Encode the best divisor value
long encodedDivisor = (bestDivisor >> 3) | (fracCode[bestDivisor & 7] << 14);
// Deal with special cases for encoded value
if (encodedDivisor == 1) {
encodedDivisor = 0; // 3000000 baud
} else if (encodedDivisor == 0x4001) {
encodedDivisor = 1; // 2000000 baud (BM only)
}
// Split into "value" and "index" values
long value = encodedDivisor & 0xFFFF;
long index;
if (mType == DeviceType.TYPE_2232C || mType == DeviceType.TYPE_2232H
|| mType == DeviceType.TYPE_4232H) {
index = (encodedDivisor >> 8) & 0xffff;
index &= 0xFF00;
index |= 0 /* TODO mIndex */;
} else {
index = (encodedDivisor >> 16) & 0xffff;
}
// Return the nearest baud rate
return new long[] {
bestBaud, index, value
};
}
@Override
public boolean getCD() throws IOException {
return false;
}
@Override
public boolean getCTS() throws IOException {
return false;
}
@Override
public boolean getDSR() throws IOException {
return false;
}
@Override
public boolean getDTR() throws IOException {
return false;
}
@Override
public void setDTR(boolean value) throws IOException {
}
@Override
public boolean getRI() throws IOException {
return false;
}
@Override
public boolean getRTS() throws IOException {
return false;
}
@Override
public void setRTS(boolean value) throws IOException {
}
@Override
public boolean purgeHwBuffers(boolean purgeReadBuffers, boolean purgeWriteBuffers) throws IOException {
if (purgeReadBuffers) {
int result = mConnection.controlTransfer(FTDI_DEVICE_OUT_REQTYPE, SIO_RESET_REQUEST,
SIO_RESET_PURGE_RX, 0 /* index */, null, 0, USB_WRITE_TIMEOUT_MILLIS);
if (result != 0) {
throw new IOException("Flushing RX failed: result=" + result);
}
}
if (purgeWriteBuffers) {
int result = mConnection.controlTransfer(FTDI_DEVICE_OUT_REQTYPE, SIO_RESET_REQUEST,
SIO_RESET_PURGE_TX, 0 /* index */, null, 0, USB_WRITE_TIMEOUT_MILLIS);
if (result != 0) {
throw new IOException("Flushing RX failed: result=" + result);
}
}
return true;
}
}
public static Map getSupportedDevices() {
final Map supportedDevices = new LinkedHashMap();
supportedDevices.put(Integer.valueOf(UsbId.VENDOR_FTDI),
new int[] {
UsbId.FTDI_FT232R,
UsbId.FTDI_FT231X,
});
return supportedDevices;
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/ImportedLibraries/usbserial/driver/ProbeTable.java
================================================
/* Copyright 2011-2013 Google Inc.
* Copyright 2013 mike wakerly
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
* USA.
*
* Project home page: https://github.com/mik3y/usb-serial-for-android
*/
package com.eveningoutpost.dexdrip.ImportedLibraries.usbserial.driver;
import android.util.Pair;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* Maps (vendor id, product id) pairs to the corresponding serial driver.
*
* @author mike wakerly (opensource@hoho.com)
*/
public class ProbeTable {
private final Map, Class> mProbeTable =
new LinkedHashMap, Class>();
/**
* Adds or updates a (vendor, product) pair in the table.
*
* @param vendorId the USB vendor id
* @param productId the USB product id
* @param driverClass the driver class responsible for this pair
* @return {@code this}, for chaining
*/
public ProbeTable addProduct(int vendorId, int productId,
Class driverClass) {
mProbeTable.put(Pair.create(vendorId, productId), driverClass);
return this;
}
/**
* Internal method to add all supported products from
* {@code getSupportedProducts} static method.
*
* @param driverClass
* @return
*/
@SuppressWarnings("unchecked")
ProbeTable addDriver(Class driverClass) {
final Method method;
try {
method = driverClass.getMethod("getSupportedDevices");
} catch (SecurityException e) {
throw new RuntimeException(e);
} catch (NoSuchMethodException e) {
throw new RuntimeException(e);
}
final Map devices;
try {
devices = (Map) method.invoke(null);
} catch (IllegalArgumentException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
} catch (InvocationTargetException e) {
throw new RuntimeException(e);
}
for (Map.Entry entry : devices.entrySet()) {
final int vendorId = entry.getKey().intValue();
for (int productId : entry.getValue()) {
addProduct(vendorId, productId, driverClass);
}
}
return this;
}
/**
* Returns the driver for the given (vendor, product) pair, or {@code null}
* if no match.
*
* @param vendorId the USB vendor id
* @param productId the USB product id
* @return the driver class matching this pair, or {@code null}
*/
public Class findDriver(int vendorId, int productId) {
final Pair pair = Pair.create(vendorId, productId);
return mProbeTable.get(pair);
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/ImportedLibraries/usbserial/driver/ProlificSerialDriver.java
================================================
/* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
* USA.
*
* Project home page: https://github.com/mik3y/usb-serial-for-android
*/
/*
* Ported to usb-serial-for-android
* by Felix Hädicke
*
* Based on the pyprolific driver written
* by Emmanuel Blot
* See https://github.com/eblot/pyftdi
*/
package com.eveningoutpost.dexdrip.ImportedLibraries.usbserial.driver;
import android.hardware.usb.UsbConstants;
import android.hardware.usb.UsbDevice;
import android.hardware.usb.UsbDeviceConnection;
import android.hardware.usb.UsbEndpoint;
import android.hardware.usb.UsbInterface;
import android.hardware.usb.UsbRequest;
import android.util.Log;
import java.io.IOException;
import java.lang.reflect.Method;
import java.nio.ByteBuffer;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
public class ProlificSerialDriver implements UsbSerialDriver {
private final String TAG = ProlificSerialDriver.class.getSimpleName();
private final UsbDevice mDevice;
private final UsbSerialPort mPort;
public ProlificSerialDriver(UsbDevice device) {
mDevice = device;
mPort = new ProlificSerialPort(mDevice, 0);
}
@Override
public List getPorts() {
return Collections.singletonList(mPort);
}
@Override
public UsbDevice getDevice() {
return mDevice;
}
class ProlificSerialPort extends CommonUsbSerialPort {
private static final int USB_READ_TIMEOUT_MILLIS = 1000;
private static final int USB_WRITE_TIMEOUT_MILLIS = 5000;
private static final int USB_RECIP_INTERFACE = 0x01;
private static final int PROLIFIC_VENDOR_READ_REQUEST = 0x01;
private static final int PROLIFIC_VENDOR_WRITE_REQUEST = 0x01;
private static final int PROLIFIC_VENDOR_OUT_REQTYPE = UsbConstants.USB_DIR_OUT
| UsbConstants.USB_TYPE_VENDOR;
private static final int PROLIFIC_VENDOR_IN_REQTYPE = UsbConstants.USB_DIR_IN
| UsbConstants.USB_TYPE_VENDOR;
private static final int PROLIFIC_CTRL_OUT_REQTYPE = UsbConstants.USB_DIR_OUT
| UsbConstants.USB_TYPE_CLASS | USB_RECIP_INTERFACE;
private static final int WRITE_ENDPOINT = 0x02;
private static final int READ_ENDPOINT = 0x83;
private static final int INTERRUPT_ENDPOINT = 0x81;
private static final int FLUSH_RX_REQUEST = 0x08;
private static final int FLUSH_TX_REQUEST = 0x09;
private static final int SET_LINE_REQUEST = 0x20;
private static final int SET_CONTROL_REQUEST = 0x22;
private static final int CONTROL_DTR = 0x01;
private static final int CONTROL_RTS = 0x02;
private static final int STATUS_FLAG_CD = 0x01;
private static final int STATUS_FLAG_DSR = 0x02;
private static final int STATUS_FLAG_RI = 0x08;
private static final int STATUS_FLAG_CTS = 0x80;
private static final int STATUS_BUFFER_SIZE = 10;
private static final int STATUS_BYTE_IDX = 8;
private static final int DEVICE_TYPE_HX = 0;
private static final int DEVICE_TYPE_0 = 1;
private static final int DEVICE_TYPE_1 = 2;
private int mDeviceType = DEVICE_TYPE_HX;
private UsbEndpoint mReadEndpoint;
private UsbEndpoint mWriteEndpoint;
private UsbEndpoint mInterruptEndpoint;
private int mControlLinesValue = 0;
private int mBaudRate = -1, mDataBits = -1, mStopBits = -1, mParity = -1;
private int mStatus = 0;
private volatile Thread mReadStatusThread = null;
private final Object mReadStatusThreadLock = new Object();
boolean mStopReadStatusThread = false;
private IOException mReadStatusException = null;
public ProlificSerialPort(UsbDevice device, int portNumber) {
super(device, portNumber);
}
@Override
public UsbSerialDriver getDriver() {
return ProlificSerialDriver.this;
}
private final byte[] inControlTransfer(int requestType, int request,
int value, int index, int length) throws IOException {
byte[] buffer = new byte[length];
int result = mConnection.controlTransfer(requestType, request, value,
index, buffer, length, USB_READ_TIMEOUT_MILLIS);
if (result != length) {
throw new IOException(
String.format("ControlTransfer with value 0x%x failed: %d",
value, result));
}
return buffer;
}
private final void outControlTransfer(int requestType, int request,
int value, int index, byte[] data) throws IOException {
int length = (data == null) ? 0 : data.length;
int result = mConnection.controlTransfer(requestType, request, value,
index, data, length, USB_WRITE_TIMEOUT_MILLIS);
if (result != length) {
throw new IOException(
String.format("ControlTransfer with value 0x%x failed: %d",
value, result));
}
}
public int read(byte[] dest, int timeoutMillis, UsbDeviceConnection connection) throws IOException {
if (false) {
final UsbRequest request = new UsbRequest();
try {
request.initialize(connection, mReadEndpoint);
final ByteBuffer buf = ByteBuffer.wrap(dest);
if (!request.queue(buf, dest.length)) {
throw new IOException("Error queueing request.");
}
final UsbRequest response = connection.requestWait();
if (response == null) {
throw new IOException("Null response");
}
final int nread = buf.position();
if (nread > 0) {
//Log.d(TAG, HexDump.dumpHexString(dest, 0, Math.min(32, dest.length)));
return nread;
} else {
return 0;
}
} finally {
request.close();
}
}
final int numBytesRead;
synchronized (mReadBufferLock) {
int readAmt = Math.min(dest.length, mReadBuffer.length);
numBytesRead = connection.bulkTransfer(mReadEndpoint, mReadBuffer, readAmt,
timeoutMillis);
if (numBytesRead < 0) {
// This sucks: we get -1 on timeout, not 0 as preferred.
// We *should* use UsbRequest, except it has a bug/api oversight
// where there is no way to determine the number of bytes read
// in response :\ -- http://b.android.com/28023
if (timeoutMillis == Integer.MAX_VALUE) {
// Hack: Special case "~infinite timeout" as an error.
return -1;
}
return 0;
}
System.arraycopy(mReadBuffer, 0, dest, 0, numBytesRead);
}
return numBytesRead;
}
private final byte[] vendorIn(int value, int index, int length)
throws IOException {
return inControlTransfer(PROLIFIC_VENDOR_IN_REQTYPE,
PROLIFIC_VENDOR_READ_REQUEST, value, index, length);
}
private final void vendorOut(int value, int index, byte[] data)
throws IOException {
outControlTransfer(PROLIFIC_VENDOR_OUT_REQTYPE,
PROLIFIC_VENDOR_WRITE_REQUEST, value, index, data);
}
private void resetDevice() throws IOException {
purgeHwBuffers(true, true);
}
private final void ctrlOut(int request, int value, int index, byte[] data)
throws IOException {
outControlTransfer(PROLIFIC_CTRL_OUT_REQTYPE, request, value, index,
data);
}
private void doBlackMagic() throws IOException {
vendorIn(0x8484, 0, 1);
vendorOut(0x0404, 0, null);
vendorIn(0x8484, 0, 1);
vendorIn(0x8383, 0, 1);
vendorIn(0x8484, 0, 1);
vendorOut(0x0404, 1, null);
vendorIn(0x8484, 0, 1);
vendorIn(0x8383, 0, 1);
vendorOut(0, 1, null);
vendorOut(1, 0, null);
vendorOut(2, (mDeviceType == DEVICE_TYPE_HX) ? 0x44 : 0x24, null);
}
private void setControlLines(int newControlLinesValue) throws IOException {
ctrlOut(SET_CONTROL_REQUEST, newControlLinesValue, 0, null);
mControlLinesValue = newControlLinesValue;
}
private final void readStatusThreadFunction() {
try {
while (!mStopReadStatusThread) {
byte[] buffer = new byte[STATUS_BUFFER_SIZE];
int readBytesCount = mConnection.bulkTransfer(mInterruptEndpoint,
buffer,
STATUS_BUFFER_SIZE,
500);
if (readBytesCount > 0) {
if (readBytesCount == STATUS_BUFFER_SIZE) {
mStatus = buffer[STATUS_BYTE_IDX] & 0xff;
} else {
throw new IOException(
String.format("Invalid CTS / DSR / CD / RI status buffer received, expected %d bytes, but received %d",
STATUS_BUFFER_SIZE,
readBytesCount));
}
}
}
} catch (IOException e) {
mReadStatusException = e;
}
}
private final int getStatus() throws IOException {
if ((mReadStatusThread == null) && (mReadStatusException == null)) {
synchronized (mReadStatusThreadLock) {
if (mReadStatusThread == null) {
byte[] buffer = new byte[STATUS_BUFFER_SIZE];
int readBytes = mConnection.bulkTransfer(mInterruptEndpoint,
buffer,
STATUS_BUFFER_SIZE,
100);
if (readBytes != STATUS_BUFFER_SIZE) {
Log.w(TAG, "Could not read initial CTS / DSR / CD / RI status");
} else {
mStatus = buffer[STATUS_BYTE_IDX] & 0xff;
}
mReadStatusThread = new Thread(new Runnable() {
@Override
public void run() {
readStatusThreadFunction();
}
});
mReadStatusThread.setDaemon(true);
mReadStatusThread.start();
}
}
}
/* throw and clear an exception which occured in the status read thread */
IOException readStatusException = mReadStatusException;
if (mReadStatusException != null) {
mReadStatusException = null;
throw readStatusException;
}
return mStatus;
}
private final boolean testStatusFlag(int flag) throws IOException {
return ((getStatus() & flag) == flag);
}
@Override
public void open(UsbDeviceConnection connection) throws IOException {
if (mConnection != null) {
throw new IOException("Already open");
}
UsbInterface usbInterface = mDevice.getInterface(0);
if (!connection.claimInterface(usbInterface, true)) {
throw new IOException("Error claiming Prolific interface 0");
}
mConnection = connection;
boolean opened = false;
try {
for (int i = 0; i < usbInterface.getEndpointCount(); ++i) {
UsbEndpoint currentEndpoint = usbInterface.getEndpoint(i);
switch (currentEndpoint.getAddress()) {
case READ_ENDPOINT:
mReadEndpoint = currentEndpoint;
break;
case WRITE_ENDPOINT:
mWriteEndpoint = currentEndpoint;
break;
case INTERRUPT_ENDPOINT:
mInterruptEndpoint = currentEndpoint;
break;
}
}
if (mDevice.getDeviceClass() == 0x02) {
mDeviceType = DEVICE_TYPE_0;
} else {
try {
Method getRawDescriptorsMethod
= mConnection.getClass().getMethod("getRawDescriptors");
byte[] rawDescriptors
= (byte[]) getRawDescriptorsMethod.invoke(mConnection);
byte maxPacketSize0 = rawDescriptors[7];
if (maxPacketSize0 == 64) {
mDeviceType = DEVICE_TYPE_HX;
} else if ((mDevice.getDeviceClass() == 0x00)
|| (mDevice.getDeviceClass() == 0xff)) {
mDeviceType = DEVICE_TYPE_1;
} else {
Log.w(TAG, "Could not detect PL2303 subtype, "
+ "Assuming that it is a HX device");
mDeviceType = DEVICE_TYPE_HX;
}
} catch (NoSuchMethodException e) {
Log.w(TAG, "Method UsbDeviceConnection.getRawDescriptors, "
+ "required for PL2303 subtype detection, not "
+ "available! Assuming that it is a HX device");
mDeviceType = DEVICE_TYPE_HX;
} catch (Exception e) {
Log.e(TAG, "An unexpected exception occured while trying "
+ "to detect PL2303 subtype", e);
}
}
setControlLines(mControlLinesValue);
resetDevice();
doBlackMagic();
opened = true;
} finally {
if (!opened) {
mConnection = null;
connection.releaseInterface(usbInterface);
}
}
}
@Override
public void close() throws IOException {
if (mConnection == null) {
throw new IOException("Already closed");
}
try {
mStopReadStatusThread = true;
synchronized (mReadStatusThreadLock) {
if (mReadStatusThread != null) {
try {
mReadStatusThread.join();
} catch (Exception e) {
Log.w(TAG, "An error occured while waiting for status read thread", e);
}
}
}
resetDevice();
} finally {
try {
mConnection.releaseInterface(mDevice.getInterface(0));
} finally {
mConnection = null;
}
}
}
@Override
public int read(byte[] dest, int timeoutMillis) throws IOException {
synchronized (mReadBufferLock) {
int readAmt = Math.min(dest.length, mReadBuffer.length);
int numBytesRead = mConnection.bulkTransfer(mReadEndpoint, mReadBuffer,
readAmt, timeoutMillis);
if (numBytesRead < 0) {
return 0;
}
System.arraycopy(mReadBuffer, 0, dest, 0, numBytesRead);
return numBytesRead;
}
}
@Override
public int write(byte[] src, int timeoutMillis) throws IOException {
int offset = 0;
while (offset < src.length) {
final int writeLength;
final int amtWritten;
synchronized (mWriteBufferLock) {
final byte[] writeBuffer;
writeLength = Math.min(src.length - offset, mWriteBuffer.length);
if (offset == 0) {
writeBuffer = src;
} else {
// bulkTransfer does not support offsets, make a copy.
System.arraycopy(src, offset, mWriteBuffer, 0, writeLength);
writeBuffer = mWriteBuffer;
}
amtWritten = mConnection.bulkTransfer(mWriteEndpoint,
writeBuffer, writeLength, timeoutMillis);
}
if (amtWritten <= 0) {
throw new IOException("Error writing " + writeLength
+ " bytes at offset " + offset + " length="
+ src.length);
}
offset += amtWritten;
}
return offset;
}
@Override
public void setParameters(int baudRate, int dataBits, int stopBits,
int parity) throws IOException {
if ((mBaudRate == baudRate) && (mDataBits == dataBits)
&& (mStopBits == stopBits) && (mParity == parity)) {
// Make sure no action is performed if there is nothing to change
return;
}
byte[] lineRequestData = new byte[7];
lineRequestData[0] = (byte) (baudRate & 0xff);
lineRequestData[1] = (byte) ((baudRate >> 8) & 0xff);
lineRequestData[2] = (byte) ((baudRate >> 16) & 0xff);
lineRequestData[3] = (byte) ((baudRate >> 24) & 0xff);
switch (stopBits) {
case STOPBITS_1:
lineRequestData[4] = 0;
break;
case STOPBITS_1_5:
lineRequestData[4] = 1;
break;
case STOPBITS_2:
lineRequestData[4] = 2;
break;
default:
throw new IllegalArgumentException("Unknown stopBits value: " + stopBits);
}
switch (parity) {
case PARITY_NONE:
lineRequestData[5] = 0;
break;
case PARITY_ODD:
lineRequestData[5] = 1;
break;
case PARITY_MARK:
lineRequestData[5] = 3;
break;
case PARITY_SPACE:
lineRequestData[5] = 4;
break;
default:
throw new IllegalArgumentException("Unknown parity value: " + parity);
}
lineRequestData[6] = (byte) dataBits;
ctrlOut(SET_LINE_REQUEST, 0, 0, lineRequestData);
resetDevice();
mBaudRate = baudRate;
mDataBits = dataBits;
mStopBits = stopBits;
mParity = parity;
}
@Override
public boolean getCD() throws IOException {
return testStatusFlag(STATUS_FLAG_CD);
}
@Override
public boolean getCTS() throws IOException {
return testStatusFlag(STATUS_FLAG_CTS);
}
@Override
public boolean getDSR() throws IOException {
return testStatusFlag(STATUS_FLAG_DSR);
}
@Override
public boolean getDTR() throws IOException {
return ((mControlLinesValue & CONTROL_DTR) == CONTROL_DTR);
}
@Override
public void setDTR(boolean value) throws IOException {
int newControlLinesValue;
if (value) {
newControlLinesValue = mControlLinesValue | CONTROL_DTR;
} else {
newControlLinesValue = mControlLinesValue & ~CONTROL_DTR;
}
setControlLines(newControlLinesValue);
}
@Override
public boolean getRI() throws IOException {
return testStatusFlag(STATUS_FLAG_RI);
}
@Override
public boolean getRTS() throws IOException {
return ((mControlLinesValue & CONTROL_RTS) == CONTROL_RTS);
}
@Override
public void setRTS(boolean value) throws IOException {
int newControlLinesValue;
if (value) {
newControlLinesValue = mControlLinesValue | CONTROL_RTS;
} else {
newControlLinesValue = mControlLinesValue & ~CONTROL_RTS;
}
setControlLines(newControlLinesValue);
}
@Override
public boolean purgeHwBuffers(boolean purgeReadBuffers, boolean purgeWriteBuffers) throws IOException {
if (purgeReadBuffers) {
vendorOut(FLUSH_RX_REQUEST, 0, null);
}
if (purgeWriteBuffers) {
vendorOut(FLUSH_TX_REQUEST, 0, null);
}
return purgeReadBuffers || purgeWriteBuffers;
}
}
public static Map getSupportedDevices() {
final Map supportedDevices = new LinkedHashMap();
supportedDevices.put(Integer.valueOf(UsbId.VENDOR_PROLIFIC),
new int[] { UsbId.PROLIFIC_PL2303, });
return supportedDevices;
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/ImportedLibraries/usbserial/driver/UsbId.java
================================================
/* Copyright 2011-2013 Google Inc.
* Copyright 2013 mike wakerly
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
* USA.
*
* Project home page: https://github.com/mik3y/usb-serial-for-android
*/
package com.eveningoutpost.dexdrip.ImportedLibraries.usbserial.driver;
/**
* Registry of USB vendor/product ID constants.
*
* Culled from various sources; see
* usb.ids for one listing.
*
* @author mike wakerly (opensource@hoho.com)
*/
public final class UsbId {
public static final int VENDOR_FTDI = 0x0403;
public static final int FTDI_FT232R = 0x6001;
public static final int FTDI_FT231X = 0x6015;
public static final int VENDOR_ATMEL = 0x03EB;
public static final int ATMEL_LUFA_CDC_DEMO_APP = 0x2044;
public static final int VENDOR_ARDUINO = 0x2341;
public static final int ARDUINO_UNO = 0x0001;
public static final int ARDUINO_MEGA_2560 = 0x0010;
public static final int ARDUINO_SERIAL_ADAPTER = 0x003b;
public static final int ARDUINO_MEGA_ADK = 0x003f;
public static final int ARDUINO_MEGA_2560_R3 = 0x0042;
public static final int ARDUINO_UNO_R3 = 0x0043;
public static final int ARDUINO_MEGA_ADK_R3 = 0x0044;
public static final int ARDUINO_SERIAL_ADAPTER_R3 = 0x0044;
public static final int ARDUINO_LEONARDO = 0x8036;
public static final int VENDOR_VAN_OOIJEN_TECH = 0x16c0;
public static final int VAN_OOIJEN_TECH_TEENSYDUINO_SERIAL = 0x0483;
public static final int VENDOR_LEAFLABS = 0x1eaf;
public static final int LEAFLABS_MAPLE = 0x0004;
public static final int VENDOR_SILABS = 0x10c4;
public static final int SILABS_CP2102 = 0xea60;
public static final int SILABS_CP2105 = 0xea70;
public static final int SILABS_CP2108 = 0xea71;
public static final int SILABS_CP2110 = 0xea80;
public static final int VENDOR_PROLIFIC = 0x067b;
public static final int PROLIFIC_PL2303 = 0x2303;
private UsbId() {
throw new IllegalAccessError("Non-instantiable class.");
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/ImportedLibraries/usbserial/driver/UsbSerialDriver.java
================================================
/* Copyright 2011-2013 Google Inc.
* Copyright 2013 mike wakerly
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
* USA.
*
* Project home page: https://github.com/mik3y/usb-serial-for-android
*/
package com.eveningoutpost.dexdrip.ImportedLibraries.usbserial.driver;
import android.hardware.usb.UsbDevice;
import java.util.List;
/**
*
* @author mike wakerly (opensource@hoho.com)
*/
public interface UsbSerialDriver {
/**
* Returns the raw {@link UsbDevice} backing this port.
*
* @return the device
*/
public UsbDevice getDevice();
/**
* Returns all available ports for this device. This list must have at least
* one entry.
*
* @return the ports
*/
public List getPorts();
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/ImportedLibraries/usbserial/driver/UsbSerialPort.java
================================================
/* Copyright 2011-2013 Google Inc.
* Copyright 2013 mike wakerly
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
* USA.
*
* Project home page: https://github.com/mik3y/usb-serial-for-android
*/
package com.eveningoutpost.dexdrip.ImportedLibraries.usbserial.driver;
import android.hardware.usb.UsbDeviceConnection;
import android.hardware.usb.UsbManager;
import java.io.IOException;
/**
* Interface for a single serial port.
*
* @author mike wakerly (opensource@hoho.com)
*/
public interface UsbSerialPort {
/** 5 data bits. */
public static final int DATABITS_5 = 5;
/** 6 data bits. */
public static final int DATABITS_6 = 6;
/** 7 data bits. */
public static final int DATABITS_7 = 7;
/** 8 data bits. */
public static final int DATABITS_8 = 8;
/** No flow control. */
public static final int FLOWCONTROL_NONE = 0;
/** RTS/CTS input flow control. */
public static final int FLOWCONTROL_RTSCTS_IN = 1;
/** RTS/CTS output flow control. */
public static final int FLOWCONTROL_RTSCTS_OUT = 2;
/** XON/XOFF input flow control. */
public static final int FLOWCONTROL_XONXOFF_IN = 4;
/** XON/XOFF output flow control. */
public static final int FLOWCONTROL_XONXOFF_OUT = 8;
/** No parity. */
public static final int PARITY_NONE = 0;
/** Odd parity. */
public static final int PARITY_ODD = 1;
/** Even parity. */
public static final int PARITY_EVEN = 2;
/** Mark parity. */
public static final int PARITY_MARK = 3;
/** Space parity. */
public static final int PARITY_SPACE = 4;
/** 1 stop bit. */
public static final int STOPBITS_1 = 1;
/** 1.5 stop bits. */
public static final int STOPBITS_1_5 = 3;
/** 2 stop bits. */
public static final int STOPBITS_2 = 2;
public UsbSerialDriver getDriver();
/**
* Port number within driver.
*/
public int getPortNumber();
/**
* The serial number of the underlying UsbDeviceConnection, or {@code null}.
*/
public String getSerial();
/**
* Opens and initializes the port. Upon success, caller must ensure that
* {@link #close()} is eventually called.
*
* @param connection an open device connection, acquired with
* {@link UsbManager#openDevice(android.hardware.usb.UsbDevice)}
* @throws IOException on error opening or initializing the port.
*/
public void open(UsbDeviceConnection connection) throws IOException;
/**
* Closes the port.
*
* @throws IOException on error closing the port.
*/
public void close() throws IOException;
/**
* Reads as many bytes as possible into the destination buffer.
*
* @param dest the destination byte buffer
* @param timeoutMillis the timeout for reading
* @return the actual number of bytes read
* @throws IOException if an error occurred during reading
*/
public int read(final byte[] dest, final int timeoutMillis) throws IOException;
public int read(final byte[] dest, final int timeoutMillis, final UsbDeviceConnection connection) throws IOException;
/**
* Writes as many bytes as possible from the source buffer.
*
* @param src the source byte buffer
* @param timeoutMillis the timeout for writing
* @return the actual number of bytes written
* @throws IOException if an error occurred during writing
*/
public int write(final byte[] src, final int timeoutMillis) throws IOException;
/**
* Sets various serial port parameters.
*
* @param baudRate baud rate as an integer, for example {@code 115200}.
* @param dataBits one of {@link #DATABITS_5}, {@link #DATABITS_6},
* {@link #DATABITS_7}, or {@link #DATABITS_8}.
* @param stopBits one of {@link #STOPBITS_1}, {@link #STOPBITS_1_5}, or
* {@link #STOPBITS_2}.
* @param parity one of {@link #PARITY_NONE}, {@link #PARITY_ODD},
* {@link #PARITY_EVEN}, {@link #PARITY_MARK}, or
* {@link #PARITY_SPACE}.
* @throws IOException on error setting the port parameters
*/
public void setParameters(
int baudRate, int dataBits, int stopBits, int parity) throws IOException;
/**
* Gets the CD (Carrier Detect) bit from the underlying UART.
*
* @return the current state, or {@code false} if not supported.
* @throws IOException if an error occurred during reading
*/
public boolean getCD() throws IOException;
/**
* Gets the CTS (Clear To Send) bit from the underlying UART.
*
* @return the current state, or {@code false} if not supported.
* @throws IOException if an error occurred during reading
*/
public boolean getCTS() throws IOException;
/**
* Gets the DSR (Data Set Ready) bit from the underlying UART.
*
* @return the current state, or {@code false} if not supported.
* @throws IOException if an error occurred during reading
*/
public boolean getDSR() throws IOException;
/**
* Gets the DTR (Data Terminal Ready) bit from the underlying UART.
*
* @return the current state, or {@code false} if not supported.
* @throws IOException if an error occurred during reading
*/
public boolean getDTR() throws IOException;
/**
* Sets the DTR (Data Terminal Ready) bit on the underlying UART, if
* supported.
*
* @param value the value to set
* @throws IOException if an error occurred during writing
*/
public void setDTR(boolean value) throws IOException;
/**
* Gets the RI (Ring Indicator) bit from the underlying UART.
*
* @return the current state, or {@code false} if not supported.
* @throws IOException if an error occurred during reading
*/
public boolean getRI() throws IOException;
/**
* Gets the RTS (Request To Send) bit from the underlying UART.
*
* @return the current state, or {@code false} if not supported.
* @throws IOException if an error occurred during reading
*/
public boolean getRTS() throws IOException;
/**
* Sets the RTS (Request To Send) bit on the underlying UART, if
* supported.
*
* @param value the value to set
* @throws IOException if an error occurred during writing
*/
public void setRTS(boolean value) throws IOException;
/**
* Flush non-transmitted output data and / or non-read input data
* @param flushRX {@code true} to flush non-transmitted output data
* @param flushTX {@code true} to flush non-read input data
* @return {@code true} if the operation was successful, or
* {@code false} if the operation is not supported by the driver or device
* @throws IOException if an error occurred during flush
*/
public boolean purgeHwBuffers(boolean flushRX, boolean flushTX) throws IOException;
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/ImportedLibraries/usbserial/driver/UsbSerialProber.java
================================================
/* Copyright 2011-2013 Google Inc.
* Copyright 2013 mike wakerly
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
* USA.
*
* Project home page: https://github.com/mik3y/usb-serial-for-android
*/
package com.eveningoutpost.dexdrip.ImportedLibraries.usbserial.driver;
import android.hardware.usb.UsbDevice;
import android.hardware.usb.UsbManager;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;
/**
*
* @author mike wakerly (opensource@hoho.com)
*/
public class UsbSerialProber {
private final ProbeTable mProbeTable;
public UsbSerialProber(ProbeTable probeTable) {
mProbeTable = probeTable;
}
public static UsbSerialProber getDefaultProber() {
return new UsbSerialProber(getDefaultProbeTable());
}
public static ProbeTable getDefaultProbeTable() {
final ProbeTable probeTable = new ProbeTable();
probeTable.addDriver(CdcAcmSerialDriver.class);
probeTable.addDriver(Cp21xxSerialDriver.class);
probeTable.addDriver(FtdiSerialDriver.class);
probeTable.addDriver(ProlificSerialDriver.class);
return probeTable;
}
/**
* Finds and builds all possible {@link UsbSerialDriver UsbSerialDrivers}
* from the currently-attached {@link UsbDevice} hierarchy. This method does
* not require permission from the Android USB system, since it does not
* open any of the devices.
*
* @param usbManager
* @return a list, possibly empty, of all compatible drivers
*/
public List findAllDrivers(final UsbManager usbManager) {
final List result = new ArrayList();
for (final UsbDevice usbDevice : usbManager.getDeviceList().values()) {
final UsbSerialDriver driver = probeDevice(usbDevice);
if (driver != null) {
result.add(driver);
}
}
return result;
}
/**
* Probes a single device for a compatible driver.
*
* @param usbDevice the usb device to probe
* @return a new {@link UsbSerialDriver} compatible with this device, or
* {@code null} if none available.
*/
public UsbSerialDriver probeDevice(final UsbDevice usbDevice) {
final int vendorId = usbDevice.getVendorId();
final int productId = usbDevice.getProductId();
final Class driverClass =
mProbeTable.findDriver(vendorId, productId);
if (driverClass != null) {
final UsbSerialDriver driver;
try {
final Constructor ctor =
driverClass.getConstructor(UsbDevice.class);
driver = ctor.newInstance(usbDevice);
} catch (NoSuchMethodException e) {
throw new RuntimeException(e);
} catch (IllegalArgumentException e) {
throw new RuntimeException(e);
} catch (InstantiationException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
} catch (InvocationTargetException e) {
throw new RuntimeException(e);
}
return driver;
}
return null;
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/ImportedLibraries/usbserial/driver/UsbSerialRuntimeException.java
================================================
/*
* Copyright 2011 Google Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
* USA.
*/
package com.eveningoutpost.dexdrip.ImportedLibraries.usbserial.driver;
/**
* Generic unchecked exception for the usbserial package.
*
* @author mike wakerly (opensource@hoho.com)
*/
@SuppressWarnings("serial")
public class UsbSerialRuntimeException extends RuntimeException {
public UsbSerialRuntimeException() {
super();
}
public UsbSerialRuntimeException(String detailMessage, Throwable throwable) {
super(detailMessage, throwable);
}
public UsbSerialRuntimeException(String detailMessage) {
super(detailMessage);
}
public UsbSerialRuntimeException(Throwable throwable) {
super(throwable);
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/ImportedLibraries/usbserial/util/HexDump.java
================================================
/*
* Copyright (C) 2006 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.eveningoutpost.dexdrip.ImportedLibraries.usbserial.util;
/**
* Clone of Android's HexDump class, for use in debugging. Cosmetic changes
* only.
*/
public class HexDump {
private final static char[] HEX_DIGITS = {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
};
public static String dumpHexString(byte[] array) {
return dumpHexString(array, 0, array.length);
}
public static String dumpHexString(byte[] array, int offset, int length) {
StringBuilder result = new StringBuilder();
byte[] line = new byte[16];
int lineIndex = 0;
result.append("\n0x");
result.append(toHexString(offset));
for (int i = offset; i < offset + length; i++) {
if (lineIndex == 16) {
result.append(" ");
for (int j = 0; j < 16; j++) {
if (line[j] > ' ' && line[j] < '~') {
result.append(new String(line, j, 1));
} else {
result.append(".");
}
}
result.append("\n0x");
result.append(toHexString(i));
lineIndex = 0;
}
byte b = array[i];
result.append(" ");
result.append(HEX_DIGITS[(b >>> 4) & 0x0F]);
result.append(HEX_DIGITS[b & 0x0F]);
line[lineIndex++] = b;
}
if (lineIndex != 16) {
int count = (16 - lineIndex) * 3;
count++;
for (int i = 0; i < count; i++) {
result.append(" ");
}
for (int i = 0; i < lineIndex; i++) {
if (line[i] > ' ' && line[i] < '~') {
result.append(new String(line, i, 1));
} else {
result.append(".");
}
}
}
return result.toString();
}
public static String toHexString(byte b) {
return toHexString(toByteArray(b));
}
public static String toHexString(byte[] array) {
return toHexString(array, 0, array.length);
}
public static String toHexString(byte[] array, int offset, int length) {
char[] buf = new char[length * 2];
int bufIndex = 0;
for (int i = offset; i < offset + length; i++) {
byte b = array[i];
buf[bufIndex++] = HEX_DIGITS[(b >>> 4) & 0x0F];
buf[bufIndex++] = HEX_DIGITS[b & 0x0F];
}
return new String(buf);
}
public static String toHexString(int i) {
return toHexString(toByteArray(i));
}
public static String toHexString(short i) {
return toHexString(toByteArray(i));
}
public static byte[] toByteArray(byte b) {
byte[] array = new byte[1];
array[0] = b;
return array;
}
public static byte[] toByteArray(int i) {
byte[] array = new byte[4];
array[3] = (byte) (i & 0xFF);
array[2] = (byte) ((i >> 8) & 0xFF);
array[1] = (byte) ((i >> 16) & 0xFF);
array[0] = (byte) ((i >> 24) & 0xFF);
return array;
}
public static byte[] toByteArray(short i) {
byte[] array = new byte[2];
array[1] = (byte) (i & 0xFF);
array[0] = (byte) ((i >> 8) & 0xFF);
return array;
}
private static int toByte(char c) {
if (c >= '0' && c <= '9')
return (c - '0');
if (c >= 'A' && c <= 'F')
return (c - 'A' + 10);
if (c >= 'a' && c <= 'f')
return (c - 'a' + 10);
throw new RuntimeException("Invalid hex char '" + c + "'");
}
public static byte[] hexStringToByteArray(String hexString) {
int length = hexString.length();
byte[] buffer = new byte[length / 2];
for (int i = 0; i < length; i += 2) {
buffer[i / 2] = (byte) ((toByte(hexString.charAt(i)) << 4) | toByte(hexString
.charAt(i + 1)));
}
return buffer;
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/ImportedLibraries/usbserial/util/SerialInputOutputManager.java
================================================
/* Copyright 2011-2013 Google Inc.
* Copyright 2013 mike wakerly
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
* USA.
*
* Project home page: https://github.com/mik3y/usb-serial-for-android
*/
package com.eveningoutpost.dexdrip.ImportedLibraries.usbserial.util;
import android.hardware.usb.UsbRequest;
import android.util.Log;
import com.eveningoutpost.dexdrip.ImportedLibraries.usbserial.driver.UsbSerialPort;
import java.io.IOException;
import java.nio.ByteBuffer;
/**
* Utility class which services a {@link UsbSerialPort} in its {@link #run()}
* method.
*
* @author mike wakerly (opensource@hoho.com)
*/
public class SerialInputOutputManager implements Runnable {
private static final String TAG = SerialInputOutputManager.class.getSimpleName();
private static final boolean DEBUG = true;
private static final int READ_WAIT_MILLIS = 200;
private static final int BUFSIZ = 4096;
private final UsbSerialPort mDriver;
private final ByteBuffer mReadBuffer = ByteBuffer.allocate(BUFSIZ);
// Synchronized by 'mWriteBuffer'
private final ByteBuffer mWriteBuffer = ByteBuffer.allocate(BUFSIZ);
private enum State {
STOPPED,
RUNNING,
STOPPING
}
// Synchronized by 'this'
private State mState = State.STOPPED;
// Synchronized by 'this'
private Listener mListener;
public interface Listener {
/**
* Called when new incoming data is available.
*/
public void onNewData(byte[] data);
/**
* Called when {@link SerialInputOutputManager#run()} aborts due to an
* error.
*/
public void onRunError(Exception e);
}
/**
* Creates a new instance with no listener.
*/
public SerialInputOutputManager(UsbSerialPort driver) {
this(driver, null);
}
/**
* Creates a new instance with the provided listener.
*/
public SerialInputOutputManager(UsbSerialPort driver, Listener listener) {
mDriver = driver;
mListener = listener;
}
public synchronized void setListener(Listener listener) {
mListener = listener;
}
public synchronized Listener getListener() {
return mListener;
}
public void writeAsync(byte[] data) {
synchronized (mWriteBuffer) {
mWriteBuffer.put(data);
}
}
public synchronized void stop() {
if (getState() == State.RUNNING) {
Log.i(TAG, "Stop requested");
mState = State.STOPPING;
}
}
private synchronized State getState() {
return mState;
}
/**
* Continuously services the read and write buffers until {@link #stop()} is
* called, or until a driver exception is raised.
*
* NOTE(mikey): Uses inefficient read/write-with-timeout.
* TODO(mikey): Read asynchronously with {@link UsbRequest#queue(ByteBuffer, int)}
*/
@Override
public void run() {
synchronized (this) {
if (getState() != State.STOPPED) {
throw new IllegalStateException("Already running.");
}
mState = State.RUNNING;
}
Log.i(TAG, "Running ..");
try {
while (true) {
if (getState() != State.RUNNING) {
Log.i(TAG, "Stopping mState=" + getState());
break;
}
step();
}
} catch (Exception e) {
Log.w(TAG, "Run ending due to exception: " + e.getMessage(), e);
final Listener listener = getListener();
if (listener != null) {
listener.onRunError(e);
}
} finally {
synchronized (this) {
mState = State.STOPPED;
Log.i(TAG, "Stopped.");
}
}
}
private void step() throws IOException {
// Handle incoming data.
int len = mDriver.read(mReadBuffer.array(), READ_WAIT_MILLIS);
if (len > 0) {
if (DEBUG) Log.d(TAG, "Read data len=" + len);
final Listener listener = getListener();
if (listener != null) {
final byte[] data = new byte[len];
mReadBuffer.get(data, 0, len);
listener.onNewData(data);
}
mReadBuffer.clear();
}
// Handle outgoing data.
byte[] outBuff = null;
synchronized (mWriteBuffer) {
len = mWriteBuffer.position();
if (len > 0) {
outBuff = new byte[len];
mWriteBuffer.rewind();
mWriteBuffer.get(outBuff, 0, len);
mWriteBuffer.clear();
}
}
if (outBuff != null) {
if (DEBUG) {
Log.d(TAG, "Writing data len=" + len);
}
mDriver.write(outBuff, READ_WAIT_MILLIS);
}
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/Interfaces/BgReadingInterface.java
================================================
package com.eveningoutpost.dexdrip.Interfaces;
import com.eveningoutpost.dexdrip.Models.BgReading;
import retrofit.Callback;
import retrofit.http.Body;
import retrofit.http.POST;
import retrofit.http.PUT;
import retrofit.http.Path;
/**
* Created by stephenblack on 11/6/14.
*/
public interface BgReadingInterface {
@POST("/api/v1/users/{user_uuid}/BgReadings/new")
void createReading(@Path("user_uuid") String user_uuid, @Body BgReading bgReading, Callback callback);
@PUT("/api/v1/users/{user_uuid}/BgReading/{bgReading_uuid}")
void updateReading(@Path("user_uuid") String user_uuid, @Path("bgReading_uuid") String uuid, @Body BgReading bgReading, Callback callback);
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/Interfaces/CalibrationInterface.java
================================================
package com.eveningoutpost.dexdrip.Interfaces;
import com.eveningoutpost.dexdrip.Models.Calibration;
import retrofit.Callback;
import retrofit.http.Body;
import retrofit.http.POST;
import retrofit.http.Path;
/**
* Created by stephenblack on 11/7/14.
*/
public interface CalibrationInterface {
@POST("/api/v1/users/{user_uuid}/calibrations/new")
void createCalibration(@Path("user_uuid") String user_uuid, @Body Calibration calibration, Callback callback);
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/Interfaces/SensorInterface.java
================================================
package com.eveningoutpost.dexdrip.Interfaces;
import com.eveningoutpost.dexdrip.Sensor;
import retrofit.Callback;
import retrofit.http.Body;
import retrofit.http.POST;
import retrofit.http.Path;
/**
* Created by stephenblack on 11/7/14.
*/
public interface SensorInterface {
@POST("/api/v1/users/{user_uuid}/sensors/new")
void createSensor(@Path("user_uuid") String user_uuid, @Body Sensor sensor, Callback callback);
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/Interfaces/UserInterface.java
================================================
package com.eveningoutpost.dexdrip.Interfaces;
import com.eveningoutpost.dexdrip.Models.User;
import retrofit.Callback;
import retrofit.http.Body;
import retrofit.http.POST;
/**
* Created by stephenblack on 11/10/14.
*/
public interface UserInterface {
@POST("/api/v1/sessions/new")
void authenticate(@Body User user, Callback callback);
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/LicenseAgreementActivity.java
================================================
package com.eveningoutpost.dexdrip;
import android.app.Activity;
import android.content.Intent;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.Button;
import android.widget.CheckBox;
import android.widget.EditText;
import com.eveningoutpost.dexdrip.Models.BgReading;
public class LicenseAgreementActivity extends Activity {
boolean IUnderstand;
CheckBox agreeCheckBox;
Button saveButton;
SharedPreferences prefs;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
prefs = PreferenceManager.getDefaultSharedPreferences(getApplicationContext());
IUnderstand = prefs.getBoolean("I_understand", false);
setContentView(R.layout.activity_license_agreement);
agreeCheckBox = (CheckBox)findViewById(R.id.agreeCheckBox);
agreeCheckBox.setChecked(IUnderstand);
saveButton = (Button)findViewById(R.id.saveButton);
addListenerOnButton();
}
public void addListenerOnButton() {
saveButton.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
prefs.edit().putBoolean("I_understand", agreeCheckBox.isChecked()).apply();
Intent intent = new Intent(getApplicationContext(), Home.class);
startActivity(intent);
finish();
}
});
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/Models/ActiveBluetoothDevice.java
================================================
package com.eveningoutpost.dexdrip.Models;
import android.provider.BaseColumns;
import com.activeandroid.Model;
import com.activeandroid.annotation.Column;
import com.activeandroid.annotation.Table;
import com.activeandroid.query.Select;
/**
* Created by stephenblack on 11/3/14.
*/
@Table(name = "ActiveBluetoothDevice", id = BaseColumns._ID)
public class ActiveBluetoothDevice extends Model {
@Column(name = "name")
public String name;
@Column(name = "address")
public String address;
@Column(name = "connected")
public boolean connected;
public static ActiveBluetoothDevice first() {
return new Select()
.from(ActiveBluetoothDevice.class)
.orderBy("_ID asc")
.executeSingle();
}
public static void forget() {
ActiveBluetoothDevice activeBluetoothDevice = ActiveBluetoothDevice.first();
if (activeBluetoothDevice != null) {
activeBluetoothDevice.delete();
}
}
public static void connected() {
ActiveBluetoothDevice activeBluetoothDevice = ActiveBluetoothDevice.first();
if(activeBluetoothDevice != null) {
activeBluetoothDevice.connected = true;
activeBluetoothDevice.save();
}
}
public static void disconnected() {
ActiveBluetoothDevice activeBluetoothDevice = ActiveBluetoothDevice.first();
if(activeBluetoothDevice != null) {
activeBluetoothDevice.connected = false;
activeBluetoothDevice.save();
}
}
public static boolean is_connected() {
ActiveBluetoothDevice activeBluetoothDevice = ActiveBluetoothDevice.first();
if(activeBluetoothDevice != null) {
return activeBluetoothDevice.connected;
}
return false;
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/Models/BgReading.java
================================================
package com.eveningoutpost.dexdrip.Models;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.preference.PreferenceManager;
import android.provider.BaseColumns;
import android.util.Log;
import com.activeandroid.Model;
import com.activeandroid.annotation.Column;
import com.activeandroid.annotation.Table;
import com.activeandroid.query.Select;
import com.eveningoutpost.dexdrip.ImportedLibraries.dexcom.records.CalSubrecord;
import com.eveningoutpost.dexdrip.ImportedLibraries.dexcom.records.EGVRecord;
import com.eveningoutpost.dexdrip.ImportedLibraries.dexcom.records.SensorRecord;
import com.eveningoutpost.dexdrip.Sensor;
import com.eveningoutpost.dexdrip.Services.DexShareCollectionService;
import com.eveningoutpost.dexdrip.UtilityModels.BgSendQueue;
import com.eveningoutpost.dexdrip.UtilityModels.Constants;
import com.eveningoutpost.dexdrip.UtilityModels.Notifications;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.annotations.Expose;
import com.google.gson.internal.bind.DateTypeAdapter;
import java.text.DecimalFormat;
import java.util.Date;
import java.util.List;
import java.util.UUID;
@Table(name = "BgReadings", id = BaseColumns._ID)
public class BgReading extends Model {
private final static String TAG = BgReading.class.getSimpleName();
//TODO: Have these as adjustable settings!!
public final static double BESTOFFSET = (60000 * 0); // Assume readings are about x minutes off from actual!
@Column(name = "sensor", index = true)
public Sensor sensor;
@Column(name = "calibration", index = true)
public Calibration calibration;
@Expose
@Column(name = "timestamp", index = true)
public long timestamp;
@Expose
@Column(name = "time_since_sensor_started")
public double time_since_sensor_started;
@Expose
@Column(name = "raw_data")
public double raw_data;
@Expose
@Column(name = "filtered_data")
public double filtered_data;
@Expose
@Column(name = "age_adjusted_raw_value")
public double age_adjusted_raw_value;
@Expose
@Column(name = "calibration_flag")
public boolean calibration_flag;
@Expose
@Column(name = "calculated_value")
public double calculated_value;
@Expose
@Column(name = "calculated_value_slope")
public double calculated_value_slope;
@Expose
@Column(name = "a")
public double a;
@Expose
@Column(name = "b")
public double b;
@Expose
@Column(name = "c")
public double c;
@Expose
@Column(name = "ra")
public double ra;
@Expose
@Column(name = "rb")
public double rb;
@Expose
@Column(name = "rc")
public double rc;
@Expose
@Column(name = "uuid", index = true)
public String uuid;
@Expose
@Column(name = "calibration_uuid")
public String calibration_uuid;
@Expose
@Column(name = "sensor_uuid", index = true)
public String sensor_uuid;
@Column(name = "snyced")
public boolean synced;
@Column(name = "raw_calculated")
public double raw_calculated;
@Column(name = "hide_slope")
public boolean hide_slope;
@Column(name = "noise")
public String noise;
public double calculated_value_mmol() {
return mmolConvert(calculated_value);
}
public double mmolConvert(double mgdl) {
return mgdl * Constants.MGDL_TO_MMOLL;
}
public String displayValue(Context context) {
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
String unit = prefs.getString("units", "mgdl");
DecimalFormat df = new DecimalFormat("#");
df.setMaximumFractionDigits(0);
if (calculated_value >= 400) {
return "HIGH";
} else if (calculated_value >= 40) {
if(unit.compareTo("mgdl") == 0) {
df.setMaximumFractionDigits(0);
return df.format(calculated_value);
} else {
df.setMaximumFractionDigits(1);
return df.format(calculated_value_mmol());
}
} else {
return "LOW";
}
}
public static double activeSlope() {
BgReading bgReading = BgReading.lastNoSenssor();
double slope = (2 * bgReading.a * (new Date().getTime() + BESTOFFSET)) + bgReading.b;
Log.w(TAG, "ESTIMATE SLOPE" + slope);
return slope;
}
public static double activePrediction() {
BgReading bgReading = BgReading.lastNoSenssor();
if (bgReading != null) {
double currentTime = new Date().getTime();
if (currentTime >= bgReading.timestamp + (60000 * 7)) { currentTime = bgReading.timestamp + (60000 * 7); }
double time = currentTime + BESTOFFSET;
return ((bgReading.a * time * time) + (bgReading.b * time) + bgReading.c);
}
return 0;
}
//*******CLASS METHODS***********//
public static void create(EGVRecord[] egvRecords, long addativeOffset, Context context) {
for(EGVRecord egvRecord : egvRecords) { BgReading.create(egvRecord, addativeOffset, context); }
}
public static void create(SensorRecord[] sensorRecords, long addativeOffset, Context context) {
for(SensorRecord sensorRecord : sensorRecords) { BgReading.create(sensorRecord, addativeOffset, context); }
}
public static void create(SensorRecord sensorRecord, long addativeOffset, Context context) {
Log.w(TAG, "gonna make some sensor records: " + sensorRecord.getUnfiltered());
if(BgReading.is_new(sensorRecord, addativeOffset)) {
BgReading bgReading = new BgReading();
Sensor sensor = Sensor.currentSensor();
Calibration calibration = Calibration.getForTimestamp(sensorRecord.getSystemTime().getTime() + addativeOffset);
if(sensor != null && calibration != null) {
bgReading.sensor = sensor;
bgReading.sensor_uuid = sensor.uuid;
bgReading.calibration = calibration;
bgReading.calibration_uuid = calibration.uuid;
bgReading.raw_data = (sensorRecord.getUnfiltered() / 1000);
bgReading.filtered_data = (sensorRecord.getFiltered() / 1000);
bgReading.timestamp = sensorRecord.getSystemTime().getTime() + addativeOffset;
if(bgReading.timestamp > new Date().getTime()) { return; }
bgReading.uuid = UUID.randomUUID().toString();
bgReading.time_since_sensor_started = bgReading.timestamp - sensor.started_at;
bgReading.synced = false;
bgReading.calculateAgeAdjustedRawValue();
bgReading.save();
}
}
}
public static void create(EGVRecord egvRecord, long addativeOffset, Context context) {
BgReading bgReading = BgReading.getForTimestamp(egvRecord.getSystemTime().getTime() + addativeOffset);
Log.w(TAG, "Looking for BG reading to tag this thing to: " + egvRecord.getBGValue());
if(bgReading != null) {
bgReading.calculated_value = egvRecord.getBGValue();
if (egvRecord.getBGValue() <= 13) {
Calibration calibration = bgReading.calibration;
double firstAdjSlope = calibration.first_slope + (calibration.first_decay * (Math.ceil(new Date().getTime() - calibration.timestamp)/(1000 * 60 * 10)));
double calSlope = (calibration.first_scale / firstAdjSlope)*1000;
double calIntercept = ((calibration.first_scale * calibration.first_intercept) / firstAdjSlope)*-1;
bgReading.raw_calculated = (((calSlope * bgReading.raw_data) + calIntercept) - 5);
bgReading.noise = egvRecord.noiseValue();
}
Log.w(TAG, "NEW VALUE CALCULATED AT: " + bgReading.calculated_value);
bgReading.calculated_value_slope = bgReading.slopefromName(egvRecord.getTrend().friendlyTrendName());
if(egvRecord.getTrend().friendlyTrendName().compareTo("NOT_COMPUTABLE") == 0 || egvRecord.getTrend().friendlyTrendName().compareTo("OUT_OF_RANGE") == 0) {
bgReading.hide_slope = true;
}
bgReading.save();
bgReading.find_new_curve();
bgReading.find_new_raw_curve();
Notifications.notificationSetter(context);
BgSendQueue.addToQueue(bgReading, "create", context);
}
}
public static BgReading getForTimestamp(double timestamp) {
Sensor sensor = Sensor.currentSensor();
if(sensor != null) {
BgReading bgReading = new Select()
.from(BgReading.class)
.where("Sensor = ? ", sensor.getId())
.where("timestamp <= ?", (timestamp + (60*1000))) // 1 minute padding (should never be that far off, but why not)
.where("calculated_value = 0")
.where("raw_calculated = 0")
.orderBy("timestamp desc")
.executeSingle();
if(bgReading != null && Math.abs(bgReading.timestamp - timestamp) < (3*60*1000)) { //cool, so was it actually within 4 minutes of that bg reading?
Log.w(TAG, "Found a BG timestamp match");
return bgReading;
}
}
Log.w(TAG, "No luck finding a BG timestamp match");
return null;
}
public static boolean is_new(SensorRecord sensorRecord, long addativeOffset) {
double timestamp = sensorRecord.getSystemTime().getTime() + addativeOffset;
Sensor sensor = Sensor.currentSensor();
if(sensor != null) {
BgReading bgReading = new Select()
.from(BgReading.class)
.where("Sensor = ? ", sensor.getId())
.where("timestamp <= ?", (timestamp + (60*1000))) // 1 minute padding (should never be that far off, but why not)
.orderBy("timestamp desc")
.executeSingle();
if(bgReading != null && Math.abs(bgReading.timestamp - timestamp) < (3*60*1000)) { //cool, so was it actually within 4 minutes of that bg reading?
Log.w(TAG, "Old Reading");
return false;
}
}
Log.w(TAG, "New Reading");
return true;
}
public static BgReading create(double raw_data, Context context, Long timestamp) {
BgReading bgReading = new BgReading();
Sensor sensor = Sensor.currentSensor();
if (sensor != null) {
Calibration calibration = Calibration.last();
if (calibration == null) {
bgReading.sensor = sensor;
bgReading.sensor_uuid = sensor.uuid;
bgReading.raw_data = (raw_data / 1000);
bgReading.filtered_data = (raw_data / 1000);
bgReading.timestamp = timestamp;
bgReading.uuid = UUID.randomUUID().toString();
bgReading.time_since_sensor_started = bgReading.timestamp - sensor.started_at;
bgReading.synced = false;
bgReading.calibration_flag = false;
bgReading.calculateAgeAdjustedRawValue();
bgReading.save();
bgReading.perform_calculations();
} else {
bgReading.sensor = sensor;
bgReading.sensor_uuid = sensor.uuid;
bgReading.calibration = calibration;
bgReading.calibration_uuid = calibration.uuid;
bgReading.raw_data = (raw_data/1000);
bgReading.filtered_data = (raw_data/1000);
bgReading.timestamp = timestamp;
bgReading.uuid = UUID.randomUUID().toString();
bgReading.time_since_sensor_started = bgReading.timestamp - sensor.started_at;
bgReading.synced = false;
bgReading.calculateAgeAdjustedRawValue();
if(calibration.check_in) {
double firstAdjSlope = calibration.first_slope + (calibration.first_decay * (Math.ceil(new Date().getTime() - calibration.timestamp)/(1000 * 60 * 10)));
double calSlope = (calibration.first_scale / firstAdjSlope)*1000;
double calIntercept = ((calibration.first_scale * calibration.first_intercept) / firstAdjSlope)*-1;
bgReading.calculated_value = (((calSlope * bgReading.raw_data) + calIntercept) - 5);
} else {
BgReading lastBgReading = BgReading.last();
if (lastBgReading != null && lastBgReading.calibration != null) {
if (lastBgReading.calibration_flag == true && ((lastBgReading.timestamp + (60000 * 20)) > bgReading.timestamp) && ((lastBgReading.calibration.timestamp + (60000 * 20)) > bgReading.timestamp)) {
lastBgReading.calibration.rawValueOverride(BgReading.weightedAverageRaw(lastBgReading.timestamp, bgReading.timestamp, lastBgReading.calibration.timestamp, lastBgReading.age_adjusted_raw_value, bgReading.age_adjusted_raw_value), context);
}
}
bgReading.calculated_value = ((calibration.slope * bgReading.age_adjusted_raw_value) + calibration.intercept);
}
bgReading.calculated_value = Math.min(400, Math.max(40, bgReading.calculated_value));
Log.w(TAG, "NEW VALUE CALCULATED AT: " + bgReading.calculated_value);
bgReading.save();
bgReading.perform_calculations();
Notifications.notificationSetter(context);
BgSendQueue.addToQueue(bgReading, "create", context);
}
}
Log.w("BG GSON: ",bgReading.toS());
return bgReading;
}
public static String slopeArrow() {
double slope = (float) (BgReading.activeSlope() * 60000);
return slopeArrow(slope);
}
public static String slopeArrow(double slope) {
String arrow;
if (slope <= (-3.5)) {
arrow = "\u21ca";
} else if (slope <= (-2)) {
arrow = "\u2193";
} else if (slope <= (-1)) {
arrow = "\u2198";
} else if (slope <= (1)) {
arrow = "\u2192";
} else if (slope <= (2)) {
arrow = "\u2197";
} else if (slope <= (3.5)) {
arrow = "\u2191";
} else {
arrow = "\u21c8";
}
return arrow;
}
public String slopeName() {
double slope_by_minute = calculated_value_slope * 60000;
String arrow = "NONE";
if (slope_by_minute <= (-3.5)) {
arrow = "DoubleDown";
} else if (slope_by_minute <= (-2)) {
arrow = "SingleDown";
} else if (slope_by_minute <= (-1)) {
arrow = "FortyFiveDown";
} else if (slope_by_minute <= (1)) {
arrow = "Flat";
} else if (slope_by_minute <= (2)) {
arrow = "FortyFiveUp";
} else if (slope_by_minute <= (3.5)) {
arrow = "SingleUp";
} else if (slope_by_minute <= (40)) {
arrow = "DoubleUp";
}
if(hide_slope) {
arrow = "9";
}
return arrow;
}
public double slopefromName(String slope_name) {
double slope_by_minute = 0;
if (slope_name.compareTo("DoubleDown") == 0) {
slope_by_minute = -3.5;
} else if (slope_name.compareTo("SingleDown") == 0) {
slope_by_minute = -2;
} else if (slope_name.compareTo("FortyFiveDown") == 0) {
slope_by_minute = -1;
} else if (slope_name.compareTo("Flat") == 0) {
slope_by_minute = 0;
} else if (slope_name.compareTo("FortyFiveUp") == 0) {
slope_by_minute = 2;
} else if (slope_name.compareTo("SingleUp") == 0) {
slope_by_minute = 2;
} else if (slope_name.compareTo("DoubleUp") == 0) {
slope_by_minute = 4;
} else if (slope_name.compareTo("NOT_COMPUTABLE") == 0 || slope_name.compareTo("OUT_OF_RANGE") == 0) {
slope_by_minute = 0;
}
return slope_by_minute /60000;
}
public static BgReading last() {
Sensor sensor = Sensor.currentSensor();
if (sensor != null) {
return new Select()
.from(BgReading.class)
.where("Sensor = ? ", sensor.getId())
.where("calculated_value != 0")
.where("raw_data != 0")
.orderBy("timestamp desc")
.executeSingle();
}
return null;
}
public static List latest_by_size(int number) {
Sensor sensor = Sensor.currentSensor();
return new Select()
.from(BgReading.class)
.where("Sensor = ? ", sensor.getId())
.where("raw_data != 0")
.orderBy("timestamp desc")
.limit(number)
.execute();
}
public static BgReading lastNoSenssor() {
return new Select()
.from(BgReading.class)
.where("calculated_value != 0")
.where("raw_data != 0")
.orderBy("timestamp desc")
.executeSingle();
}
public static List latest(int number) {
Sensor sensor = Sensor.currentSensor();
if (sensor == null) { return null; }
return new Select()
.from(BgReading.class)
.where("Sensor = ? ", sensor.getId())
.where("calculated_value != 0")
.where("raw_data != 0")
.orderBy("timestamp desc")
.limit(number)
.execute();
}
public static List latestUnCalculated(int number) {
Sensor sensor = Sensor.currentSensor();
if (sensor == null) { return null; }
return new Select()
.from(BgReading.class)
.where("Sensor = ? ", sensor.getId())
.where("raw_data != 0")
.orderBy("timestamp desc")
.limit(number)
.execute();
}
public static List latestForGraph(int number, double startTime) {
DecimalFormat df = new DecimalFormat("#");
df.setMaximumFractionDigits(1);
return new Select()
.from(BgReading.class)
.where("timestamp >= " + df.format(startTime))
.where("calculated_value != 0")
.where("raw_data != 0")
.orderBy("timestamp desc")
.limit(number)
.execute();
}
public static List last30Minutes() {
double timestamp = (new Date().getTime()) - (60000 * 30);
return new Select()
.from(BgReading.class)
.where("timestamp >= " + timestamp)
.where("calculated_value != 0")
.where("raw_data != 0")
.orderBy("timestamp desc")
.execute();
}
public static double estimated_bg(double timestamp) {
timestamp = timestamp + BESTOFFSET;
BgReading latest = BgReading.last();
if (latest == null) {
return 0;
} else {
return (latest.a * timestamp * timestamp) + (latest.b * timestamp) + latest.c;
}
}
public static double estimated_raw_bg(double timestamp) {
timestamp = timestamp + BESTOFFSET;
double estimate;
BgReading latest = BgReading.last();
if (latest == null) {
Log.w(TAG, "No data yet, assume perfect!");
estimate = 160;
} else {
estimate = (latest.ra * timestamp * timestamp) + (latest.rb * timestamp) + latest.rc;
}
Log.w(TAG, "ESTIMATE RAW BG" + estimate);
return estimate;
}
//*******INSTANCE METHODS***********//
public void perform_calculations() {
find_new_curve();
find_new_raw_curve();
find_slope();
}
public void find_slope() {
List last_2 = BgReading.latest(2);
if (last_2.size() == 2) {
BgReading second_latest = last_2.get(1);
double y1 = calculated_value;
double x1 = timestamp;
double y2 = second_latest.calculated_value;
double x2 = second_latest.timestamp;
if(y1 == y2) {
calculated_value_slope = 0;
} else {
calculated_value_slope = (y2 - y1)/(x2 - x1);
}
save();
} else if (last_2.size() == 1) {
calculated_value_slope = 0;
save();
} else {
Log.w(TAG, "NO BG? COULDNT FIND SLOPE!");
}
}
public void find_new_curve() {
List last_3 = BgReading.latest(3);
if (last_3.size() == 3) {
BgReading second_latest = last_3.get(1);
BgReading third_latest = last_3.get(2);
double y3 = calculated_value;
double x3 = timestamp;
double y2 = second_latest.calculated_value;
double x2 = second_latest.timestamp;
double y1 = third_latest.calculated_value;
double x1 = third_latest.timestamp;
a = y1/((x1-x2)*(x1-x3))+y2/((x2-x1)*(x2-x3))+y3/((x3-x1)*(x3-x2));
b = (-y1*(x2+x3)/((x1-x2)*(x1-x3))-y2*(x1+x3)/((x2-x1)*(x2-x3))-y3*(x1+x2)/((x3-x1)*(x3-x2)));
c = (y1*x2*x3/((x1-x2)*(x1-x3))+y2*x1*x3/((x2-x1)*(x2-x3))+y3*x1*x2/((x3-x1)*(x3-x2)));
Log.w(TAG, "BG PARABOLIC RATES: "+a+"x^2 + "+b+"x + "+c);
save();
} else if (last_3.size() == 2) {
Log.w(TAG, "Not enough data to calculate parabolic rates - assume Linear");
BgReading latest = last_3.get(0);
BgReading second_latest = last_3.get(1);
double y2 = latest.calculated_value;
double x2 = timestamp;
double y1 = second_latest.calculated_value;
double x1 = second_latest.timestamp;
if(y1 == y2) {
b = 0;
} else {
b = (y2 - y1)/(x2 - x1);
}
a = 0;
c = -1 * ((latest.b * x1) - y1);
Log.w(TAG, ""+latest.a+"x^2 + "+latest.b+"x + "+latest.c);
save();
} else {
Log.w(TAG, "Not enough data to calculate parabolic rates - assume static data");
a = 0;
b = 0;
c = calculated_value;
Log.w(TAG, ""+a+"x^2 + "+b+"x + "+c);
save();
}
}
public void calculateAgeAdjustedRawValue(){
double adjust_for = (86400000 * 1.9) - time_since_sensor_started;
if (adjust_for > 0) {
age_adjusted_raw_value = (((.45) * (adjust_for / (86400000 * 1.9))) * raw_data) + raw_data;
Log.w("RAW VALUE ADJUSTMENT: ", "FROM:" + raw_data + " TO: " + age_adjusted_raw_value);
} else {
age_adjusted_raw_value = raw_data;
}
}
public void find_new_raw_curve() {
List last_3 = BgReading.latest(3);
if (last_3.size() == 3) {
BgReading second_latest = last_3.get(1);
BgReading third_latest = last_3.get(2);
double y3 = age_adjusted_raw_value;
double x3 = timestamp;
double y2 = second_latest.age_adjusted_raw_value;
double x2 = second_latest.timestamp;
double y1 = third_latest.age_adjusted_raw_value;
double x1 = third_latest.timestamp;
ra = y1/((x1-x2)*(x1-x3))+y2/((x2-x1)*(x2-x3))+y3/((x3-x1)*(x3-x2));
rb = (-y1*(x2+x3)/((x1-x2)*(x1-x3))-y2*(x1+x3)/((x2-x1)*(x2-x3))-y3*(x1+x2)/((x3-x1)*(x3-x2)));
rc = (y1*x2*x3/((x1-x2)*(x1-x3))+y2*x1*x3/((x2-x1)*(x2-x3))+y3*x1*x2/((x3-x1)*(x3-x2)));
Log.w(TAG, "RAW PARABOLIC RATES: "+ra+"x^2 + "+rb+"x + "+rc);
save();
} else if (last_3.size() == 2) {
BgReading latest = last_3.get(0);
BgReading second_latest = last_3.get(1);
double y2 = latest.age_adjusted_raw_value;
double x2 = timestamp;
double y1 = second_latest.age_adjusted_raw_value;
double x1 = second_latest.timestamp;
if(y1 == y2) {
rb = 0;
} else {
rb = (y2 - y1)/(x2 - x1);
}
ra = 0;
rc = -1 * ((latest.rb * x1) - y1);
Log.w(TAG, "Not enough data to calculate parabolic rates - assume Linear data");
Log.w(TAG, "RAW PARABOLIC RATES: "+ra+"x^2 + "+rb+"x + "+rc);
save();
} else {
Log.w(TAG, "Not enough data to calculate parabolic rates - assume static data");
BgReading latest_entry = BgReading.lastNoSenssor();
ra = 0;
rb = 0;
rc = latest_entry.age_adjusted_raw_value;
save();
}
}
public static double weightedAverageRaw(double timeA, double timeB, double calibrationTime, double rawA, double rawB) {
double relativeSlope = (rawB - rawA)/(timeB - timeA);
double relativeIntercept = rawA - (relativeSlope * timeA);
return ((relativeSlope * calibrationTime) + relativeIntercept);
}
public String toS() {
Gson gson = new GsonBuilder()
.excludeFieldsWithoutExposeAnnotation()
.registerTypeAdapter(Date.class, new DateTypeAdapter())
.serializeSpecialFloatingPointValues()
.create();
return gson.toJson(this);
}
public String noiseValue() {
if(noise == null || noise.compareTo("") == 0) {
return "1";
} else {
return String.valueOf(noise);
}
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/Models/Calibration.java
================================================
package com.eveningoutpost.dexdrip.Models;
import android.content.Context;
import android.content.SharedPreferences;
import android.preference.PreferenceManager;
import android.provider.BaseColumns;
import android.util.Log;
import com.activeandroid.Model;
import com.activeandroid.annotation.Column;
import com.activeandroid.annotation.Table;
import com.activeandroid.query.Select;
import com.eveningoutpost.dexdrip.ImportedLibraries.dexcom.records.CalRecord;
import com.eveningoutpost.dexdrip.ImportedLibraries.dexcom.records.CalSubrecord;
import com.eveningoutpost.dexdrip.Sensor;
import com.eveningoutpost.dexdrip.UtilityModels.BgSendQueue;
import com.eveningoutpost.dexdrip.UtilityModels.CalibrationSendQueue;
import com.eveningoutpost.dexdrip.UtilityModels.Constants;
import com.eveningoutpost.dexdrip.UtilityModels.Notifications;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.annotations.Expose;
import com.google.gson.internal.bind.DateTypeAdapter;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.UUID;
/**
* Created by stephenblack on 10/29/14.
*/
@Table(name = "Calibration", id = BaseColumns._ID)
public class Calibration extends Model {
private final static String TAG = Calibration.class.getSimpleName();
@Expose
@Column(name = "timestamp", index = true)
public double timestamp;
@Expose
@Column(name = "sensor_age_at_time_of_estimation")
public double sensor_age_at_time_of_estimation;
@Column(name = "sensor", index = true)
public Sensor sensor;
@Expose
@Column(name = "bg")
public double bg;
@Expose
@Column(name = "raw_value")
public double raw_value;
//
// @Expose
// @Column(name = "filtered_value")
// public double filtered_value;
@Expose
@Column(name = "adjusted_raw_value")
public double adjusted_raw_value;
@Expose
@Column(name = "sensor_confidence")
public double sensor_confidence;
@Expose
@Column(name = "slope_confidence")
public double slope_confidence;
@Expose
@Column(name = "raw_timestamp")
public double raw_timestamp;
@Expose
@Column(name = "slope")
public double slope;
@Expose
@Column(name = "intercept")
public double intercept;
@Expose
@Column(name = "distance_from_estimate")
public double distance_from_estimate;
@Expose
@Column(name = "estimate_raw_at_time_of_calibration")
public double estimate_raw_at_time_of_calibration;
@Expose
@Column(name = "estimate_bg_at_time_of_calibration")
public double estimate_bg_at_time_of_calibration;
@Expose
@Column(name = "uuid", index = true)
public String uuid;
@Expose
@Column(name = "sensor_uuid", index = true)
public String sensor_uuid;
@Expose
@Column(name = "possible_bad")
public Boolean possible_bad;
@Expose
@Column(name = "check_in")
public boolean check_in;
@Expose
@Column(name = "first_decay")
public double first_decay;
@Expose
@Column(name = "second_decay")
public double second_decay;
@Expose
@Column(name = "first_slope")
public double first_slope;
@Expose
@Column(name = "second_slope")
public double second_slope;
@Expose
@Column(name = "first_intercept")
public double first_intercept;
@Expose
@Column(name = "second_intercept")
public double second_intercept;
@Expose
@Column(name = "first_scale")
public double first_scale;
@Expose
@Column(name = "second_scale")
public double second_scale;
public static void initialCalibration(double bg1, double bg2, Context context) {
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
String unit = prefs.getString("units", "mgdl");
if(unit.compareTo("mgdl") != 0 ) {
bg1 = bg1 * Constants.MMOLL_TO_MGDL;
bg2 = bg2 * Constants.MMOLL_TO_MGDL;
}
clear_all_existing_calibrations();
Calibration higherCalibration = new Calibration();
Calibration lowerCalibration = new Calibration();
Sensor sensor = Sensor.currentSensor();
List bgReadings = BgReading.latest_by_size(2);
BgReading bgReading1 = bgReadings.get(0);
BgReading bgReading2 = bgReadings.get(1);
BgReading highBgReading;
BgReading lowBgReading;
double higher_bg = Math.max(bg1, bg2);
double lower_bg = Math.min(bg1, bg2);
if (bgReading1.raw_data > bgReading2.raw_data) {
highBgReading = bgReading1;
lowBgReading = bgReading2;
} else {
highBgReading = bgReading2;
lowBgReading = bgReading1;
}
higherCalibration.bg = higher_bg;
higherCalibration.slope = 1;
higherCalibration.intercept = higher_bg;
higherCalibration.sensor = sensor;
higherCalibration.estimate_raw_at_time_of_calibration = highBgReading.age_adjusted_raw_value;
higherCalibration.adjusted_raw_value = highBgReading.age_adjusted_raw_value;
higherCalibration.raw_value = highBgReading.raw_data;
higherCalibration.raw_timestamp = highBgReading.timestamp;
higherCalibration.save();
highBgReading.calculated_value = higher_bg;
highBgReading.calibration_flag = true;
highBgReading.calibration = higherCalibration;
highBgReading.save();
higherCalibration.save();
lowerCalibration.bg = lower_bg;
lowerCalibration.slope = 1;
lowerCalibration.intercept = lower_bg;
lowerCalibration.sensor = sensor;
lowerCalibration.estimate_raw_at_time_of_calibration = lowBgReading.age_adjusted_raw_value;
lowerCalibration.adjusted_raw_value = lowBgReading.age_adjusted_raw_value;
lowerCalibration.raw_value = lowBgReading.raw_data;
lowerCalibration.raw_timestamp = lowBgReading.timestamp;
lowerCalibration.save();
lowBgReading.calculated_value = lower_bg;
lowBgReading.calibration_flag = true;
lowBgReading.calibration = lowerCalibration;
lowBgReading.save();
lowerCalibration.save();
highBgReading.find_new_curve();
highBgReading.find_new_raw_curve();
lowBgReading.find_new_curve();
lowBgReading.find_new_raw_curve();
List calibrations = new ArrayList();
calibrations.add(lowerCalibration);
calibrations.add(higherCalibration);
for(Calibration calibration : calibrations) {
calibration.timestamp = new Date().getTime();
calibration.sensor_uuid = sensor.uuid;
calibration.slope_confidence = .5;
calibration.distance_from_estimate = 0;
calibration.check_in = false;
calibration.sensor_confidence = ((-0.0018 * calibration.bg * calibration.bg) + (0.6657 * calibration.bg) + 36.7505) / 100;
calibration.sensor_age_at_time_of_estimation = calibration.timestamp - sensor.started_at;
calibration.uuid = UUID.randomUUID().toString();
calibration.save();
calculate_w_l_s();
CalibrationSendQueue.addToQueue(calibration, context);
}
adjustRecentBgReadings(5);
CalibrationRequest.createOffset(lowerCalibration.bg, 35);
Notifications.notificationSetter(context);
}
//Create Calibration Checkin
public static void create(CalRecord[] calRecords, long addativeOffset, Context context) { create(calRecords, context, false, addativeOffset); }
public static void create(CalRecord[] calRecords, Context context) { create(calRecords, context, false, 0); }
public static void create(CalRecord[] calRecords, Context context, boolean override, long addativeOffset) {
//TODO: Change calibration.last and other queries to order calibrations by timestamp rather than ID
Log.w("CALIBRATION-CHECK-IN: ", "Creating Calibration Record");
Sensor sensor = Sensor.currentSensor();
CalRecord firstCalRecord = calRecords[0];
CalRecord secondCalRecord = calRecords[0];
// CalRecord secondCalRecord = calRecords[calRecords.length - 1];
//TODO: Figgure out how the ratio between the two is determined
double calSlope = ((secondCalRecord.getScale() / secondCalRecord.getSlope()) + (3 * firstCalRecord.getScale() / firstCalRecord.getSlope())) * 250;
double calIntercept = (((secondCalRecord.getScale() * secondCalRecord.getIntercept()) / secondCalRecord.getSlope()) + ((3 * firstCalRecord.getScale() * firstCalRecord.getIntercept()) / firstCalRecord.getSlope())) / -4;
if (sensor != null) {
for(int i = 0; i < firstCalRecord.getCalSubrecords().length - 1; i++) {
if (((firstCalRecord.getCalSubrecords()[i] != null && Calibration.is_new(firstCalRecord.getCalSubrecords()[i], addativeOffset))) || (i == 0 && override)) {
CalSubrecord calSubrecord = firstCalRecord.getCalSubrecords()[i];
Calibration calibration = new Calibration();
calibration.bg = calSubrecord.getCalBGL();
calibration.timestamp = calSubrecord.getDateEntered().getTime() + addativeOffset;
if (calibration.timestamp > new Date().getTime()) {
Log.e(TAG, "ERROR - Calibration timestamp is from the future, wont save!");
return;
}
calibration.raw_value = calSubrecord.getCalRaw() / 1000;
calibration.slope = calSlope;
calibration.intercept = calIntercept;
calibration.sensor_confidence = ((-0.0018 * calibration.bg * calibration.bg) + (0.6657 * calibration.bg) + 36.7505) / 100;
if (calibration.sensor_confidence <= 0) {
calibration.sensor_confidence = 0;
}
calibration.slope_confidence = 0.8; //TODO: query backwards to find this value near the timestamp
calibration.estimate_raw_at_time_of_calibration = calSubrecord.getCalRaw() / 1000;
calibration.sensor = sensor;
calibration.sensor_age_at_time_of_estimation = calibration.timestamp - sensor.started_at;
calibration.uuid = UUID.randomUUID().toString();
calibration.sensor_uuid = sensor.uuid;
calibration.check_in = true;
calibration.first_decay = firstCalRecord.getDecay();
calibration.second_decay = secondCalRecord.getDecay();
calibration.first_slope = firstCalRecord.getSlope();
calibration.second_slope = secondCalRecord.getSlope();
calibration.first_scale = firstCalRecord.getScale();
calibration.second_scale = secondCalRecord.getScale();
calibration.first_intercept = firstCalRecord.getIntercept();
calibration.second_intercept = secondCalRecord.getIntercept();
calibration.save();
CalibrationSendQueue.addToQueue(calibration, context);
Calibration.requestCalibrationIfRangeTooNarrow();
}
}
if(firstCalRecord.getCalSubrecords()[0] != null && firstCalRecord.getCalSubrecords()[2] == null) {
if(Calibration.latest(2).size() == 1) {
Calibration.create(calRecords, context, true, 0);
}
}
Notifications.notificationSetter(context);
}
}
public static boolean is_new(CalSubrecord calSubrecord, long addativeOffset) {
Sensor sensor = Sensor.currentSensor();
Calibration calibration = new Select()
.from(Calibration.class)
.where("Sensor = ? ", sensor.getId())
.where("timestamp <= ?", calSubrecord.getDateEntered().getTime() + addativeOffset + (1000 * 60 * 2))
.orderBy("timestamp desc")
.executeSingle();
if(calibration != null && Math.abs(calibration.timestamp - (calSubrecord.getDateEntered().getTime() + addativeOffset)) < (4*60*1000)) {
Log.d("CAL CHECK IN ", "Already have that calibration!");
return false;
} else {
Log.d("CAL CHECK IN ", "Looks like a new calibration!");
return true;
}
}
public static Calibration getForTimestamp(double timestamp) {
Sensor sensor = Sensor.currentSensor();
return new Select()
.from(Calibration.class)
.where("Sensor = ? ", sensor.getId())
.where("slope_confidence != 0")
.where("sensor_confidence != 0")
.where("timestamp < ?", timestamp)
.orderBy("timestamp desc")
.executeSingle();
}
public static Calibration create(double bg, Context context) {
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
String unit = prefs.getString("units", "mgdl");
if(unit.compareTo("mgdl") != 0 ) {
bg = bg * Constants.MMOLL_TO_MGDL;
}
CalibrationRequest.clearAll();
Calibration calibration = new Calibration();
Sensor sensor = Sensor.currentSensor();
if (sensor != null) {
BgReading bgReading = BgReading.last();
if (bgReading != null) {
calibration.sensor = sensor;
calibration.bg = bg;
calibration.check_in = false;
calibration.timestamp = new Date().getTime();
calibration.raw_value = bgReading.raw_data;
calibration.adjusted_raw_value = bgReading.age_adjusted_raw_value;
calibration.sensor_uuid = sensor.uuid;
calibration.slope_confidence = Math.min(Math.max(((4 - Math.abs((bgReading.calculated_value_slope) * 60000))/4), 0), 1);
double estimated_raw_bg = BgReading.estimated_raw_bg(new Date().getTime());
calibration.raw_timestamp = bgReading.timestamp;
if (Math.abs(estimated_raw_bg - bgReading.age_adjusted_raw_value) > 20) {
calibration.estimate_raw_at_time_of_calibration = bgReading.age_adjusted_raw_value;
} else {
calibration.estimate_raw_at_time_of_calibration = estimated_raw_bg;
}
calibration.distance_from_estimate = Math.abs(calibration.bg - bgReading.calculated_value);
calibration.sensor_confidence = Math.max(((-0.0018 * bg * bg) + (0.6657 * bg) + 36.7505) / 100, 0);
calibration.sensor_age_at_time_of_estimation = calibration.timestamp - sensor.started_at;
calibration.uuid = UUID.randomUUID().toString();
calibration.save();
bgReading.calibration = calibration;
bgReading.calibration_flag = true;
bgReading.save();
BgSendQueue.addToQueue(bgReading, "update", context);
calculate_w_l_s();
adjustRecentBgReadings();
CalibrationSendQueue.addToQueue(calibration, context);
Notifications.notificationSetter(context);
Calibration.requestCalibrationIfRangeTooNarrow();
}
} else {
Log.w("CALIBRATION", "No sensor, cant save!");
}
return Calibration.last();
}
public static List allForSensorInLastFiveDays() {
Sensor sensor = Sensor.currentSensor();
if (sensor == null) { return null; }
return new Select()
.from(Calibration.class)
.where("Sensor = ? ", sensor.getId())
.where("slope_confidence != 0")
.where("sensor_confidence != 0")
.where("timestamp > ?", (new Date().getTime() - (60000 * 60 * 24 * 5)))
.orderBy("timestamp desc")
.execute();
}
public static void calculate_w_l_s() {
if (Sensor.isActive()) {
double l = 0;
double m = 0;
double n = 0;
double p = 0;
double q = 0;
double w;
List calibrations = allForSensorInLastFourDays(); //5 days was a bit much, dropped this to 4
if (calibrations.size() == 1) {
Calibration calibration = Calibration.last();
calibration.slope = 1;
calibration.intercept = calibration.bg - (calibration.raw_value * calibration.slope);
calibration.save();
} else {
for (Calibration calibration : calibrations) {
w = calibration.calculateWeight();
l += (w);
m += (w * calibration.estimate_raw_at_time_of_calibration);
n += (w * calibration.estimate_raw_at_time_of_calibration * calibration.estimate_raw_at_time_of_calibration);
p += (w * calibration.bg);
q += (w * calibration.estimate_raw_at_time_of_calibration * calibration.bg);
}
Calibration last_calibration = Calibration.last();
w = (last_calibration.calculateWeight() * (calibrations.size() * 0.14));
l += (w);
m += (w * last_calibration.estimate_raw_at_time_of_calibration);
n += (w * last_calibration.estimate_raw_at_time_of_calibration * last_calibration.estimate_raw_at_time_of_calibration);
p += (w * last_calibration.bg);
q += (w * last_calibration.estimate_raw_at_time_of_calibration * last_calibration.bg);
double d = (l * n) - (m * m);
Calibration calibration = Calibration.last();
calibration.intercept = ((n * p) - (m * q)) / d;
calibration.slope = ((l * q) - (m * p)) / d;
if ((calibrations.size() == 2 && calibration.slope < 0.95) || (calibration.slope < 0.85)) { // I have not seen a case where a value below 7.5 proved to be accurate but we should keep an eye on this
calibration.slope = calibration.slopeOOBHandler(0);
if(calibrations.size() > 2) { calibration.possible_bad = true; }
calibration.intercept = calibration.bg - (calibration.estimate_raw_at_time_of_calibration * calibration.slope);
CalibrationRequest.createOffset(calibration.bg, 25);
}
if ((calibrations.size() == 2 && calibration.slope > 1.3) || (calibration.slope > 1.4)) {
calibration.slope = calibration.slopeOOBHandler(1);
if(calibrations.size() > 2) { calibration.possible_bad = true; }
calibration.intercept = calibration.bg - (calibration.estimate_raw_at_time_of_calibration * calibration.slope);
CalibrationRequest.createOffset(calibration.bg, 25);
}
Log.d(TAG, "Calculated Calibration Slope: " + calibration.slope);
Log.d(TAG, "Calculated Calibration intercept: " + calibration.intercept);
calibration.save();
}
} else {
Log.w(TAG, "NO Current active sensor found!!");
}
}
private double slopeOOBHandler(int status) {
// If the last slope was reasonable and reasonably close, use that, otherwise use a slope that may be a little steep, but its best to play it safe when uncertain
List calibrations = Calibration.latest(3);
Calibration thisCalibration = calibrations.get(0);
if(status == 0) {
if (calibrations.size() == 3) {
if ((Math.abs(thisCalibration.bg - thisCalibration.estimate_bg_at_time_of_calibration) < 30) && (calibrations.get(1).possible_bad != null && calibrations.get(1).possible_bad == true)) {
return calibrations.get(1).slope;
} else {
return Math.max(((-0.048) * (thisCalibration.sensor_age_at_time_of_estimation / (60000 * 60 * 24))) + 1.1, 1.08);
}
} else if (calibrations.size() == 2) {
return Math.max(((-0.048) * (thisCalibration.sensor_age_at_time_of_estimation / (60000 * 60 * 24))) + 1.1, 1.15);
}
return 1;
} else {
if (calibrations.size() == 3) {
if ((Math.abs(thisCalibration.bg - thisCalibration.estimate_bg_at_time_of_calibration) < 30) && (calibrations.get(1).possible_bad != null && calibrations.get(1).possible_bad == true)) {
return calibrations.get(1).slope;
} else {
return 1.3;
}
} else if (calibrations.size() == 2) {
return 1.2;
}
}
return 1;
}
private static List calibrations_for_sensor(Sensor sensor) {
return new Select()
.from(Calibration.class)
.where("Sensor = ?", sensor.getId())
.where("slope_confidence != 0")
.where("sensor_confidence != 0")
.orderBy("timestamp desc")
.execute();
}
private double calculateWeight() {
double firstTimeStarted = Calibration.first().sensor_age_at_time_of_estimation;
double lastTimeStarted = Calibration.last().sensor_age_at_time_of_estimation;
double time_percentage = Math.min(((sensor_age_at_time_of_estimation - firstTimeStarted) / (lastTimeStarted - firstTimeStarted)) / (.85), 1);
time_percentage = (time_percentage + .01);
Log.w(TAG, "CALIBRATIONS TIME PERCENTAGE WEIGHT: " + time_percentage);
return Math.max((((((slope_confidence + sensor_confidence) * (time_percentage))) / 2) * 100), 1);
}
public static void adjustRecentBgReadings() {// This just adjust the last 30 bg readings transition from one calibration point to the next
adjustRecentBgReadings(30);
}
public static void adjustRecentBgReadings(int adjustCount) {
//TODO: add some handling around calibration overrides as they come out looking a bit funky
List calibrations = Calibration.latest(3);
List bgReadings = BgReading.latestUnCalculated(adjustCount);
if (calibrations.size() == 3) {
int denom = bgReadings.size();
Calibration latestCalibration = calibrations.get(0);
int i = 0;
for (BgReading bgReading : bgReadings) {
double oldYValue = bgReading.calculated_value;
double newYvalue = (bgReading.age_adjusted_raw_value * latestCalibration.slope) + latestCalibration.intercept;
bgReading.calculated_value = ((newYvalue * (denom - i)) + (oldYValue * ( i ))) / denom;
bgReading.save();
i += 1;
}
} else if (calibrations.size() == 2) {
Calibration latestCalibration = calibrations.get(0);
for (BgReading bgReading : bgReadings) {
double newYvalue = (bgReading.age_adjusted_raw_value * latestCalibration.slope) + latestCalibration.intercept;
bgReading.calculated_value = newYvalue;
bgReading.save();
}
}
bgReadings.get(0).find_new_raw_curve();
bgReadings.get(0).find_new_curve();
}
public void rawValueOverride(double rawValue, Context context) {
estimate_raw_at_time_of_calibration = rawValue;
save();
calculate_w_l_s();
CalibrationSendQueue.addToQueue(this, context);
}
public static void requestCalibrationIfRangeTooNarrow() {
double max = Calibration.max_recent();
double min = Calibration.min_recent();
if ((max - min) < 55) {
double avg = ((min + max) / 2);
double dist = max - avg;
CalibrationRequest.createOffset(avg, dist + 20);
}
}
public static void clear_all_existing_calibrations() {
CalibrationRequest.clearAll();
List pastCalibrations = Calibration.allForSensor();
if (pastCalibrations != null) {
for(Calibration calibration : pastCalibrations){
calibration.slope_confidence = 0;
calibration.sensor_confidence = 0;
calibration.save();
}
}
}
public String toS() {
Gson gson = new GsonBuilder()
.excludeFieldsWithoutExposeAnnotation()
.registerTypeAdapter(Date.class, new DateTypeAdapter())
.serializeSpecialFloatingPointValues()
.create();
return gson.toJson(this);
}
//COMMON SCOPES!
public static Calibration last() {
Sensor sensor = Sensor.currentSensor();
return new Select()
.from(Calibration.class)
.where("Sensor = ? ", sensor.getId())
.orderBy("timestamp desc")
.executeSingle();
}
public static Calibration first() {
Sensor sensor = Sensor.currentSensor();
return new Select()
.from(Calibration.class)
.where("Sensor = ? ", sensor.getId())
.where("slope_confidence != 0")
.where("sensor_confidence != 0")
.orderBy("timestamp asc")
.executeSingle();
}
public static double max_recent() {
Sensor sensor = Sensor.currentSensor();
Calibration calibration = new Select()
.from(Calibration.class)
.where("Sensor = ? ", sensor.getId())
.where("slope_confidence != 0")
.where("sensor_confidence != 0")
.where("timestamp > ?", (new Date().getTime() - (60000 * 60 * 24 * 4)))
.orderBy("bg desc")
.executeSingle();
if(calibration != null) {
return calibration.bg;
} else {
return 120;
}
}
public static double min_recent() {
Sensor sensor = Sensor.currentSensor();
Calibration calibration = new Select()
.from(Calibration.class)
.where("Sensor = ? ", sensor.getId())
.where("slope_confidence != 0")
.where("sensor_confidence != 0")
.where("timestamp > ?", (new Date().getTime() - (60000 * 60 * 24 * 4)))
.orderBy("bg asc")
.executeSingle();
if(calibration != null) {
return calibration.bg;
} else {
return 100;
}
}
public static List latest(int number) {
Sensor sensor = Sensor.currentSensor();
if (sensor == null) { return null; }
return new Select()
.from(Calibration.class)
.where("Sensor = ? ", sensor.getId())
.orderBy("timestamp desc")
.limit(number)
.execute();
}
public static List allForSensor() {
Sensor sensor = Sensor.currentSensor();
if (sensor == null) { return null; }
return new Select()
.from(Calibration.class)
.where("Sensor = ? ", sensor.getId())
.where("slope_confidence != 0")
.where("sensor_confidence != 0")
.orderBy("timestamp desc")
.execute();
}
public static List allForSensorInLastFourDays() {
Sensor sensor = Sensor.currentSensor();
if (sensor == null) { return null; }
return new Select()
.from(Calibration.class)
.where("Sensor = ? ", sensor.getId())
.where("slope_confidence != 0")
.where("sensor_confidence != 0")
.where("timestamp > ?", (new Date().getTime() - (60000 * 60 * 24 * 4)))
.orderBy("timestamp desc")
.execute();
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/Models/CalibrationRequest.java
================================================
package com.eveningoutpost.dexdrip.Models;
import android.provider.BaseColumns;
import com.activeandroid.Model;
import com.activeandroid.annotation.Column;
import com.activeandroid.annotation.Table;
import com.activeandroid.query.Select;
import java.util.List;
/**
* Created by stephenblack on 12/9/14.
*/
@Table(name = "CalibrationRequest", id = BaseColumns._ID)
public class CalibrationRequest extends Model {
private static final int max = 250;
private static final int min = 70;
@Column(name = "requestIfAbove")
public double requestIfAbove;
@Column(name = "requestIfBelow")
public double requestIfBelow;
public static void createRange(double low, double high) {
CalibrationRequest calibrationRequest = new CalibrationRequest();
calibrationRequest.requestIfAbove = low;
calibrationRequest.requestIfBelow = high;
calibrationRequest.save();
}
public static void createOffset(double center, double distance) {
CalibrationRequest calibrationRequest = new CalibrationRequest();
calibrationRequest.requestIfAbove = center + distance;
calibrationRequest.requestIfBelow = max;
calibrationRequest.save();
calibrationRequest.requestIfAbove = min;
calibrationRequest.requestIfBelow = center - distance;
calibrationRequest.save();
}
public static void clearAll(){
List calibrationRequests = new Select()
.from(CalibrationRequest.class)
.execute();
if (calibrationRequests.size() >=1) {
for (CalibrationRequest calibrationRequest : calibrationRequests) {
calibrationRequest.delete();
}
}
}
public static boolean shouldRequestCalibration(BgReading bgReading){
CalibrationRequest calibrationRequest = new Select()
.from(CalibrationRequest.class)
.where("requestIfAbove < ?", bgReading.calculated_value)
.where("requestIfBelow > ?", bgReading.calculated_value)
.executeSingle();
if (calibrationRequest != null && Math.abs(bgReading.calculated_value_slope * 60000) < 1.8) {
return true;
} else {
return false;
}
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/Models/TransmitterData.java
================================================
package com.eveningoutpost.dexdrip.Models;
import android.provider.BaseColumns;
import android.util.Log;
import com.activeandroid.Model;
import com.activeandroid.annotation.Column;
import com.activeandroid.annotation.Table;
import com.activeandroid.query.Select;
import java.util.Date;
import java.util.UUID;
/**
* Created by stephenblack on 11/6/14.
*/
@Table(name = "TransmitterData", id = BaseColumns._ID)
public class TransmitterData extends Model {
private final static String TAG = BgReading.class.getSimpleName();
@Column(name = "timestamp", index = true)
public long timestamp;
@Column(name = "raw_data")
public double raw_data;
//
// @Column(name = "filtered_data")
// public double filtered_data;
@Column(name = "sensor_battery_level")
public int sensor_battery_level;
@Column(name = "uuid", index = true)
public String uuid;
public static TransmitterData create(byte[] buffer, int len, Long timestamp) {
StringBuilder data_string = new StringBuilder();
if (len < 6) { return null; };
for (int i = 0; i < len; ++i) {
data_string.append((char) buffer[i]);
}
String[] data = data_string.toString().split("\\s+");
randomDelay(100, 2000);
TransmitterData lastTransmitterData = TransmitterData.last();
if (lastTransmitterData != null && lastTransmitterData.raw_data == Integer.parseInt(data[0]) && Math.abs(lastTransmitterData.timestamp - timestamp) < (10000)) { //Stop allowing duplicate data, its bad!
return null;
}
TransmitterData transmitterData = new TransmitterData();
if(data.length > 1) {
transmitterData.sensor_battery_level = Integer.parseInt(data[1]);
}
if (Integer.parseInt(data[0]) < 1000) { return null; } // Sometimes the HM10 sends the battery level and readings in separate transmissions, filter out these incomplete packets!
transmitterData.raw_data = Integer.parseInt(data[0]);
transmitterData.timestamp = timestamp;
transmitterData.uuid = UUID.randomUUID().toString();
transmitterData.save();
return transmitterData;
}
public static TransmitterData create(int raw_data ,int sensor_battery_level, long timestamp) {
randomDelay(100, 2000);
TransmitterData lastTransmitterData = TransmitterData.last();
if (lastTransmitterData != null && lastTransmitterData.raw_data == raw_data && Math.abs(lastTransmitterData.timestamp - new Date().getTime()) < (10000)) { //Stop allowing duplicate data, its bad!
return null;
}
TransmitterData transmitterData = new TransmitterData();
transmitterData.sensor_battery_level = sensor_battery_level;
transmitterData.raw_data = raw_data ;
transmitterData.timestamp = timestamp;
transmitterData.uuid = UUID.randomUUID().toString();
transmitterData.save();
return transmitterData;
}
public static TransmitterData last() {
return new Select()
.from(TransmitterData.class)
.orderBy("_ID desc")
.executeSingle();
}
public static void randomDelay(float min, float max){
int random = (int)(max * Math.random() + min);
try {
Log.d("Sleeping ", "for " + random + "ms");
Thread.sleep(random);
} catch (InterruptedException e) {
Log.e("Random Delay ", "INTERUPTED");
}
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/Models/User.java
================================================
package com.eveningoutpost.dexdrip.Models;
import android.provider.BaseColumns;
import android.util.Log;
import com.activeandroid.Model;
import com.activeandroid.annotation.Column;
import com.activeandroid.annotation.Table;
import com.activeandroid.query.Select;
import com.eveningoutpost.dexdrip.Interfaces.UserInterface;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonObject;
import com.google.gson.annotations.Expose;
import com.google.gson.internal.bind.DateTypeAdapter;
import java.util.Date;
import retrofit.Callback;
import retrofit.RestAdapter;
import retrofit.RetrofitError;
import retrofit.client.Response;
import retrofit.converter.GsonConverter;
/**
* Created by stephenblack on 11/7/14.
*/
@Table(name = "User", id = BaseColumns._ID)
public class User extends Model {
private static final String baseUrl = "http://10.0.2.2:3000";
public static Gson gson = new GsonBuilder()
.excludeFieldsWithoutExposeAnnotation()
.registerTypeAdapter(Date.class, new DateTypeAdapter())
.create();
@Expose
@Column(name = "email")
public String email;
@Expose
@Column(name = "password")
public String password;
@Expose
@Column(name = "token")
public String token;
@Expose
@Column(name = "token_expiration")
public double token_expiration;
@Expose
@Column(name = "uuid", index = true)
public String uuid;
public static User currentUser() {
User user = new Select()
.from(User.class)
.orderBy("_ID desc")
.limit(1)
.executeSingle();
return user;
}
//TODO: Add refresh token attempt instance method!!
public static void authenticate() {
final User user = User.currentUser();
userInterface().authenticate(user, new Callback() {
@Override
public void success(String gsonResponse, Response response) {
JsonObject jobj = new Gson().fromJson(gsonResponse, JsonObject.class);
user.token = jobj.get("token").getAsString();
user.token_expiration = jobj.get("expiration").getAsDouble();
user.save();
}
@Override
public void failure(RetrofitError error) {
Response response = error.getResponse();
Log.w("REST CALL ERROR:", "****************");
Log.w("REST CALL STATUS:", "" + response.getStatus());
Log.w("REST CALL REASON:", response.getReason());
}
}
);
}
public static UserInterface userInterface() {
RestAdapter adapter = adapterBuilder().build();
UserInterface userInterface =
adapter.create(UserInterface.class);
return userInterface();
}
public static RestAdapter.Builder adapterBuilder() {
RestAdapter.Builder adapterBuilder = new RestAdapter.Builder();
adapterBuilder
.setEndpoint(baseUrl)
.setConverter(new GsonConverter(gson));
return adapterBuilder;
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/Models/UserNotification.java
================================================
package com.eveningoutpost.dexdrip.Models;
import android.provider.BaseColumns;
import com.activeandroid.Model;
import com.activeandroid.annotation.Column;
import com.activeandroid.annotation.Table;
import com.activeandroid.query.Select;
import java.util.Date;
/**
* Created by stephenblack on 11/29/14.
*/
@Table(name = "Notifications", id = BaseColumns._ID)
public class UserNotification extends Model {
@Column(name = "timestamp", index = true)
public double timestamp;
@Column(name = "message")
public String message;
@Column(name = "bg_alert")
public boolean bg_alert;
@Column(name = "calibration_alert")
public boolean calibration_alert;
@Column(name = "double_calibration_alert")
public boolean double_calibration_alert;
@Column(name = "extra_calibration_alert")
public boolean extra_calibration_alert;
public static UserNotification lastBgAlert() {
return new Select()
.from(UserNotification.class)
.where("bg_alert = ?", true)
.orderBy("_ID desc")
.executeSingle();
}
public static UserNotification lastCalibrationAlert() {
return new Select()
.from(UserNotification.class)
.where("calibration_alert = ?", true)
.orderBy("_ID desc")
.executeSingle();
}
public static UserNotification lastDoubleCalibrationAlert() {
return new Select()
.from(UserNotification.class)
.where("double_calibration_alert = ?", true)
.orderBy("_ID desc")
.executeSingle();
}
public static UserNotification lastExtraCalibrationAlert() {
return new Select()
.from(UserNotification.class)
.where("extra_calibration_alert = ?", true)
.orderBy("_ID desc")
.executeSingle();
}
public static UserNotification create(String message, String type) {
UserNotification userNotification = new UserNotification();
userNotification.timestamp = new Date().getTime();
userNotification.message = message;
if (type == "bg_alert") {
userNotification.bg_alert = true;
} else if (type == "calibration_alert") {
userNotification.calibration_alert = true;
} else if (type == "double_calibration_alert") {
userNotification.double_calibration_alert = true;
} else if (type == "extra_calibration_alert") {
userNotification.extra_calibration_alert = true;
}
userNotification.save();
return userNotification;
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/NavDrawerBuilder.java
================================================
package com.eveningoutpost.dexdrip;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.preference.Preference;
import android.preference.PreferenceManager;
import com.eveningoutpost.dexdrip.Models.BgReading;
import com.eveningoutpost.dexdrip.Models.Calibration;
import com.eveningoutpost.dexdrip.Tables.BgReadingTable;
import com.eveningoutpost.dexdrip.Tables.CalibrationDataTable;
import com.eveningoutpost.dexdrip.UtilityModels.CollectionServiceStarter;
import com.eveningoutpost.dexdrip.utils.Preferences;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
/**
* Created by stephenblack on 11/5/14.
*/
public class NavDrawerBuilder {
public final List last_two_calibrations = Calibration.latest(2);
public final List last_two_bgReadings = BgReading.latestUnCalculated(2);
public final List bGreadings_in_last_30_mins = BgReading.last30Minutes();
public final boolean is_active_sensor = Sensor.isActive();
public final double time_now = new Date().getTime();
public List nav_drawer_intents;
public List nav_drawer_options;
public Context context;
public NavDrawerBuilder(Context aContext) {
context = aContext;
this.nav_drawer_intents = nav_drawer_intents();
this.nav_drawer_options = nav_drawer_options();
}
private final List nav_drawer_options() {
List options = new ArrayList();
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
boolean IUnderstand = prefs.getBoolean("I_understand", false);
if(IUnderstand == false) {
options.add("Settings");
return options;
}
options.add("xDrip");
if(is_active_sensor) {
options.add("Calibration Graph");
}
options.add("BG Data Table");
options.add("Calibration Data Table");
// options.add("Sensor Data Table");
if(is_active_sensor) {
if(!CollectionServiceStarter.isBTShare(context)) {
if (last_two_bgReadings.size() > 1) {
if (last_two_calibrations.size() > 1) {
if (bGreadings_in_last_30_mins.size() >= 2) {
if (time_now - last_two_calibrations.get(0).timestamp < (1000 * 60 * 60)) { //Put steps in place to discourage over calibration
options.add("Override Calibration");
} else {
options.add("Add Calibration");
}
} else {
options.add("Cannot Calibrate right now");
}
if (last_two_calibrations.get(0).slope >= 1.4 || last_two_calibrations.get(0).slope <= 0.5) {
options.add("Add Double Calibration");
}
} else {
options.add("Add Double Calibration");
}
}
}
options.add("Stop Sensor");
} else { options.add("Start Sensor"); }
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN_MR2) {
if(CollectionServiceStarter.isBTWixel(context) || CollectionServiceStarter.isBTShare(context)) {
options.add("Scan for BT");
}
}
options.add("System Status");
options.add("Settings");
// options.add("Fake Numbers");
// options.add("Add Double Calibration");
// options.add("Share Test");
return options;
}
private List nav_drawer_intents() {
List options = new ArrayList();
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
boolean IUnderstand = prefs.getBoolean("I_understand", false);
if(IUnderstand == false) {
options.add(new Intent(context, SettingsActivity.class));
return options;
}
options.add(new Intent(context, Home.class));
if(is_active_sensor) {
options.add(new Intent(context, CalibrationGraph.class));
}
options.add(new Intent(context, BgReadingTable.class));
options.add(new Intent(context, CalibrationDataTable.class));
// options.add(new Intent(context, SensorDataTable.class));
if(is_active_sensor) {
if(!CollectionServiceStarter.isBTShare(context)) {
if (last_two_bgReadings.size() > 1) {
if (last_two_calibrations.size() > 1) {
if (bGreadings_in_last_30_mins.size() >= 2) {
if (time_now - last_two_calibrations.get(0).timestamp < (1000 * 60 * 60)) { //Put steps in place to discourage over calibration
options.add(new Intent(context, CalibrationOverride.class));
} else {
options.add(new Intent(context, AddCalibration.class));
}
} else {
options.add(new Intent(context, Home.class));
}
if (last_two_calibrations.get(0).slope >= 1.4 || last_two_calibrations.get(0).slope <= 0.5) {
options.add(new Intent(context, DoubleCalibrationActivity.class));
}
} else {
options.add(new Intent(context, DoubleCalibrationActivity.class));
}
}
}
options.add(new Intent(context, StopSensor.class));
} else { options.add(new Intent(context, StartNewSensor.class)); }
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN_MR2) {
if(CollectionServiceStarter.isBTWixel(context) || CollectionServiceStarter.isBTShare(context)) {
options.add(new Intent(context, BluetoothScan.class));
}
}
options.add(new Intent(context, SystemStatus.class));
// options.add(new Intent(context, SettingsActivity.class));
options.add(new Intent(context, Preferences.class));
// options.add(new Intent(context, FakeNumbers.class));
// options.add(new Intent(context, DoubleCalibrationActivity.class));
// options.add(new Intent(context, ShareTest.class));
return options;
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/NavigationDrawerFragment.java
================================================
package com.eveningoutpost.dexdrip;
import android.app.ActionBar;
import android.app.Activity;
import android.app.Fragment;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.res.Configuration;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.support.v4.app.ActionBarDrawerToggle;
import android.support.v4.view.GravityCompat;
import android.support.v4.widget.DrawerLayout;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.ListView;
import java.util.List;
public class NavigationDrawerFragment extends Fragment {
private static final String STATE_SELECTED_POSITION = "selected_navigation_drawer_position";
private static final String PREF_USER_LEARNED_DRAWER = "navigation_drawer_learned";
private NavigationDrawerCallbacks mCallbacks;
private ActionBarDrawerToggle mDrawerToggle;
private DrawerLayout mDrawerLayout;
private ListView mDrawerListView;
private View mFragmentContainerView;
private int mCurrentSelectedPosition = 0;
private boolean mFromSavedInstanceState;
private boolean mUserLearnedDrawer;
private String menu_name;
public NavDrawerBuilder navDrawerBuilder;
private int menu_position;
private List menu_option_list;
private List intent_list;
public NavigationDrawerFragment() {
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(getActivity());
sp.edit().putBoolean(PREF_USER_LEARNED_DRAWER, true).apply();
mUserLearnedDrawer = sp.getBoolean(PREF_USER_LEARNED_DRAWER, false);
if (savedInstanceState != null) {
mCurrentSelectedPosition = 0;
mFromSavedInstanceState = true;
}
}
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
setHasOptionsMenu(true);
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
mDrawerListView = (ListView) inflater.inflate(
R.layout.fragment_navigation_drawer, container, false);
mDrawerListView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
@Override
public void onItemClick(AdapterView parent, View view, int position, long id) {
selectItem(position);
}
});
navDrawerBuilder = new NavDrawerBuilder(getActivity());
List menu_option_list = navDrawerBuilder.nav_drawer_options;
String[] menu_options = menu_option_list.toArray(new String[menu_option_list.size()]);
mDrawerListView.setAdapter(new ArrayAdapter(
getActionBar().getThemedContext(),
android.R.layout.simple_list_item_activated_1,
android.R.id.text1,
menu_options
));
return mDrawerListView;
}
public boolean isDrawerOpen() {
return mDrawerLayout != null && mDrawerLayout.isDrawerOpen(mFragmentContainerView);
}
public void setUp(int fragmentId, DrawerLayout drawerLayout, String current_activity, Context context) {
navDrawerBuilder = new NavDrawerBuilder(context);
menu_name = current_activity;
menu_option_list = navDrawerBuilder.nav_drawer_options;
String[] menu_options = menu_option_list.toArray(new String[menu_option_list.size()]);
menu_position = menu_option_list.indexOf(menu_name);
intent_list = navDrawerBuilder.nav_drawer_intents;
mFragmentContainerView = getActivity().findViewById(fragmentId);
mDrawerLayout = drawerLayout;
mCurrentSelectedPosition = menu_position;
mDrawerListView.setItemChecked(mCurrentSelectedPosition, true);
mDrawerLayout.setDrawerShadow(R.drawable.drawer_shadow, GravityCompat.START);
ActionBar actionBar = getActionBar();
actionBar.setDisplayHomeAsUpEnabled(true);
actionBar.setHomeButtonEnabled(true);
// mDrawerListView = (ListView) inflater.inflate(
// R.layout.fragment_navigation_drawer, container, false);
// mDrawerListView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
// @Override
// public void onItemClick(AdapterView parent, View view, int position, long id) {
// selectItem(position);
// }
// });
// navDrawerBuilder = new NavDrawerBuilder();
// List menu_option_list = navDrawerBuilder.nav_drawer_options();
// String[] menu_options = menu_option_list.toArray(new String[menu_option_list.size()]);
mDrawerListView.setAdapter(new ArrayAdapter(
getActionBar().getThemedContext(),
android.R.layout.simple_list_item_activated_1,
android.R.id.text1,
menu_options
));
mDrawerToggle = new ActionBarDrawerToggle(
getActivity(),
mDrawerLayout,
R.drawable.ic_drawer,
R.string.navigation_drawer_open,
R.string.navigation_drawer_close
) {
@Override
public void onDrawerClosed(View drawerView) {
super.onDrawerClosed(drawerView);
if (!isAdded()) {
return;
}
getActivity().invalidateOptionsMenu();
}
@Override
public void onDrawerOpened(View drawerView) {
super.onDrawerOpened(drawerView);
if (!isAdded()) {
return;
}
if (!mUserLearnedDrawer) {
mUserLearnedDrawer = true;
SharedPreferences sp = PreferenceManager
.getDefaultSharedPreferences(getActivity());
sp.edit().putBoolean(PREF_USER_LEARNED_DRAWER, true).apply();
}
getActivity().invalidateOptionsMenu(); // calls onPrepareOptionsMenu()
}
};
if (!mUserLearnedDrawer && !mFromSavedInstanceState) {
mDrawerLayout.openDrawer(mFragmentContainerView);
}
mDrawerLayout.post(new Runnable() {
@Override
public void run() {
mDrawerToggle.syncState();
}
});
mDrawerLayout.setDrawerListener(mDrawerToggle);
}
private void selectItem(int position) {
mCurrentSelectedPosition = position;
if (mDrawerListView != null) {
mDrawerListView.setItemChecked(position, true);
}
if (mDrawerLayout != null) {
mDrawerLayout.closeDrawer(mFragmentContainerView);
}
if (mCallbacks != null) {
mCallbacks.onNavigationDrawerItemSelected(position);
}
}
@Override
public void onAttach(Activity activity) {
super.onAttach(activity);
try {
mCallbacks = (NavigationDrawerCallbacks) activity;
} catch (ClassCastException e) {
throw new ClassCastException("Activity must implement NavigationDrawerCallbacks.");
}
}
@Override
public void onDetach() {
super.onDetach();
mCallbacks = null;
}
@Override
public void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
outState.putInt(STATE_SELECTED_POSITION, mCurrentSelectedPosition);
}
@Override
public void onConfigurationChanged(Configuration newConfig) {
super.onConfigurationChanged(newConfig);
mDrawerToggle.onConfigurationChanged(newConfig);
}
@Override
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
if (mDrawerLayout != null && isDrawerOpen()) {
inflater.inflate(R.menu.global, menu);
showGlobalContextActionBar();
}
super.onCreateOptionsMenu(menu, inflater);
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
if (mDrawerToggle.onOptionsItemSelected(item)) {
return true;
}
return super.onOptionsItemSelected(item);
}
private void showGlobalContextActionBar() {
ActionBar actionBar = getActionBar();
actionBar.setDisplayShowTitleEnabled(true);
actionBar.setNavigationMode(ActionBar.NAVIGATION_MODE_STANDARD);
actionBar.setTitle(R.string.app_name);
}
private ActionBar getActionBar() {
return getActivity().getActionBar();
}
public static interface NavigationDrawerCallbacks {
void onNavigationDrawerItemSelected(int position);
}
public void swapContext(int position) {
if (position != menu_position) {
Intent[] intent_array = intent_list.toArray(new Intent[intent_list.size()]);
startActivity(intent_array[position]);
if(menu_position != 0) {
getActivity().finish();
}
}
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/Sensor.java
================================================
package com.eveningoutpost.dexdrip;
import android.provider.BaseColumns;
import android.util.Log;
import com.activeandroid.Model;
import com.activeandroid.annotation.Column;
import com.activeandroid.annotation.Table;
import com.activeandroid.query.Select;
import com.eveningoutpost.dexdrip.UtilityModels.SensorSendQueue;
import java.util.UUID;
/**
* Created by stephenblack on 10/29/14.
*/
@Table(name = "Sensors", id = BaseColumns._ID)
public class Sensor extends Model {
// @Expose
@Column(name = "started_at", index = true)
public double started_at;
// @Expose
@Column(name = "stopped_at")
public double stopped_at;
// @Expose
@Column(name = "latest_battery_level")
public int latest_battery_level;
// @Expose
@Column(name = "uuid", index = true)
public String uuid;
public static Sensor create(double started_at) {
Sensor sensor = new Sensor();
sensor.started_at = started_at;
sensor.uuid = UUID.randomUUID().toString();
sensor.save();
SensorSendQueue.addToQueue(sensor);
Log.w("SENSOR MODEL:", sensor.toString());
return sensor;
}
public static Sensor currentSensor() {
Sensor sensor = new Select()
.from(Sensor.class)
.where("started_at != 0")
.where("stopped_at = 0")
.orderBy("_ID desc")
.limit(1)
.executeSingle();
return sensor;
}
public static boolean isActive() {
Sensor sensor = new Select()
.from(Sensor.class)
.where("started_at != 0")
.where("stopped_at = 0")
.orderBy("_ID desc")
.limit(1)
.executeSingle();
if(sensor == null) {
return false;
} else {
return true;
}
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/Services/ComunicationHeader.java
================================================
package com.eveningoutpost.dexdrip.Services;
import java.io.Serializable;
import com.google.gson.annotations.Expose;
// This is a struct that is supsoed to tell the protocol version and is the first that the client is sending
// The complete protocol is:
// 1) the client connects
// 2) send this message.
// 3) the server will send numberOfRecords of type ???? that it has.
public class ComunicationHeader {
/**
*
*/
int version;
int numberOfRecords;
// String message;
// byte reserved[];
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/Services/DexCollectionService.java
================================================
/*
* Copyright (C) 2013 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.eveningoutpost.dexdrip.Services;
import android.annotation.TargetApi;
import android.app.AlarmManager;
import android.app.PendingIntent;
import android.app.Service;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothGatt;
import android.bluetooth.BluetoothGattCallback;
import android.bluetooth.BluetoothGattCharacteristic;
import android.bluetooth.BluetoothGattDescriptor;
import android.bluetooth.BluetoothGattService;
import android.bluetooth.BluetoothManager;
import android.bluetooth.BluetoothProfile;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.os.Binder;
import android.os.Build;
import android.os.IBinder;
import android.os.PowerManager;
import android.preference.PreferenceManager;
import android.util.Log;
import com.activeandroid.query.Select;
import com.eveningoutpost.dexdrip.Models.ActiveBluetoothDevice;
import com.eveningoutpost.dexdrip.Models.BgReading;
import com.eveningoutpost.dexdrip.Sensor;
import com.eveningoutpost.dexdrip.UtilityModels.CollectionServiceStarter;
import com.eveningoutpost.dexdrip.UtilityModels.ForegroundServiceStarter;
import com.eveningoutpost.dexdrip.UtilityModels.HM10Attributes;
import com.eveningoutpost.dexdrip.Models.TransmitterData;
import java.util.Calendar;
import java.util.Date;
import java.util.UUID;
@TargetApi(Build.VERSION_CODES.KITKAT)
public class DexCollectionService extends Service {
private final static String TAG = DexCollectionService.class.getSimpleName();
private String mDeviceName;
private String mDeviceAddress;
private boolean is_connected = false;
SharedPreferences prefs;
public DexCollectionService dexCollectionService;
private BluetoothManager mBluetoothManager;
private BluetoothAdapter mBluetoothAdapter;
private String mBluetoothDeviceAddress;
private BluetoothGatt mBluetoothGatt;
private ForegroundServiceStarter foregroundServiceStarter;
private int mConnectionState = STATE_DISCONNECTED;
private BluetoothDevice device;
private Context mContext = null;
private static final int STATE_DISCONNECTED = BluetoothProfile.STATE_DISCONNECTED;
private static final int STATE_DISCONNECTING = BluetoothProfile.STATE_DISCONNECTING;
private static final int STATE_CONNECTING = BluetoothProfile.STATE_CONNECTING;
private static final int STATE_CONNECTED = BluetoothProfile.STATE_CONNECTED;
public final static String ACTION_DATA_AVAILABLE = "com.example.bluetooth.le.ACTION_DATA_AVAILABLE";
public final static UUID xDripDataService = UUID.fromString(HM10Attributes.HM_10_SERVICE);
public final static UUID xDripDataCharacteristic = UUID.fromString(HM10Attributes.HM_RX_TX);
@Override
public IBinder onBind(Intent intent) {
throw new UnsupportedOperationException("Not yet implemented");
}
@Override
public void onCreate() {
foregroundServiceStarter = new ForegroundServiceStarter(getApplicationContext(), this);
foregroundServiceStarter.start();
mContext = getApplicationContext();
dexCollectionService = this;
prefs = PreferenceManager.getDefaultSharedPreferences(getApplicationContext());
listenForChangeInSettings();
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
if (android.os.Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT){
stopSelf();
return START_NOT_STICKY;
}
if (CollectionServiceStarter.isBTWixel(getApplicationContext())) {
setFailoverTimer();
} else {
stopSelf();
return START_NOT_STICKY;
}
attemptConnection();
return START_STICKY;
}
@Override
public void onDestroy() {
super.onDestroy();
close();
foregroundServiceStarter.stop();
setRetryTimer();
Log.w(TAG, "SERVICE STOPPED");
}
public SharedPreferences.OnSharedPreferenceChangeListener prefListener = new SharedPreferences.OnSharedPreferenceChangeListener() {
public void onSharedPreferenceChanged(SharedPreferences prefs, String key) {
if(key.compareTo("run_service_in_foreground") == 0) {
Log.e("FOREGROUND", "run_service_in_foreground changed!");
if (prefs.getBoolean("run_service_in_foreground", false)) {
foregroundServiceStarter = new ForegroundServiceStarter(getApplicationContext(), dexCollectionService);
foregroundServiceStarter.start();
Log.w(TAG, "Moving to foreground");
} else {
dexCollectionService.stopForeground(true);
Log.w(TAG, "Removing from foreground");
}
}
}
};
public void listenForChangeInSettings() {
prefs.registerOnSharedPreferenceChangeListener(prefListener);
}
public void setRetryTimer() {
if (CollectionServiceStarter.isBTWixel(getApplicationContext())) {
long retry_in = (1000 * 60 * 2);
Log.d(TAG, "Restarting in: " + (retry_in / (60 * 1000)) + " minutes");
Calendar calendar = Calendar.getInstance();
AlarmManager alarm = (AlarmManager) getSystemService(ALARM_SERVICE);
alarm.setExact(alarm.RTC_WAKEUP, calendar.getTimeInMillis() + retry_in, PendingIntent.getService(this, 0, new Intent(this, DexCollectionService.class), 0));
}
}
public void setFailoverTimer() { //Sometimes it gets stuck in limbo on 4.4, this should make it try again
if (CollectionServiceStarter.isBTWixel(getApplicationContext())) {
long retry_in = (1000 * 60 * 5);
Log.d(TAG, "Fallover Restarting in: " + (retry_in / (60 * 1000)) + " minutes");
Calendar calendar = Calendar.getInstance();
AlarmManager alarm = (AlarmManager) getSystemService(ALARM_SERVICE);
alarm.set(alarm.RTC_WAKEUP, calendar.getTimeInMillis() + retry_in, PendingIntent.getService(this, 0, new Intent(this, DexCollectionService.class), 0));
} else {
stopSelf();
}
}
public void attemptConnection() {
mBluetoothManager = (BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);
if (mBluetoothManager != null) {
mBluetoothAdapter = mBluetoothManager.getAdapter();
if (mBluetoothAdapter != null) {
if (device != null) {
mConnectionState = STATE_DISCONNECTED;
for (BluetoothDevice bluetoothDevice : mBluetoothManager.getConnectedDevices(BluetoothProfile.GATT)) {
if (bluetoothDevice.getAddress().compareTo(device.getAddress()) == 0) {
mConnectionState = STATE_CONNECTED;
}
}
}
Log.w(TAG, "Connection state: " + mConnectionState);
if (mConnectionState == STATE_DISCONNECTED || mConnectionState == STATE_DISCONNECTING) {
ActiveBluetoothDevice btDevice = ActiveBluetoothDevice.first();
if (btDevice != null) {
mDeviceName = btDevice.name;
mDeviceAddress = btDevice.address;
if (mBluetoothAdapter.isEnabled() && mBluetoothAdapter.getRemoteDevice(mDeviceAddress) != null) {
connect(mDeviceAddress);
return;
}
}
} else if (mConnectionState == STATE_CONNECTED) { //WOOO, we are good to go, nothing to do here!
Log.w(TAG, "Looks like we are already connected, going to read!");
return;
}
}
}
setRetryTimer();
}
private final BluetoothGattCallback mGattCallback = new BluetoothGattCallback() {
@Override
public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
if (newState == BluetoothProfile.STATE_CONNECTED) {
mConnectionState = STATE_CONNECTED;
ActiveBluetoothDevice.connected();
Log.w(TAG, "Connected to GATT server.");
mBluetoothGatt.discoverServices();
} else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
mConnectionState = STATE_DISCONNECTED;
ActiveBluetoothDevice.disconnected();
Log.w(TAG, "Disconnected from GATT server.");
setRetryTimer();
}
}
@Override
public void onServicesDiscovered(BluetoothGatt gatt, int status) {
if (status == BluetoothGatt.GATT_SUCCESS) {
BluetoothGattService gattService = mBluetoothGatt.getService(xDripDataService);
if (gattService != null) {
BluetoothGattCharacteristic gattCharacteristic = gattService.getCharacteristic(xDripDataCharacteristic);
if (gattCharacteristic != null ) {
final int charaProp = gattCharacteristic.getProperties();
if ((charaProp | BluetoothGattCharacteristic.PROPERTY_NOTIFY) > 0) {
mBluetoothGatt.setCharacteristicNotification(gattCharacteristic, true);
} else {
Log.e(TAG, "characteristic " + gattCharacteristic.getUuid() + " doesn't have notify properties");
}
} else {
Log.e(TAG, "characteristic " + xDripDataCharacteristic + " not found");
}
} else {
Log.e(TAG, "service " + xDripDataCharacteristic + " not found");
}
}
}
@Override
public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
final byte[] data = characteristic.getValue();
if (data != null && data.length > 0) { setSerialDataToTransmitterRawData(data, data.length); }
}
};
public boolean connect(final String address) {
Log.w(TAG, "going to connect to device at address" + address);
if (mBluetoothAdapter == null || address == null) {
Log.w(TAG, "BluetoothAdapter not initialized or unspecified address.");
setRetryTimer();
return false;
}
if (mBluetoothGatt != null) {
Log.w(TAG, "BGatt isnt null, Closing.");
mBluetoothGatt.close();
mBluetoothGatt = null;
}
device = mBluetoothAdapter.getRemoteDevice(address);
if (device == null) {
Log.w(TAG, "Device not found. Unable to connect.");
setRetryTimer();
return false;
}
Log.w(TAG, "Trying to create a new connection.");
mBluetoothGatt = device.connectGatt(getApplicationContext(), true, mGattCallback);
mConnectionState = STATE_CONNECTING;
return true;
}
public void disconnect() {
if ( mBluetoothGatt == null) { return; }
mBluetoothGatt.disconnect();
Log.d(TAG, "Gatt Disconnect");
}
public void close() {
if (mBluetoothGatt == null) {
return;
}
mBluetoothGatt.close();
setRetryTimer();
mBluetoothGatt = null;
mConnectionState = STATE_DISCONNECTED;
}
public void setSerialDataToTransmitterRawData(byte[] buffer, int len) {
Log.w(TAG, "received some data!");
PowerManager powerManager = (PowerManager) getSystemService(POWER_SERVICE);
PowerManager.WakeLock wakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
"ReceivedReading");
wakeLock.acquire();
Long timestamp = new Date().getTime();
TransmitterData transmitterData = TransmitterData.create(buffer, len, timestamp);
if (transmitterData != null) {
Sensor sensor = Sensor.currentSensor();
if (sensor != null) {
sensor.latest_battery_level = transmitterData.sensor_battery_level;
sensor.save();
BgReading.create(transmitterData.raw_data, this, timestamp);
} else {
Log.w(TAG, "No Active Sensor, Data only stored in Transmitter Data");
}
}
wakeLock.release();
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/Services/DexShareCollectionService.java
================================================
package com.eveningoutpost.dexdrip.Services;
import android.annotation.TargetApi;
import android.app.AlarmManager;
import android.app.PendingIntent;
import android.app.Service;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothGatt;
import android.bluetooth.BluetoothGattCallback;
import android.bluetooth.BluetoothGattCharacteristic;
import android.bluetooth.BluetoothGattDescriptor;
import android.bluetooth.BluetoothGattService;
import android.bluetooth.BluetoothManager;
import android.bluetooth.BluetoothProfile;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.SharedPreferences;
import android.os.Build;
import android.os.Bundle;
import android.os.IBinder;
import android.preference.PreferenceManager;
import android.util.Log;
import android.widget.Toast;
import com.activeandroid.query.Select;
import com.eveningoutpost.dexdrip.ImportedLibraries.dexcom.ReadDataShare;
import com.eveningoutpost.dexdrip.ImportedLibraries.dexcom.records.CalRecord;
import com.eveningoutpost.dexdrip.ImportedLibraries.dexcom.records.EGVRecord;
import com.eveningoutpost.dexdrip.ImportedLibraries.dexcom.records.SensorRecord;
import com.eveningoutpost.dexdrip.Models.ActiveBluetoothDevice;
import com.eveningoutpost.dexdrip.Models.BgReading;
import com.eveningoutpost.dexdrip.Models.Calibration;
import com.eveningoutpost.dexdrip.Sensor;
import com.eveningoutpost.dexdrip.UtilityModels.CollectionServiceStarter;
import com.eveningoutpost.dexdrip.UtilityModels.DexShareAttributes;
import com.eveningoutpost.dexdrip.UtilityModels.ForegroundServiceStarter;
import com.eveningoutpost.dexdrip.UtilityModels.HM10Attributes;
import java.lang.reflect.Method;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.UUID;
import java.util.logging.Logger;
import rx.Observable;
import rx.functions.Action1;
@TargetApi(Build.VERSION_CODES.KITKAT)
public class DexShareCollectionService extends Service {
private final static String TAG = DexShareCollectionService.class.getSimpleName();
private ForegroundServiceStarter foregroundServiceStarter;
private String mDeviceAddress;
private String mDeviceName;
private boolean is_connected = false;
private boolean reconnecting = false;
private BluetoothManager mBluetoothManager;
private BluetoothAdapter mBluetoothAdapter;
private BluetoothGatt mBluetoothGatt;
private String mBluetoothDeviceAddress;
private int mConnectionState = STATE_DISCONNECTED;
private BluetoothDevice device;
private static final int STATE_DISCONNECTED = BluetoothProfile.STATE_DISCONNECTED;
private static final int STATE_DISCONNECTING = BluetoothProfile.STATE_DISCONNECTING;
private static final int STATE_CONNECTING = BluetoothProfile.STATE_CONNECTING;
private static final int STATE_CONNECTED = BluetoothProfile.STATE_CONNECTED;
private BluetoothGattService mShareService;
private BluetoothGattCharacteristic mAuthenticationCharacteristic;
private BluetoothGattCharacteristic mSendDataCharacteristic;
private BluetoothGattCharacteristic mReceiveDataCharacteristic;
private BluetoothGattCharacteristic mCommandCharacteristic;
private BluetoothGattCharacteristic mResponseCharacteristic;
private BluetoothGattCharacteristic mHeartBeatCharacteristic;
//Gatt Tasks
public final int GATT_NOTHING = 0;
public final int GATT_SETUP = 1;
public final int GATT_WRITING_COMMANDS = 2;
public final int GATT_READING_RESPONSE = 3;
public int successfulWrites;
//RXJAVA FUN
Action1 mDataResponseListener;
public int currentGattTask;
public int step;
public List writePackets;
public int recordType;
SharedPreferences prefs;
ReadDataShare readData;
public boolean state_authSucess = false;
public boolean state_authInProgress = false;
public boolean state_notifSetupSucess = false;
public boolean shouldDisconnect = false;
public boolean share2 = false;
public Service service;
@Override
public void onCreate() {
super.onCreate();
readData = new ReadDataShare(this);
service = this;
foregroundServiceStarter = new ForegroundServiceStarter(getApplicationContext(), service);
foregroundServiceStarter.start();
final IntentFilter bondintent = new IntentFilter(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
registerReceiver(mPairReceiver, bondintent);
prefs = PreferenceManager.getDefaultSharedPreferences(getApplicationContext());
listenForChangeInSettings();
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
if (android.os.Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT){
stopSelf();
return START_NOT_STICKY;
}
if (CollectionServiceStarter.isBTShare(getApplicationContext())) {
setFailoverTimer();
} else {
stopSelf();
return START_NOT_STICKY;
}
if (Sensor.currentSensor() == null) {
setRetryTimer();
return START_NOT_STICKY;
}
Log.w(TAG, "STARTING SERVICE");
attemptConnection();
return START_STICKY;
}
@Override
public void onDestroy() {
super.onDestroy();
close();
setRetryTimer();
foregroundServiceStarter.stop();
unregisterReceiver(mPairReceiver);
Log.w(TAG, "SERVICE STOPPED");
}
public SharedPreferences.OnSharedPreferenceChangeListener prefListener = new SharedPreferences.OnSharedPreferenceChangeListener() {
public void onSharedPreferenceChanged(SharedPreferences prefs, String key) {
if(key.compareTo("run_service_in_foreground") == 0) {
Log.e("FOREGROUND", "run_service_in_foreground changed!");
if (prefs.getBoolean("run_service_in_foreground", false)) {
foregroundServiceStarter = new ForegroundServiceStarter(getApplicationContext(), service);
foregroundServiceStarter.start();
Log.w(TAG, "Moving to foreground");
} else {
service.stopForeground(true);
Log.w(TAG, "Removing from foreground");
}
}
}
};
public void listenForChangeInSettings() {
prefs.registerOnSharedPreferenceChangeListener(prefListener);
}
public void setRetryTimer() {
if (CollectionServiceStarter.isBTShare(getApplicationContext())) {
BgReading bgReading = BgReading.last();
long retry_in;
if (bgReading != null) {
retry_in = Math.min(Math.max((1000 * 30), (1000 * 60 * 5) - (new Date().getTime() - bgReading.timestamp) - (1000 * 15)), (1000 * 60 * 5));
} else {
retry_in = (1000 * 20);
}
Log.d(TAG, "Restarting in: " + (retry_in / (60 * 1000)) + " minutes");
Calendar calendar = Calendar.getInstance();
AlarmManager alarm = (AlarmManager) getSystemService(ALARM_SERVICE);
alarm.setExact(alarm.RTC_WAKEUP, calendar.getTimeInMillis() + retry_in, PendingIntent.getService(this, 0, new Intent(this, DexShareCollectionService.class), 0));
}
}
public void setFailoverTimer() { //Sometimes it gets stuck in limbo on 4.4, this should make it try again
if (CollectionServiceStarter.isBTShare(getApplicationContext())) {
long retry_in = (1000 * 60 * 5);
Log.d(TAG, "Fallover Restarting in: " + (retry_in / (60 * 1000)) + " minutes");
Calendar calendar = Calendar.getInstance();
AlarmManager alarm = (AlarmManager) getSystemService(ALARM_SERVICE);
alarm.set(alarm.RTC_WAKEUP, calendar.getTimeInMillis() + retry_in, PendingIntent.getService(this, 0, new Intent(this, DexShareCollectionService.class), 0));
} else {
stopSelf();
}
}
@Override
public IBinder onBind(Intent intent) {
throw new UnsupportedOperationException("Not yet implemented");
}
public void attemptConnection() {
mBluetoothManager = (BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);
if (mBluetoothManager != null) {
if (device != null) {
mConnectionState = STATE_DISCONNECTED;
for (BluetoothDevice bluetoothDevice : mBluetoothManager.getConnectedDevices(BluetoothProfile.GATT)) {
if (bluetoothDevice.getAddress().compareTo(device.getAddress()) == 0) {
mConnectionState = STATE_CONNECTED;
}
}
}
Log.w(TAG, "Connection state: " + mConnectionState);
if (mConnectionState == STATE_DISCONNECTED || mConnectionState == STATE_DISCONNECTING) {
ActiveBluetoothDevice btDevice = ActiveBluetoothDevice.first();
if (btDevice != null) {
mDeviceName = btDevice.name;
mDeviceAddress = btDevice.address;
mBluetoothAdapter = mBluetoothManager.getAdapter();
if (mBluetoothAdapter.isEnabled() && mBluetoothAdapter.getRemoteDevice(mDeviceAddress) != null) {
connect(mDeviceAddress);
return;
} else {
Log.w(TAG, "Bluetooth is disabled or BT device cant be found");
setRetryTimer();
return;
}
} else {
Log.w(TAG, "No bluetooth device to try and connect to");
setRetryTimer();
return;
}
} else if (mConnectionState == STATE_CONNECTED) {
Log.w(TAG, "Looks like we are already connected, going to read!");
attemptRead();
return;
} else {
setRetryTimer();
return;
}
} else {
setRetryTimer();
return;
}
}
public void attemptRead() {
Log.d(TAG, "Attempting to read data");
final Action1 systemTimeListener = new Action1() {
@Override
public void call(Long s) {
if (s != null) {
Log.d(TAG, "Made the full round trip, got " + s + " as the system time");
final long addativeSystemTimeOffset = new Date().getTime() - s;
final Action1 dislpayTimeListener = new Action1() {
@Override
public void call(Long s) {
if (s != null) {
Log.d(TAG, "Made the full round trip, got " + s + " as the display time offset");
final long addativeDisplayTimeOffset = addativeSystemTimeOffset - (s*1000);
Log.d(TAG, "Making " + addativeDisplayTimeOffset + " the the total time offset");
final Action1 evgRecordListener = new Action1() {
@Override
public void call(EGVRecord[] egvRecords) {
if (egvRecords != null) {
Log.d(TAG, "Made the full round trip, got " + egvRecords.length + " EVG Records");
BgReading.create(egvRecords, addativeSystemTimeOffset, getApplicationContext());
if (shouldDisconnect) {
stopSelf();
} else {
setRetryTimer();
}
}
}
};
final Action1 sensorRecordListener = new Action1() {
@Override
public void call(SensorRecord[] sensorRecords) {
if (sensorRecords != null) {
Log.d(TAG, "Made the full round trip, got " + sensorRecords.length + " Sensor Records");
BgReading.create(sensorRecords, addativeSystemTimeOffset, getApplicationContext());
readData.getRecentEGVs(evgRecordListener);
}
}
};
final Action1 calRecordListener = new Action1() {
@Override
public void call(CalRecord[] calRecords) {
if (calRecords != null) {
Log.d(TAG, "Made the full round trip, got " + calRecords.length + " Cal Records");
Calibration.create(calRecords, addativeDisplayTimeOffset, getApplicationContext());
readData.getRecentSensorRecords(sensorRecordListener);
}
}
};
readData.getRecentCalRecords(calRecordListener);
}
}
};
readData.readDisplayTimeOffset(dislpayTimeListener);
}
}
};
readData.readSystemTime(systemTimeListener);
}
public boolean connect(final String address) {
Log.w(TAG, "going to connect to device at address" + address);
if (mBluetoothAdapter == null || address == null) {
Log.w(TAG, "BluetoothAdapter not initialized or unspecified address.");
setRetryTimer();
return false;
}
if (mBluetoothGatt != null) {
Log.w(TAG, "BGatt isnt null, Closing.");
mBluetoothGatt.close();
mBluetoothGatt = null;
}
for (BluetoothDevice bluetoothDevice : mBluetoothAdapter.getBondedDevices()) {
if (bluetoothDevice.getAddress().compareTo(address) == 0) {
Log.v(TAG, "Device found, already bonded, going to connect");
if(mBluetoothAdapter.getRemoteDevice(bluetoothDevice.getAddress()) != null) {
device = bluetoothDevice;
mBluetoothGatt = device.connectGatt(getApplicationContext(), false, mGattCallback);
return true;
}
}
}
device = mBluetoothAdapter.getRemoteDevice(address);
if (device == null) {
Log.w(TAG, "Device not found. Unable to connect.");
setRetryTimer();
return false;
}
Log.w(TAG, "Trying to create a new connection.");
mBluetoothGatt = device.connectGatt(getApplicationContext(), false, mGattCallback);
mConnectionState = STATE_CONNECTING;
return true;
}
public void authenticateConnection() {
Log.w(TAG, "Trying to auth");
String receiverSn = prefs.getString("share_key", "SM00000000").toUpperCase() + "000000";
if(receiverSn.compareTo("SM00000000000000") == 0) { // They havnt set their serial number, dont bond!
setRetryTimer();
return;
}
byte[] bondkey = (receiverSn).getBytes(StandardCharsets.US_ASCII);
if (mBluetoothGatt != null) {
if (mShareService != null) {
if(!share2) {
mAuthenticationCharacteristic = mShareService.getCharacteristic(DexShareAttributes.AuthenticationCode);
} else {
mAuthenticationCharacteristic = mShareService.getCharacteristic(DexShareAttributes.AuthenticationCode2);
}
if (mAuthenticationCharacteristic != null) {
Log.v(TAG, "Auth Characteristic found: " + mAuthenticationCharacteristic.toString());
if (mAuthenticationCharacteristic.setValue(bondkey)) {
mBluetoothGatt.writeCharacteristic(mAuthenticationCharacteristic);
} else {
setRetryTimer();
}
} else {
Log.w(TAG, "Authentication Characteristic IS NULL");
setRetryTimer();
}
} else {
Log.w(TAG, "CRADLE SERVICE IS NULL");
}
} else {
setRetryTimer();
}
}
public void assignCharacteristics() {
if(!share2) {
Log.d(TAG, "Setting #1 characteristics");
mSendDataCharacteristic = mShareService.getCharacteristic(DexShareAttributes.ShareMessageReceiver);
mReceiveDataCharacteristic = mShareService.getCharacteristic(DexShareAttributes.ShareMessageResponse);
mCommandCharacteristic = mShareService.getCharacteristic(DexShareAttributes.Command);
mResponseCharacteristic = mShareService.getCharacteristic(DexShareAttributes.Response);
mHeartBeatCharacteristic = mShareService.getCharacteristic(DexShareAttributes.HeartBeat);
} else {
Log.d(TAG, "Setting #1 characteristics");
mSendDataCharacteristic = mShareService.getCharacteristic(DexShareAttributes.ShareMessageReceiver2);
mReceiveDataCharacteristic = mShareService.getCharacteristic(DexShareAttributes.ShareMessageResponse2);
mCommandCharacteristic = mShareService.getCharacteristic(DexShareAttributes.Command2);
mResponseCharacteristic = mShareService.getCharacteristic(DexShareAttributes.Response2);
mHeartBeatCharacteristic = mShareService.getCharacteristic(DexShareAttributes.HeartBeat2);
}
}
public void setListeners(int listener_number) {
Log.w(TAG, "Setting Listener: #" + listener_number);
if (listener_number == 1) {
step = 2;
setCharacteristicIndication(mReceiveDataCharacteristic);
} else {
step = 3;
attemptRead();
}
}
public void close() {
if (mBluetoothGatt == null) {
return;
}
mBluetoothGatt.close();
setRetryTimer();
mBluetoothGatt = null;
mConnectionState = STATE_DISCONNECTED;
Log.w(TAG, "bt Disconnected");
}
public void setCharacteristicNotification(BluetoothGattCharacteristic characteristic) {
setCharacteristicNotification(characteristic, true);
}
public void setCharacteristicNotification(BluetoothGattCharacteristic characteristic, boolean enabled) {
Log.w(TAG, "Characteristic setting notification");
mBluetoothGatt.setCharacteristicNotification(characteristic, enabled);
BluetoothGattDescriptor descriptor = characteristic.getDescriptor(UUID.fromString(HM10Attributes.CLIENT_CHARACTERISTIC_CONFIG));
Log.w(TAG, "Descriptor found: " + descriptor.getUuid());
descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
mBluetoothGatt.writeDescriptor(descriptor);
}
public void setCharacteristicIndication(BluetoothGattCharacteristic characteristic) {
setCharacteristicIndication(characteristic, true);
}
public void setCharacteristicIndication(BluetoothGattCharacteristic characteristic, boolean enabled) {
Log.w(TAG, "Characteristic setting indication");
mBluetoothGatt.setCharacteristicNotification(characteristic, enabled);
BluetoothGattDescriptor descriptor = characteristic.getDescriptor(UUID.fromString(HM10Attributes.CLIENT_CHARACTERISTIC_CONFIG));
Log.w(TAG, "Descriptor found: " + descriptor.getUuid());
descriptor.setValue(BluetoothGattDescriptor.ENABLE_INDICATION_VALUE);
mBluetoothGatt.writeDescriptor(descriptor);
}
public void writeCommand(List packets, int aRecordType, Action1 dataResponseListener) {
mDataResponseListener = dataResponseListener;
successfulWrites = 0;
writePackets = packets;
recordType = aRecordType;
step = 0;
currentGattTask = GATT_WRITING_COMMANDS;
gattWritingStep();
}
public void clearGattTask() {
currentGattTask = GATT_NOTHING;
step = 0;
}
private void gattSetupStep() {
step = 1;
if(share2) { assignCharacteristics(); }
setListeners(1);
}
private void gattWritingStep() {
Log.d(TAG, "Writing command to the Gatt, step: " + step);
int index = step;
if (index <= (writePackets.size() - 1)) {
Log.d(TAG, "Writing: " + writePackets.get(index) + " index: " + index);
if(mSendDataCharacteristic != null && writePackets != null) {
mSendDataCharacteristic.setValue(writePackets.get(index));
if (mBluetoothGatt.writeCharacteristic(mSendDataCharacteristic)) {
Log.d(TAG, "Wrote Successfully");
}
}
} else {
Log.d(TAG, "Done Writing commands");
clearGattTask();
}
}
private final BroadcastReceiver mPairReceiver = new BroadcastReceiver() {
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
final BluetoothDevice bondDevice = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
if (mBluetoothGatt != null && mBluetoothGatt.getDevice() != null && bondDevice != null) {
if (!bondDevice.getAddress().equals(mBluetoothGatt.getDevice().getAddress())) {
Log.d(TAG, "Bond state wrong device");
return; // That wasnt a device we care about!!
}
}
if (BluetoothDevice.ACTION_BOND_STATE_CHANGED.equals(action)) {
final int state = intent.getIntExtra(BluetoothDevice.EXTRA_BOND_STATE, BluetoothDevice.ERROR);
if (state == BluetoothDevice.BOND_BONDED) {
Log.d(TAG, "CALLBACK RECIEVED Bonded");
authenticateConnection();
} else if (state == BluetoothDevice.BOND_NONE) {
Log.d(TAG, "CALLBACK RECIEVED: Not Bonded");
} else if (state == BluetoothDevice.BOND_BONDING) {
Log.d(TAG, "CALLBACK RECIEVED: Trying to bond");
}
}
}
};
private final BluetoothGattCallback mGattCallback = new BluetoothGattCallback() {
@Override
public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
Log.w(TAG, "Gatt state change status: " + status + " new state: " + newState);
writeStatusConnectionFailures(status);
if (status == 133) {
Log.e(TAG, "Got the status 133 bug, GROSS!!");
}
if (newState == BluetoothProfile.STATE_CONNECTED) {
mBluetoothGatt = gatt;
device = mBluetoothGatt.getDevice();
mConnectionState = STATE_CONNECTED;
ActiveBluetoothDevice.connected();
Log.w(TAG, "Connected to GATT server.");
Log.w(TAG, "discovering services");
currentGattTask = GATT_SETUP;
if (!mBluetoothGatt.discoverServices()) {
Log.w(TAG, "discovering failed");
if(shouldDisconnect) {
stopSelf();
} else {
setRetryTimer();
}
}
} else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
mConnectionState = STATE_DISCONNECTED;
ActiveBluetoothDevice.disconnected();
if(shouldDisconnect) {
stopSelf();
} else {
setRetryTimer();
}
Log.w(TAG, "Disconnected from GATT server.");
} else {
Log.w(TAG, "Gatt callback... strange state.");
}
}
@Override
public void onServicesDiscovered(BluetoothGatt gatt, int status) {
Log.d(TAG, "services discovered " + status);
if (status == BluetoothGatt.GATT_SUCCESS) {
mShareService = mBluetoothGatt.getService(DexShareAttributes.CradleService);
if(mShareService == null) {
mShareService = mBluetoothGatt.getService(DexShareAttributes.CradleService2);
share2 = true;
} else {
share2 = false;
}
assignCharacteristics();
authenticateConnection();
gattSetupStep();
} else {
Log.w(TAG, "No Services Discovered!");
}
}
@Override
public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
if (status == BluetoothGatt.GATT_SUCCESS) {
Log.v(TAG, "Characteristic Read " + characteristic.getUuid());
if(mHeartBeatCharacteristic.getUuid().equals(characteristic.getUuid())) {
Log.v(TAG, "Characteristic Read " + characteristic.getUuid() + " " + characteristic.getValue());
setCharacteristicNotification(mHeartBeatCharacteristic);
}
mBluetoothGatt.readCharacteristic(mHeartBeatCharacteristic);
} else {
Log.e(TAG, "Characteristic failed to read");
}
}
@Override
public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
UUID charUuid = characteristic.getUuid();
Log.d(TAG, "Characteristic Update Received: " + charUuid);
if (charUuid.compareTo(mReceiveDataCharacteristic.getUuid()) == 0) {
Log.d(TAG, "mCharReceiveData Update");
byte[] value = characteristic.getValue();
if (value != null) {
Observable.just(characteristic.getValue()).subscribe(mDataResponseListener);
}
}
}
@Override
public void onDescriptorWrite(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
if (status == BluetoothGatt.GATT_SUCCESS) {
BluetoothGattCharacteristic characteristic = descriptor.getCharacteristic();
Log.d(TAG, "Characteristic onDescriptorWrite ch " + characteristic.getUuid());
if(mHeartBeatCharacteristic.getUuid().equals(characteristic.getUuid())) {
state_notifSetupSucess = true;
setCharacteristicIndication(mReceiveDataCharacteristic);
}
if(mReceiveDataCharacteristic.getUuid().equals(characteristic.getUuid())) {
setCharacteristicIndication(mResponseCharacteristic);
}
if(mResponseCharacteristic.getUuid().equals(characteristic.getUuid())) {
attemptRead();
}
} else if ((status & BluetoothGatt.GATT_INSUFFICIENT_AUTHENTICATION) != 0 || (status & BluetoothGatt.GATT_INSUFFICIENT_ENCRYPTION) != 0) {
if (gatt.getDevice().getBondState() == BluetoothDevice.BOND_NONE) {
device = gatt.getDevice();
state_authInProgress = true;
bondDevice();
} else {
Log.e(TAG, "The phone is trying to read from paired device without encryption. Android Bug?");
}
} else {
Log.e(TAG, "Unknown error writing descriptor");
}
}
@Override
public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
Log.d(TAG, "characteristic wrote " + status);
if (status == BluetoothGatt.GATT_SUCCESS) {
Log.d(TAG, "Wrote a characteristic successfully " + characteristic.getUuid());
if (mAuthenticationCharacteristic.getUuid().equals(characteristic.getUuid())) {
state_authSucess = true;
mBluetoothGatt.readCharacteristic(mHeartBeatCharacteristic);
}
} else if ((status & BluetoothGatt.GATT_INSUFFICIENT_AUTHENTICATION) != 0 || (status & BluetoothGatt.GATT_INSUFFICIENT_ENCRYPTION) != 0) {
if (gatt.getDevice().getBondState() == BluetoothDevice.BOND_NONE) {
device = gatt.getDevice();
state_authInProgress = true;
bondDevice();
} else {
Log.e(TAG, "The phone is trying to read from paired device without encryption. Android Bug?");
}
} else {
Log.e(TAG, "Unknown error writing Characteristic");
}
}
};
public void bondDevice() {
final IntentFilter bondintent = new IntentFilter(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
registerReceiver(mPairReceiver, bondintent);
if(!share2){ device.setPin("000000".getBytes()); }
device.createBond();
}
private void writeStatusConnectionFailures(int status) {
if(status != 0) {
Log.e(TAG, "ERRR: GATT_WRITE_NOT_PERMITTED " + (status & BluetoothGatt.GATT_WRITE_NOT_PERMITTED));
Log.e(TAG, "ERRR: GATT_INSUFFICIENT_AUTHENTICATION " + (status & BluetoothGatt.GATT_INSUFFICIENT_AUTHENTICATION));
Log.e(TAG, "ERRR: GATT_REQUEST_NOT_SUPPORTED " + (status & BluetoothGatt.GATT_REQUEST_NOT_SUPPORTED));
Log.e(TAG, "ERRR: GATT_INSUFFICIENT_ENCRYPTION " + (status & BluetoothGatt.GATT_INSUFFICIENT_ENCRYPTION));
Log.e(TAG, "ERRR: GATT_INVALID_OFFSET " + (status & BluetoothGatt.GATT_INVALID_OFFSET));
Log.e(TAG, "ERRR: GATT_FAILURE " + (status & BluetoothGatt.GATT_FAILURE));
Log.e(TAG, "ERRR: GATT_INVALID_ATTRIBUTE_LENGTH " + (status & BluetoothGatt.GATT_INVALID_ATTRIBUTE_LENGTH));
Log.e(TAG, "ERRR: GATT_READ_NOT_PERMITTED" + (status & BluetoothGatt.GATT_READ_NOT_PERMITTED));
}
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/Services/MongoWrapper.java
================================================
package com.eveningoutpost.dexdrip.Services;
import java.io.IOException;
import java.net.UnknownHostException;
import android.util.Log;
import com.mongodb.BasicDBObject;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
import com.mongodb.MongoClient;
import com.mongodb.MongoException;
import com.mongodb.MongoClientURI;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
public class MongoWrapper {
MongoClient mongoClient_;
String dbUriStr_;
String dbName_;
String collection_;
String index_;
String machineName_;
private final static String TAG = WixelReader.class.getName();
public MongoWrapper(String dbUriStr, String collection, String index, String machineName) {
dbUriStr_ = dbUriStr;
// dbName is the last part of the string starting with /dbname
dbName_ = dbUriStr.substring(dbUriStr.lastIndexOf('/') + 1);
collection_ = collection;
index_ = index;
machineName_ = machineName;
}
// Unfortunately, this also throws other exceptions that are not documetned...
public DBCollection openMongoDb() throws UnknownHostException {
MongoClientURI dbUri = new MongoClientURI(dbUriStr_); //?? thros
mongoClient_ = new MongoClient(dbUri);
DB db = mongoClient_.getDB( dbName_ );
DBCollection coll = db.getCollection(collection_);
coll.createIndex(new BasicDBObject(index_, 1)); // create index on "i", ascending
return coll;
}
public void closeMongoDb() {
if(mongoClient_ != null) {
mongoClient_.close();
}
}
public boolean WriteDebugDataToMongo(String message)
{
String complete = machineName_ + " " + new Date().toLocaleString() + " " + message;
BasicDBObject doc = new BasicDBObject("DebugMessage", complete);
return WriteToMongo(doc);
}
public boolean WriteToMongo(TransmitterRawData trd)
{
BasicDBObject bdbo = trd.toDbObj(machineName_ + " " + new Date(trd.CaptureDateTime).toLocaleString());
return WriteToMongo(bdbo);
}
public boolean WriteToMongo(BasicDBObject bdbo)
{
DBCollection coll;
try {
coll = openMongoDb();
coll.insert(bdbo);
} catch (UnknownHostException e) {
Log.e(TAG, "WriteToMongo cought UnknownHostException! ",e);
return false;
} catch (MongoException e) {
Log.e(TAG, "WriteToMongo cought MongoException! ", e);
return false;
} catch (Exception e) {
Log.e(TAG, "WriteToMongo cought Exception! ", e);
closeMongoDb();
return false;
}
finally {
closeMongoDb();
}
return true;
}
// records will be marked by their timestamp
public List ReadFromMongo(int numberOfRecords) {
System.out.println( "Starting to read from mongodb");
List trd_list = new LinkedList();
DBCollection coll;
TransmitterRawData lastTrd = null;
try {
coll = openMongoDb();
BasicDBObject query = new BasicDBObject("RawValue", new BasicDBObject("$exists", true));
DBCursor cursor = coll.find(query);
cursor.sort(new BasicDBObject("CaptureDateTime", -1));
try {
while(cursor.hasNext() && trd_list.size() < numberOfRecords) {
//System.out.println(cursor.next());
Log.e(TAG, "Read an object from mongodb");
TransmitterRawData trd = new TransmitterRawData((BasicDBObject)cursor.next());
// Do our best to fix the relative time...
trd.RelativeTime = new Date().getTime() - trd.CaptureDateTime;
// since we are reading it from the db, it was uploaded...
trd.Uploaded = 1;
if(lastTrd == null) {
trd_list.add(0,trd);
lastTrd = trd;
System.out.println( trd.toTableString());
} else if(!WixelReader.almostEquals(lastTrd, trd)) {
lastTrd = trd;
trd_list.add(0,trd);
System.out.println( trd.toTableString());
}
}
} finally {
cursor.close();
}
} catch (UnknownHostException e) {
Log.e(TAG, "ReadFromMongo: cought UnknownHostException! ", e);
return null;
} catch (MongoException e) {
Log.e(TAG, "ReadFromMongo: cought MongoException! " , e);
return trd_list;
} catch (Exception e) {
Log.e(TAG, "ReadFromMongo: cought Exception! " , e);
closeMongoDb();
return null;
}finally {
closeMongoDb();
}
return trd_list;
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/Services/SyncService.java
================================================
package com.eveningoutpost.dexdrip.Services;
import android.app.AlarmManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.os.IBinder;
import android.preference.PreferenceManager;
import android.util.Log;
import com.eveningoutpost.dexdrip.Models.BgReading;
import com.eveningoutpost.dexdrip.Models.Calibration;
import com.eveningoutpost.dexdrip.UtilityModels.BgSendQueue;
import com.eveningoutpost.dexdrip.UtilityModels.CalibrationSendQueue;
import com.eveningoutpost.dexdrip.UtilityModels.MongoSendTask;
import com.eveningoutpost.dexdrip.UtilityModels.NightscoutUploader;
import com.eveningoutpost.dexdrip.UtilityModels.RestCalls;
import com.eveningoutpost.dexdrip.UtilityModels.SensorSendQueue;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
public class SyncService extends Service {
int mStartMode;
private Context mContext;
private Boolean enableRESTUpload;
private Boolean enableMongoUpload;
private SharedPreferences prefs;
@Override
public void onCreate() {
Log.w("SYNC SERVICE:", "STARTING SERVICE");
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
attemptSend();
return START_STICKY;
}
@Override
public void onDestroy() {
setRetryTimer();
Log.w("SYNC SERVICE", "SERVICE STOPPED");
}
@Override
public IBinder onBind(Intent intent) {
throw new UnsupportedOperationException("Not yet implemented");
}
public void attemptSend() {
mContext = getApplicationContext();
prefs = PreferenceManager.getDefaultSharedPreferences(mContext);
enableRESTUpload = prefs.getBoolean("cloud_storage_api_enable", false);
enableMongoUpload = prefs.getBoolean("cloud_storage_mongodb_enable", false);
if (enableRESTUpload || enableMongoUpload) { syncToMogoDb(); }
if (false) {
for (SensorSendQueue job : SensorSendQueue.queue()) {
RestCalls.sendSensor(job);
}
for (CalibrationSendQueue job : CalibrationSendQueue.queue()) {
RestCalls.sendCalibration(job);
}
for (BgSendQueue job : BgSendQueue.queue()) {
RestCalls.sendBgReading(job);
}
}
setRetryTimer();
}
public void setRetryTimer() {
Calendar calendar = Calendar.getInstance();
AlarmManager alarm = (AlarmManager)getSystemService(ALARM_SERVICE);
alarm.set(alarm.RTC_WAKEUP, calendar.getTimeInMillis() + (1000 * 30 * 5), PendingIntent.getService(this, 0, new Intent(this, SyncService.class), 0));
}
public void syncToMogoDb() {
MongoSendTask task = new MongoSendTask(getApplicationContext());
task.execute();
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/Services/TransmitterRawData.java
================================================
package com.eveningoutpost.dexdrip.Services;
import java.util.Date;
import com.mongodb.BasicDBObject;
/**
* Created by John Costik on 6/7/14.
*/
public class TransmitterRawData {
private long _id;
public String Id;
public int TransmissionId;
public String TransmitterId;
public int RawValue;
public int FilteredValue;
public int BatteryLife;
public int ReceivedSignalStrength;
public long CaptureDateTime;
public int Uploaded;
public int UploadAttempts;
public int UploaderBatteryLife;
// When sending set this value to the relative time...
// The time between the capture and now...
public long RelativeTime;
public int getTransmissionId() {
return TransmissionId;
}
public void setTransmissionId(int transmissionId) {
TransmissionId = transmissionId;
}
public int getUploaded() {
return Uploaded;
}
public void setUploaded(int uploaded) {
Uploaded = uploaded;
}
public int getUploadAttempts() {
return UploadAttempts;
}
public void setUploadAttempts(int uploadAttempts) {
UploadAttempts = uploadAttempts;
}
public int getUploaderBatteryLife() {
return UploaderBatteryLife;
}
public void setUploaderBatteryLife(int uploaderBatteryLife) {
UploaderBatteryLife = uploaderBatteryLife;
}
public int getBatteryLife() {
return BatteryLife;
}
public void setBatteryLife(int batteryLife) {
BatteryLife = batteryLife;
}
public int getReceivedSignalStrength() {
return ReceivedSignalStrength;
}
public void setReceivedSignalStrength(int receivedSignalStrength) {
ReceivedSignalStrength = receivedSignalStrength;
}
public String getTransmitterId() {
return TransmitterId;
}
public void setTransmitterId(String transmitterId) {
TransmitterId = transmitterId;
}
public int getRawValue() {
return RawValue;
}
public void setRawValue(int rawValue) {
RawValue = rawValue;
}
public int getFilteredValue() {
return FilteredValue;
}
public void setFilteredValue(int filteredValue) {
FilteredValue = filteredValue;
}
public long getCaptureDateTime() {
return CaptureDateTime;
}
public void setCaptureDateTime(long captureDateTime) {
CaptureDateTime = captureDateTime;
}
public long get_id() {
return _id;
}
public void set_id(long _id) {
this._id = _id;
}
private Long getRelativeTime() {
return RelativeTime;
}
public TransmitterRawData(){
}
/*
public TransmitterRawData(String id, String raw, String filter, String battery, String rssi, int uploaderBattery){
RawValue = Integer.parseInt(raw);
FilteredValue = Integer.parseInt(filter);
TransmitterId = id;
BatteryLife = Integer.parseInt(battery);
ReceivedSignalStrength = Integer.parseInt(rssi);
CaptureDateTime = new Date().getTime();
UploaderBatteryLife = uploaderBattery;
Uploaded = 0;
UploadAttempts = 1;
}
public TransmitterRawData(byte[] buffer, int len, Context context){
StringBuilder toParse = new StringBuilder();
for (int i = 0; i < len; ++i) {
toParse.append((char) buffer[i]);
}
String[] parsed = toParse.toString().split("\\s+");
RawValue = Integer.parseInt(parsed[1]);
FilteredValue = Integer.parseInt(parsed[2]);
TransmitterId = parsed[0];
BatteryLife = Integer.parseInt(parsed[3]);
ReceivedSignalStrength = Integer.parseInt(parsed[4]);
TransmissionId = Integer.parseInt(parsed[5]);
CaptureDateTime = new Date().getTime();
Intent i = context.registerReceiver(null, new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
UploaderBatteryLife = i.getIntExtra(BatteryManager.EXTRA_LEVEL, -1);
Uploaded = 0;
UploadAttempts = 1;
}
*/
public String toTableString()
{
String displayDt = new Date(getCaptureDateTime()).toLocaleString() + System.getProperty("line.separator");
String transmitterId = "Transmitter Id: " + getTransmitterId() + System.getProperty("line.separator");
String transmissionId = "Transmission Id: " + getTransmissionId() + System.getProperty("line.separator");
String rawVal = "Raw Value: " + getRawValue() + System.getProperty("line.separator");
String filterVal = "Filtered Value: " + getFilteredValue() + System.getProperty("line.separator");
String batteryVal = "Transmitter Battery: " + getBatteryLife() + " " + System.getProperty("line.separator");
String signalVal = "RSSI: " + getReceivedSignalStrength() + " " + System.getProperty("line.separator");
String uploadDeviceBatteryVal = "Uploader Battery: " + getUploaderBatteryLife() + " " + System.getProperty("line.separator");
String uploaded = "Uploaded: " + getUploaded() + " " + System.getProperty("line.separator");
String RelativeTime = "relateive time (seconds): " + getRelativeTime() / 1000 + " "+ System.getProperty("line.separator");
return displayDt + transmitterId + transmissionId + rawVal + filterVal + batteryVal + signalVal + uploadDeviceBatteryVal + uploaded + RelativeTime;
}
public BasicDBObject toDbObj(String DebugInfo) {
BasicDBObject doc = new BasicDBObject("TransmissionId", TransmissionId).
append("TransmitterId", TransmitterId).
append("RawValue", RawValue).
append("FilteredValue", FilteredValue).
append("BatteryLife", BatteryLife).
append("ReceivedSignalStrength", ReceivedSignalStrength).
append("CaptureDateTime", CaptureDateTime).
append("UploaderBatteryLife", UploaderBatteryLife).
append("DebugInfo", DebugInfo);
return doc;
}
public TransmitterRawData(BasicDBObject src) {
TransmissionId = src.getInt("TransmissionId");
TransmitterId = src.getString("TransmitterId");
RawValue = src.getInt("RawValue");
FilteredValue = src.getInt("FilteredValue");
BatteryLife = src.getInt("BatteryLife");
ReceivedSignalStrength = src.getInt("ReceivedSignalStrength");
CaptureDateTime = src.getLong("CaptureDateTime");
UploaderBatteryLife = src.getInt("UploaderBatteryLife");
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/Services/WixelReader.java
================================================
package com.eveningoutpost.dexdrip.Services;
import java.io.IOException;
import java.util.Date;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.util.LinkedList;
import java.util.List;
import android.content.Context;
import android.content.SharedPreferences;
import android.preference.PreferenceManager;
import android.util.Log;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.eveningoutpost.dexdrip.Sensor;
import com.eveningoutpost.dexdrip.Models.BgReading;
import com.eveningoutpost.dexdrip.Models.TransmitterData;
public class WixelReader extends Thread {
private final static String TAG = WixelReader.class.getName();
private static WixelReader singleton;
public synchronized static WixelReader getInstance(Context ctx) {
if(singleton == null) {
singleton = new WixelReader(ctx);
}
return singleton;
}
private final Context mContext;
private volatile boolean mStop = false;
private static boolean sStarted = false;
public WixelReader(Context ctx) {
mContext = ctx.getApplicationContext();
}
public static void sStart(Context ctx) {
if(sStarted) {
return;
}
WixelReader theWixelReader = getInstance(ctx);
theWixelReader.start();
sStarted = true;
}
public static void sStop() {
if(!sStarted) {
return;
}
WixelReader theWixelReader = getInstance(null);
theWixelReader.Stop();
try {
theWixelReader.join();
} catch (InterruptedException e) {
Log.e(TAG, "cought InterruptedException, could not wait for the wixel thread to exit", e);
}
sStarted = false;
// A stopped thread can not start again, so we need to kill it and will start a new one
// on demand
singleton = null;
}
public static boolean IsConfigured(Context ctx) {
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(ctx);
String recieversIpAddresses = prefs.getString("wifi_recievers_addresses", "");
if(recieversIpAddresses == null || recieversIpAddresses.equals("") ) {
return false;
}
return true;
}
public static boolean almostEquals( TransmitterRawData e1, TransmitterRawData e2)
{
if (e1 == null || e2==null) {
return false;
}
// relative time is in ms
if ((Math.abs(e1.CaptureDateTime - e2.CaptureDateTime) < 120 * 1000 ) &&
(e1.TransmissionId == e2.TransmissionId)) {
return true;
}
return false;
}
// last in the array, is first in time
public static List Merge2Lists(List list1 , List list2)
{
List merged = new LinkedList ();
while (true) {
if(list1.size() == 0 && list2.size() == 0) {
break;
}
if (list1.size() == 0) {
merged.addAll(list2);
break;
}
if (list2.size() == 0) {
merged.addAll(list1);
break;
}
if (almostEquals(list1.get(0), list2.get(0))) {
list2.remove(0);
merged.add(list1.remove(0));
continue;
}
if(list1.get(0).RelativeTime > list2.get(0).RelativeTime) {
merged.add(list1.remove(0));
} else {
merged.add(list2.remove(0));
}
}
return merged;
}
public static List MergeLists(List > allTransmitterRawData)
{
List MergedList;
MergedList = allTransmitterRawData.remove(0);
for (List it : allTransmitterRawData) {
MergedList = Merge2Lists(MergedList, it);
}
return MergedList;
}
public static List ReadHost(String hostAndIp, int numberOfRecords)
{
int port;
System.out.println("Reading From " + hostAndIp);
Log.i(TAG,"Reading From " + hostAndIp);
String []hosts = hostAndIp.split(":");
if(hosts.length != 2) {
System.out.println("Invalid hostAndIp " + hostAndIp);
Log.e(TAG, "Invalid hostAndIp " + hostAndIp);
return null;
}
try {
port = Integer.parseInt(hosts[1]);
} catch (NumberFormatException nfe) {
System.out.println("Invalid port " +hosts[1]);
Log.e(TAG, "Invalid hostAndIp " + hostAndIp, nfe);
return null;
}
if (port < 10 || port > 65536) {
System.out.println("Invalid port " +hosts[1]);
Log.e(TAG, "Invalid hostAndIp " + hostAndIp);
return null;
}
System.out.println("Reading from " + hosts[0] + " " + port);
List ret;
try {
ret = Read(hosts[0], port, numberOfRecords);
} catch(Exception e) {
// We had some error, need to move on...
System.out.println("read from host failed cought expation" + hostAndIp);
Log.e(TAG, "read from host failed " + hostAndIp, e);
return null;
}
return ret;
}
public static List ReadFromMongo(String dbury, int numberOfRecords)
{
Log.i(TAG,"Reading From " + dbury);
List tmpList;
// format is dburi/db/collection. We need to find the collection and strip it from the dburi.
int indexOfSlash = dbury.lastIndexOf('/');
if(indexOfSlash == -1) {
// We can not find a collection name
Log.e(TAG, "Error bad dburi. Did not find a collection name starting with / " + dbury);
// in order for the user to understand that there is a problem, we return null
return null;
}
String collection = dbury.substring(indexOfSlash + 1);
dbury = dbury.substring(0, indexOfSlash);
// Make sure that we have another /, since this is used in the constructor.
indexOfSlash = dbury.lastIndexOf('/');
if(indexOfSlash == -1) {
// We can not find a collection name
Log.e(TAG, "Error bad dburi. Did not find a collection name starting with / " + dbury);
// in order for the user to understand that there is a problem, we return null
return null;
}
MongoWrapper mt = new MongoWrapper(dbury, collection, "CaptureDateTime", "MachineNameNotUsed");
return mt.ReadFromMongo(numberOfRecords);
}
// format of string is ip1:port1,ip2:port2;
public static TransmitterRawData[] Read(String hostsNames, int numberOfRecords)
{
String []hosts = hostsNames.split(",");
if(hosts.length == 0) {
Log.e(TAG, "Error no hosts were found " + hostsNames);
return null;
}
List > allTransmitterRawData = new LinkedList >();
// go over all hosts and read data from them
for(String host : hosts) {
List tmpList;
if (host.startsWith("mongodb://")) {
tmpList = ReadFromMongo(host ,numberOfRecords);
} else {
tmpList = ReadHost(host, numberOfRecords);
}
if(tmpList != null && tmpList.size() > 0) {
allTransmitterRawData.add(tmpList);
}
}
// merge the information
if (allTransmitterRawData.size() == 0) {
System.out.println("Could not read anything from " + hostsNames);
Log.e(TAG, "Could not read anything from " + hostsNames);
return null;
}
List mergedData= MergeLists(allTransmitterRawData);
int retSize = Math.min(numberOfRecords, mergedData.size());
TransmitterRawData []trd_array = new TransmitterRawData[retSize];
mergedData.subList(mergedData.size() - retSize, mergedData.size()).toArray(trd_array);
System.out.println("Final Results========================================================================");
for (int i= 0; i < trd_array.length; i++) {
// System.out.println( trd_array[i].toTableString());
}
return trd_array;
}
public static List Read(String hostName,int port, int numberOfRecords)
{
List trd_list = new LinkedList();
try
{
Log.i(TAG, "Read called");
Gson gson = new GsonBuilder().create();
// An example of using gson.
ComunicationHeader ch = new ComunicationHeader();
ch.version = 1;
ch.numberOfRecords = numberOfRecords;
String flat = gson.toJson(ch);
ComunicationHeader ch2 = gson.fromJson(flat, ComunicationHeader.class);
System.out.println("Results code" + flat + ch2.version);
// Real client code
Socket MySocket = new Socket(hostName, port);
System.out.println("After the new socket \n");
MySocket.setSoTimeout(2000);
System.out.println("client connected... " );
PrintWriter out = new PrintWriter(MySocket.getOutputStream(), true);
BufferedReader in = new BufferedReader(new InputStreamReader(MySocket.getInputStream()));
out.println(flat);
while(true) {
String data = in.readLine();
if(data == null) {
System.out.println("recieved null exiting");
break;
}
if(data.equals("")) {
System.out.println("recieved \"\" exiting");
break;
}
//System.out.println( "data size " +data.length() + " data = "+ data);
TransmitterRawData trd = gson.fromJson(data, TransmitterRawData.class);
trd.CaptureDateTime = System.currentTimeMillis() - trd.RelativeTime;
trd_list.add(0,trd);
// System.out.println( trd.toTableString());
if(trd_list.size() == numberOfRecords) {
// We have the data we want, let's get out
break;
}
}
MySocket.close();
return trd_list;
}catch(SocketTimeoutException s) {
Log.e(TAG, "Socket timed out! ", s);
}
catch(IOException e) {
Log.e(TAG, "cought IOException! ", e);
}
return trd_list;
}
public void run()
{
Long LastReportedTime = new Date().getTime();
TransmitterRawData LastReportedReading = null;
Log.e(TAG, "Starting... LastReportedReading " + LastReportedReading);
try {
while (!mStop && !interrupted()) {
// try to read one object...
TransmitterRawData[] LastReadingArr = null;
if(WixelReader.IsConfigured(mContext)) {
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(mContext);
String recieversIpAddresses = prefs.getString("wifi_recievers_addresses", "");
LastReadingArr = Read(recieversIpAddresses ,1);
}
if (LastReadingArr != null && LastReadingArr.length > 0) {
// Last in the array is the most updated reading we have.
TransmitterRawData LastReading = LastReadingArr[LastReadingArr.length -1];
//if (LastReading.CaptureDateTime > LastReportedReading + 5000) {
// Make sure we do not report packets from the far future...
if ((LastReading.CaptureDateTime > LastReportedTime ) &&
(!almostEquals(LastReading, LastReportedReading)) &&
LastReading.CaptureDateTime < new Date().getTime() + 12000) {
// We have a real new reading...
Log.e(TAG, "calling setSerialDataToTransmitterRawData " + LastReading.RawValue +
" LastReading.CaptureDateTime " + LastReading.CaptureDateTime + " " + LastReading.TransmissionId);
setSerialDataToTransmitterRawData(LastReading.RawValue , LastReading.BatteryLife, LastReading.CaptureDateTime);
LastReportedReading = LastReading;
LastReportedTime = LastReading.CaptureDateTime;
}
}
// let's sleep (right now for 30 seconds)
Thread.sleep(30000);
}
} catch (InterruptedException e) {
Log.e(TAG, "cought InterruptedException! ", e);
// time to get out...
}
}
// this function is only a test function. It is used to set many points fast in order to allow
// faster testing without real data.
public void runFake()
{
// let's start by faking numbers....
int i = 0;
int added = 5;
while (!mStop) {
try {
for (int j = 0 ; j < 3; j++) {
Thread.sleep(1000);
if(mStop ) {
// we were asked to leave, so do it....
return;
}
}
i+=added;
if (i==50) {
added = -5;
}
if (i==0) {
added = 5;
}
int fakedRaw = 150000 + i * 1000;
Log.e(TAG, "calling setSerialDataToTransmitterRawData " + fakedRaw);
setSerialDataToTransmitterRawData(fakedRaw, 100, new Date().getTime());
} catch (InterruptedException e) {
// time to get out...
Log.e(TAG, "cought InterruptedException! ", e);
break;
}
}
}
public void Stop()
{
mStop = true;
interrupt();
}
public void setSerialDataToTransmitterRawData(int raw_data ,int sensor_battery_leve, Long CaptureTime) {
TransmitterData transmitterData = TransmitterData.create(raw_data, sensor_battery_leve, CaptureTime);
if (transmitterData != null) {
Sensor sensor = Sensor.currentSensor();
if (sensor != null) {
BgReading bgReading = BgReading.create(transmitterData.raw_data, mContext, CaptureTime);
sensor.latest_battery_level = transmitterData.sensor_battery_level;
sensor.save();
} else {
Log.w(TAG, "No Active Sensor, Data only stored in Transmitter Data");
}
}
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/SettingsActivity.java
================================================
package com.eveningoutpost.dexdrip;
import android.media.Ringtone;
import android.media.RingtoneManager;
import android.net.Uri;
import android.os.Bundle;
import android.preference.ListPreference;
import android.preference.Preference;
import android.preference.PreferenceActivity;
import android.preference.PreferenceCategory;
import android.preference.PreferenceManager;
import android.preference.RingtonePreference;
import android.text.TextUtils;
public class SettingsActivity extends PreferenceActivity {
@Override
protected void onPostCreate(Bundle savedInstanceState) {
super.onPostCreate(savedInstanceState);
setupSimplePreferencesScreen();
}
private void setupSimplePreferencesScreen() {
addPreferencesFromResource(R.xml.pref_license);
PreferenceCategory fakeHeader = new PreferenceCategory(this);
getPreferenceScreen().addPreference(fakeHeader);
addPreferencesFromResource(R.xml.pref_general);
fakeHeader = new PreferenceCategory(this);
getPreferenceScreen().addPreference(fakeHeader);
addPreferencesFromResource(R.xml.pref_notifications);
fakeHeader = new PreferenceCategory(this);
getPreferenceScreen().addPreference(fakeHeader);
addPreferencesFromResource(R.xml.pref_data_source);
fakeHeader = new PreferenceCategory(this);
getPreferenceScreen().addPreference(fakeHeader);
addPreferencesFromResource(R.xml.pref_data_sync);
bindPreferenceSummaryToValue(findPreference("dex_collection_method"));
bindPreferenceSummaryToValue(findPreference("units"));
bindPreferenceSummaryToValue(findPreference("share_key"));
}
private static Preference.OnPreferenceChangeListener sBindPreferenceSummaryToValueListener = new Preference.OnPreferenceChangeListener() {
@Override
public boolean onPreferenceChange(Preference preference, Object value) {
String stringValue = value.toString();
if (preference instanceof ListPreference) {
ListPreference listPreference = (ListPreference) preference;
int index = listPreference.findIndexOfValue(stringValue);
preference.setSummary(
index >= 0
? listPreference.getEntries()[index]
: null);
} else if (preference instanceof RingtonePreference) {
if (TextUtils.isEmpty(stringValue)) {
preference.setSummary(R.string.pref_ringtone_silent);
} else {
Ringtone ringtone = RingtoneManager.getRingtone(
preference.getContext(), Uri.parse(stringValue));
if (ringtone == null) {
preference.setSummary(null);
} else {
String name = ringtone.getTitle(preference.getContext());
preference.setSummary(name);
}
}
} else {
preference.setSummary(stringValue);
}
return true;
}
};
private static void bindPreferenceSummaryToValue(Preference preference) {
preference.setOnPreferenceChangeListener(sBindPreferenceSummaryToValueListener);
sBindPreferenceSummaryToValueListener.onPreferenceChange(preference,
PreferenceManager
.getDefaultSharedPreferences(preference.getContext())
.getString(preference.getKey(), ""));
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/ShareModels/DexcomShareInterface.java
================================================
package com.eveningoutpost.dexdrip.ShareModels;
import java.util.Map;
import retrofit.Callback;
import retrofit.client.Response;
import retrofit.http.Body;
import retrofit.http.POST;
import retrofit.http.QueryMap;
/**
* Created by stephenblack on 3/16/15.
*/
public interface DexcomShareInterface {
@POST("/Publisher/ReadPublisherLatestGlucoseValues")
ShareGlucose[] getShareBg(@QueryMap Map options);
@POST("/General/LoginPublisherAccountByName")
void getSessionId(@Body ShareAuthenticationBody body, Callback callback);
//Since this seems to respond with a string we need a callback that will parse the response body
//new String(((TypedByteArray) response.getBody()).getBytes());
@POST("/Publisher/IsRemoteMonitoringSessionActive")
void checkSessionActive(@QueryMap Map options, Callback callback);
// needs ?sessionId={YourSessionId}
// returns true or false
@POST("/Publisher/PostReceiverEgvRecords")
void uploadBGRecords(@QueryMap Map options, @Body ShareUploadPayload payload, Callback callback);
// needs ?sessionId={YourSessionId}
// body ShareUploadPayload
// status code
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/ShareModels/Egv.java
================================================
package com.eveningoutpost.dexdrip.ShareModels;
import com.eveningoutpost.dexdrip.Models.BgReading;
import com.google.gson.annotations.Expose;
/**
* Created by stephenblack on 3/19/15.
*/
public class Egv {
@Expose
public int Trend;
@Expose
public int Value;
@Expose
public String ST;
@Expose
public String DT;
public Egv(BgReading bg) {
this.Value = (int) bg.calculated_value;
this.DT = toDateString(bg.timestamp);
this.ST = toDateString(bg.timestamp);
this.Trend = slopeOrdinal(bg);
}
public String toDateString(double timestamp) {
long shortened = (long) Math.floor((timestamp/1000));
return "/Date(" + Long.toString(shortened*1000) + ")/";
}
public int slopeOrdinal(BgReading bg) {
double slope_by_minute = bg.calculated_value_slope * 60000;
int arrow = 0;
if (slope_by_minute <= (-3.5)) {
arrow = 7;
} else if (slope_by_minute <= (-2)) {
arrow = 6;
} else if (slope_by_minute <= (-1)) {
arrow = 5;
} else if (slope_by_minute <= (1)) {
arrow = 4;
} else if (slope_by_minute <= (2)) {
arrow = 3;
} else if (slope_by_minute <= (3.5)) {
arrow = 2;
} else {
arrow = 1;
}
if(bg.hide_slope) {
arrow = 9;
}
return arrow;
}
// {
//
// "Trend":4,
// "ST":"\/Date(1426783106000 - 1426754317000)\/",
// "DT":"\/Date(1426754317000)\/",
// "Value":97
// }
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/ShareModels/ShareAuthenticationBody.java
================================================
package com.eveningoutpost.dexdrip.ShareModels;
import com.google.gson.annotations.Expose;
/**
* Created by stephenblack on 3/16/15.
*/
public class ShareAuthenticationBody {
@Expose
public String password;
@Expose
public String applicationId;
@Expose
public String accountName;
public ShareAuthenticationBody(String aPassword, String aAccountName) {
this.password = aPassword;
this.accountName = aAccountName;
this.applicationId = "d89443d2-327c-4a6f-89e5-496bbb0317db";
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/ShareModels/ShareGlucose.java
================================================
package com.eveningoutpost.dexdrip.ShareModels;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.BatteryManager;
import android.provider.BaseColumns;
import android.util.Log;
import com.activeandroid.Model;
import com.activeandroid.annotation.Column;
import com.activeandroid.annotation.Table;
import com.google.gson.annotations.Expose;
/**
* Created by stephenblack on 3/16/15.
*/
@Table(name = "ShareGlucose", id = BaseColumns._ID)
public class ShareGlucose extends Model {
public Context mContext;
@Expose
@Column(name = "DT")
public String DT;
@Expose
@Column(name = "ST")
public String ST;
@Expose
@Column(name = "Trend")
public double Trend;
@Expose
@Column(name = "Value")
public double Value;
@Expose
@Column(name = "WT")
public String WT;
public void processShareData(Context context) {
Log.d("SHARE", "Share Data being processed!"); // TODO maybe set this up??
// mContext = context;
// Log.d("SHARE", "Timestamp before parsing: " + WT);
// Log.d("SHARE", "Timestamp before parsing: " + WT.replaceAll("[^\\d.]", ""));
//
// double timestamp = (Double.parseDouble(WT.replaceAll("[^\\d.]", "")));
// Log.d("SHARE", "Timestamp: " + timestamp);
// if (!Bg.alreadyExists(timestamp)) {
// Log.d("SHARE", "Data looks new!!");
// Bg bg = new Bg();
// bg.direction = slopeDirection();
// bg.battery = Integer.toString(getBatteryLevel());
// bg.bgdelta = calculateDelta(timestamp, Value);
// bg.datetime = timestamp;
// bg.sgv = Integer.toString((int) Value);
// bg.save();
// DataCollectionService.newDataArrived(mContext, true);
// Log.d("SHARE", "Share Data Processed Successfully!");
// } else {
// Log.d("SHARE", "A Bg Value similar to this timestamp already exists.");
// }
}
public String slopeDirection() {
switch((int) Trend) {
case 1:
return "DoubleUp";
case 2:
return "SingleUp";
case 3:
return "FortyFiveUp";
case 4:
return "Flat";
case 5:
return "FortyFiveDown";
case 6:
return "SingleDown";
case 7:
return "DoubleDown";
default:
return "";
}
}
public int getBatteryLevel() {
Intent batteryIntent = mContext.registerReceiver(null, new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
int level = batteryIntent.getIntExtra(BatteryManager.EXTRA_LEVEL, -1);
int scale = batteryIntent.getIntExtra(BatteryManager.EXTRA_SCALE, -1);
if(level == -1 || scale == -1) {
return 50;
}
return (int)(((float)level / (float)scale) * 100.0f);
}
public double calculateDelta(double timestamp, double currentValue) {
// Bg bg = Bg.mostRecentBefore(timestamp);
// if (bg != null && Math.abs(bg.datetime - timestamp) < (60*1000*15)) {
// return (bg.sgv_double() - currentValue);
// } else {
return 0;
// }
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/ShareModels/ShareRest.java
================================================
package com.eveningoutpost.dexdrip.ShareModels;
import android.content.Context;
import android.content.SharedPreferences;
import android.os.AsyncTask;
import android.preference.PreferenceManager;
import android.util.Log;
import com.eveningoutpost.dexdrip.Models.BgReading;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.squareup.okhttp.OkHttpClient;
import java.security.cert.CertificateException;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import retrofit.Callback;
import retrofit.RequestInterceptor;
import retrofit.RestAdapter;
import retrofit.RetrofitError;
import retrofit.android.AndroidLog;
import retrofit.client.OkClient;
import retrofit.client.Response;
import retrofit.converter.GsonConverter;
import retrofit.mime.TypedByteArray;
/**
* Created by stephenblack on 12/26/14.
*/
public class ShareRest {
private Context mContext;
private String login;
private String password;
private SharedPreferences prefs;
OkClient client;
public static Gson gson = new GsonBuilder()
.excludeFieldsWithoutExposeAnnotation()
.create();
public ShareRest(Context context) {
client = getOkClient();
mContext = context;
prefs = PreferenceManager.getDefaultSharedPreferences(context);
login = prefs.getString("dexcom_account_name", "");
password = prefs.getString("dexcom_account_password", "");
}
public boolean getBgData() {
if (prefs.getBoolean("share_poll", false) && login.compareTo("") != 0 && password.compareTo("") != 0) {
return loginAndGetData();
} else {
return false;
}
}
public boolean sendBgData(BgReading bg) {
SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(mContext);
String receiverSn = preferences.getString("share_key", "SM00000000").toUpperCase();
if (prefs.getBoolean("share_upload", false) && login.compareTo("") != 0 && password.compareTo("") != 0 && receiverSn.compareTo("SM00000000") != 0) {
return loginAndSendData(bg);
} else {
return false;
}
}
private boolean loginAndGetData() {
try {
dexcomShareAuthorizeInterface().getSessionId(new ShareAuthenticationBody(password, login), new Callback() {
@Override
public void success(Object o, Response response) {
Log.d("ShareRest", "Success!! got a response on auth.");
String returnedSessionId = new String(((TypedByteArray) response.getBody()).getBytes()).replace("\"", "");
getBgData(returnedSessionId);
}
@Override
public void failure(RetrofitError retrofitError) {
Log.e("RETROFIT ERROR: ", ""+retrofitError.toString());
}
});
return true;
} catch (Exception e) {
Log.e("REST CALL ERROR: ", "BOOOO");
return false;
}
}
private boolean loginAndSendData(final BgReading bg) {
try {
dexcomShareAuthorizeInterface().getSessionId(new ShareAuthenticationBody(password, login), new Callback() {
@Override
public void success(Object o, Response response) {
Log.d("ShareRest", "Success!! got a response on auth.");
String returnedSessionId = new String(((TypedByteArray) response.getBody()).getBytes()).replace("\"", "");
sendBgData(returnedSessionId, bg);
}
@Override
public void failure(RetrofitError retrofitError) {
Log.e("RETROFIT ERROR: ", ""+retrofitError.toString());
}
});
return true;
} catch (Exception e) {
Log.e("REST CALL ERROR: ", "BOOOO");
return false;
}
}
private void getBgData(String sessionId) {
DataFetcher dataFetcher = new DataFetcher(mContext, sessionId);
dataFetcher.execute((Void) null);
}
private void sendBgData(String sessionId, BgReading bg) {
DataSender dataSender = new DataSender(mContext, sessionId, bg);
dataSender.execute((Void) null);
}
private DexcomShareInterface dexcomShareAuthorizeInterface() {
RestAdapter adapter = authoirizeAdapterBuilder().build();
DexcomShareInterface dexcomShareInterface =
adapter.create(DexcomShareInterface.class);
return dexcomShareInterface;
}
private DexcomShareInterface dexcomShareGetBgInterface() {
RestAdapter adapter = getBgAdapterBuilder().build();
DexcomShareInterface dexcomShareInterface =
adapter.create(DexcomShareInterface.class);
return dexcomShareInterface;
}
private DexcomShareInterface dexcomShareSendBgInterface() {
RestAdapter adapter = authoirizeAdapterBuilder().build();
DexcomShareInterface dexcomShareInterface =
adapter.create(DexcomShareInterface.class);
return dexcomShareInterface;
}
private DexcomShareInterface checkSessionActive() {
RestAdapter adapter = getBgAdapterBuilder().build();
DexcomShareInterface checkSessionActive =
adapter.create(DexcomShareInterface.class);
return checkSessionActive;
}
private RestAdapter.Builder authoirizeAdapterBuilder() {
RestAdapter.Builder adapterBuilder = new RestAdapter.Builder();
adapterBuilder
.setClient(client)
.setLogLevel(RestAdapter.LogLevel.FULL).setLog(new AndroidLog("SHAREREST"))
.setEndpoint("https://share1.dexcom.com/ShareWebServices/Services")
.setRequestInterceptor(authorizationRequestInterceptor)
.setConverter(new GsonConverter(new GsonBuilder()
.excludeFieldsWithoutExposeAnnotation()
.create()));
return adapterBuilder;
}
private RestAdapter.Builder getBgAdapterBuilder() {
RestAdapter.Builder adapterBuilder = new RestAdapter.Builder();
adapterBuilder
.setClient(client)
.setLogLevel(RestAdapter.LogLevel.FULL).setLog(new AndroidLog("SHAREREST"))
.setEndpoint("https://share1.dexcom.com/ShareWebServices/Services")
.setRequestInterceptor(getBgRequestInterceptor)
.setConverter(new GsonConverter(new GsonBuilder()
.excludeFieldsWithoutExposeAnnotation()
.create()));
return adapterBuilder;
}
RequestInterceptor authorizationRequestInterceptor = new RequestInterceptor() {
@Override
public void intercept(RequestInterceptor.RequestFacade request) {
request.addHeader("User-Agent", "Dexcom Share/3.0.2.11 CFNetwork/711.2.23 Darwin/14.0.0");
request.addHeader("Content-Type", "application/json");
request.addHeader("Accept", "application/json");
}
};
RequestInterceptor getBgRequestInterceptor = new RequestInterceptor() {
@Override
public void intercept(RequestInterceptor.RequestFacade request) {
request.addHeader("User-Agent", "Dexcom Share/3.0.2.11 CFNetwork/711.2.23 Darwin/14.0.0");
request.addHeader("Content-Type", "application/json");
request.addHeader("Content-Length", "0");
request.addHeader("Accept", "application/json");
}
};
public OkHttpClient getOkHttpClient() {
try {
final TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {
@Override
public void checkClientTrusted(
java.security.cert.X509Certificate[] chain,
String authType) throws CertificateException {
}
@Override
public void checkServerTrusted(
java.security.cert.X509Certificate[] chain,
String authType) throws CertificateException {
}
@Override
public java.security.cert.X509Certificate[] getAcceptedIssuers() {
return null;
}
} };
final SSLContext sslContext = SSLContext.getInstance("SSL");
sslContext.init(null, trustAllCerts, new java.security.SecureRandom());
final SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();
OkHttpClient okHttpClient = new OkHttpClient();
okHttpClient.setSslSocketFactory(sslSocketFactory);
okHttpClient.setHostnameVerifier(new HostnameVerifier() {
@Override
public boolean verify(String hostname, SSLSession session) {
return true;
}
});
return okHttpClient;
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public OkClient getOkClient (){
OkHttpClient client1 = getOkHttpClient();
OkClient _client = new OkClient(client1);
return _client;
}
public Map queryParamMap(String sessionId) {
Map map = new HashMap();
map.put("sessionID", sessionId);
map.put("minutes", String.valueOf(minutesCount()));
map.put("maxCount", String.valueOf(requestCount()));
return map;
}
public class DataFetcher extends AsyncTask {
Context mContext;
String mSessionId;
DataFetcher(Context context, String sessionId) {
mContext = context;
mSessionId = sessionId;
}
@Override
protected Boolean doInBackground(Void... params) {
try {
try {
final ShareGlucose[] shareGlucoses = dexcomShareGetBgInterface().getShareBg(queryParamMap(mSessionId));
Log.d("REST Success: ", "YAY!");
if(shareGlucoses != null && shareGlucoses.length > 0) {
for (ShareGlucose shareGlucose : shareGlucoses) {
shareGlucose.processShareData(mContext);
}
return true;
}
return false;
} catch (Exception e) {
Log.d("REST CALL ERROR: ", "BOOOO");
return false;
}
}
catch (RetrofitError e) { Log.d("Retrofit Error: ", "BOOOO"); }
catch (Exception ex) { Log.d("Unrecognized Error: ", "BOOOO"); }
return false;
}
}
public class DataSender extends AsyncTask {
Context mContext;
String mSessionId;
BgReading mBg;
DataSender(Context context, String sessionId, BgReading bg) {
mContext = context;
mSessionId = sessionId;
mBg = bg;
}
@Override
protected Boolean doInBackground(Void... params) {
try {
SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(mContext);
String receiverSn = preferences.getString("share_key", "SM00000000").toUpperCase();
dexcomShareSendBgInterface().uploadBGRecords(querySessionMap(mSessionId), new ShareUploadPayload(receiverSn, mBg), new Callback() {
@Override
public void success(Object o, Response response) {
Log.d("ShareRest", "Success!! Uploaded!!");
}
@Override
public void failure(RetrofitError retrofitError) {
Log.e("RETROFIT ERROR: ", ""+retrofitError.toString());
}
});
}
catch (RetrofitError e) { Log.d("Retrofit Error: ", "BOOOO"); }
catch (Exception ex) { Log.d("Unrecognized Error: ", "BOOOO"); }
return false;
}
}
public int requestCount() {
BgReading bg = BgReading.last();
if(bg != null) {
return 20;
} else if (bg.timestamp < new Date().getTime()) {
return Math.min((int) Math.ceil(((new Date().getTime() - bg.timestamp) / (5 * 1000 * 60))), 10);
} else {
return 1;
}
}
public int minutesCount() {
BgReading bg = BgReading.last();
if(bg != null && bg.timestamp < new Date().getTime()) {
return Math.min((int) Math.ceil(((new Date().getTime() - bg.timestamp) / (1000 * 60))), 1440);
} else {
return 1440;
}
}
public Map querySessionMap(String sessionId) {
Map map = new HashMap();
map.put("sessionID", sessionId);
return map;
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/ShareModels/ShareUploadPayload.java
================================================
package com.eveningoutpost.dexdrip.ShareModels;
import com.eveningoutpost.dexdrip.Models.BgReading;
import com.google.gson.annotations.Expose;
import java.util.ArrayList;
import java.util.List;
/**
* Created by stephenblack on 3/19/15.
*/
public class ShareUploadPayload {
@Expose
public String SN;
@Expose
public Egv[] Egvs;
@Expose
public long TA = -5;
public ShareUploadPayload(String sn, BgReading bg) {
this.SN = sn;
List egvList = new ArrayList();
egvList.add(new Egv(bg));
this.Egvs = egvList.toArray(new Egv[egvList.size()]);
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/ShareTest.java
================================================
package com.eveningoutpost.dexdrip;
import android.app.Activity;
import android.app.AlarmManager;
import android.app.PendingIntent;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothGatt;
import android.bluetooth.BluetoothGattCallback;
import android.bluetooth.BluetoothGattCharacteristic;
import android.bluetooth.BluetoothGattDescriptor;
import android.bluetooth.BluetoothGattService;
import android.bluetooth.BluetoothManager;
import android.bluetooth.BluetoothProfile;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.text.TextUtils;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;
import com.activeandroid.query.Select;
import com.eveningoutpost.dexdrip.ImportedLibraries.dexcom.PacketBuilder;
import com.eveningoutpost.dexdrip.ImportedLibraries.dexcom.ReadData;
import com.eveningoutpost.dexdrip.ImportedLibraries.dexcom.ReadDataShare;
import com.eveningoutpost.dexdrip.ImportedLibraries.dexcom.records.CalRecord;
import com.eveningoutpost.dexdrip.ImportedLibraries.dexcom.records.EGVRecord;
import com.eveningoutpost.dexdrip.ImportedLibraries.dexcom.records.SensorRecord;
import com.eveningoutpost.dexdrip.Models.ActiveBluetoothDevice;
import com.eveningoutpost.dexdrip.Models.BgReading;
import com.eveningoutpost.dexdrip.Models.Calibration;
import com.eveningoutpost.dexdrip.UtilityModels.DexShareAttributes;
import com.eveningoutpost.dexdrip.UtilityModels.ForegroundServiceStarter;
import com.eveningoutpost.dexdrip.UtilityModels.HM10Attributes;
import java.lang.reflect.Method;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.UUID;
import rx.Observable;
import rx.functions.Action1;
public class ShareTest extends Activity {
private final static String TAG = ShareTest.class.getSimpleName();
Button button;
Button closeButton;
Button readButton;
Button bondButton;
TextView details;
private String mDeviceName;
private String mDeviceAddress;
private boolean is_connected = false;
private boolean reconnecting = false;
SharedPreferences prefs;
private BluetoothManager mBluetoothManager;
private BluetoothAdapter mBluetoothAdapter;
private String mBluetoothDeviceAddress;
private BluetoothGatt mBluetoothGatt;
private ForegroundServiceStarter foregroundServiceStarter;
private int mConnectionState = STATE_DISCONNECTED;
private BluetoothDevice device;
int mStartMode;
private Context mContext = null;
private static final int STATE_DISCONNECTED = BluetoothProfile.STATE_DISCONNECTED;
private static final int STATE_DISCONNECTING = BluetoothProfile.STATE_DISCONNECTING;
private static final int STATE_CONNECTING = BluetoothProfile.STATE_CONNECTING;
private static final int STATE_CONNECTED = BluetoothProfile.STATE_CONNECTED;
private BluetoothGattService mShareService;
private BluetoothGattCharacteristic mAuthenticationCharacteristic;
private BluetoothGattCharacteristic mSendDataCharacteristic;
private BluetoothGattCharacteristic mReceiveDataCharacteristic;
private BluetoothGattCharacteristic mHeartBeatCharacteristic;
private BluetoothGattCharacteristic mCommandCharacteristic;
private BluetoothGattCharacteristic mResponseCharacteristic;
//Gatt Tasks
public final int GATT_NOTHING = 0;
public final int GATT_SETUP = 1;
public final int GATT_WRITING_COMMANDS = 2;
public final int GATT_READING_RESPONSE = 3;
public int successfulWrites;
//RXJAVA FUN
Action1 mDataResponseListener;
public ReadDataShare mReadDataShare;
public int currentGattTask;
public int step;
public List writePackets;
public int recordType;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_share_test);
button = (Button) findViewById(R.id.connect);
closeButton = (Button) findViewById(R.id.closeConnect);
bondButton = (Button) findViewById(R.id.bond);
readButton = (Button) findViewById(R.id.read);
details = (TextView) findViewById(R.id.connection_details);
addListenerOnButton();
addListenerOnCloseButton();
IntentFilter intent = new IntentFilter(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
registerReceiver(mPairReceiver, intent);
}
@Override
public void onDestroy() {
super.onDestroy();
close();
Log.w(TAG, "CLOSING CONNECTION");
}
public void addListenerOnButton() {
button.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
attemptConnection();
}
});
readButton.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
attemptRead();
}
});
bondButton.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
bond(mBluetoothGatt);
}
});
}
public void addListenerOnCloseButton() {
closeButton.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
close();
details.setText("");
}
});
}
private final BluetoothGattCallback mGattCallback = new BluetoothGattCallback() {
@Override
public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
if (newState == BluetoothProfile.STATE_CONNECTED) {
mBluetoothGatt = gatt;
mConnectionState = STATE_CONNECTED;
ActiveBluetoothDevice.connected();
Log.w(TAG, "Connected to GATT server.");
Log.w(TAG, "Connection state: Bonded - " + device.getBondState());
if (device.getBondState() == BluetoothDevice.BOND_BONDED) {
currentGattTask = GATT_SETUP;
mBluetoothGatt.discoverServices();
} else {
device.setPin("000000".getBytes());
device.createBond();
}
} else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
mConnectionState = STATE_DISCONNECTED;
ActiveBluetoothDevice.disconnected();
Log.w(TAG, "Disconnected from GATT server.");
}
}
@Override
public void onServicesDiscovered(BluetoothGatt gatt, int status) {
if (status == BluetoothGatt.GATT_SUCCESS) {
Log.w(TAG, "Services Discovered: " + status);
authenticateConnection(gatt);
}
}
@Override
public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
if (status == BluetoothGatt.GATT_SUCCESS) {
Log.w(TAG, "Characteristic Read");
byte[] value = characteristic.getValue();
if(value != null) {
Log.w(TAG, "VALUE" + value);
} else {
Log.w(TAG, "Characteristic was null");
}
nextGattStep();
} else {
Log.w(TAG, "Characteristic failed to read");
}
}
@Override
public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
Log.w(TAG, "Characteristic changed");
UUID charUuid = characteristic.getUuid();
Log.w(TAG, "Characteristic Update Received: " + charUuid);
if(charUuid.compareTo(mResponseCharacteristic.getUuid()) == 0) {
Log.w(TAG, "mResponseCharacteristic Update");
}
if(charUuid.compareTo(mCommandCharacteristic.getUuid()) == 0) {
Log.w(TAG, "mCommandCharacteristic Update");
}
if(charUuid.compareTo(mHeartBeatCharacteristic.getUuid()) == 0) {
Log.w(TAG, "mHeartBeatCharacteristic Update");
}
if(charUuid.compareTo(mReceiveDataCharacteristic.getUuid()) == 0) {
Log.w(TAG, "mReceiveDataCharacteristic Update");
byte[] value = characteristic.getValue();
if(value != null) {
Log.w(TAG, "Characteristic: " + value);
Log.w(TAG, "Characteristic: " + value.toString());
Log.w(TAG, "Characteristic getstring: " + characteristic.getStringValue(0));
Log.w(TAG, "SUBSCRIBED TO RESPONSE LISTENER");
Observable.just(characteristic.getValue()).subscribe(mDataResponseListener);
} else {
Log.w(TAG, "Characteristic was null");
}
}
Log.w(TAG, "NEW VALUE: " + characteristic.getValue().toString());
}
@Override
public void onDescriptorWrite(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
Log.w(TAG, "Wrote a discriptor, status: " + status);
if(step == 2 && currentGattTask == GATT_SETUP) {
setListeners(2);
} else if(step == 3) {
setListeners(3);
} else if(step == 4) {
setListeners(4);
} else if(step == 5) {
Log.w(TAG, "Done setting Listeners");
}
}
@Override
public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
Log.w(TAG, "Wrote a characteristic: " + status);
nextGattStep();
}
};
public void attemptConnection() {
mBluetoothManager = (BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);
if (device != null) {
details.append("\nConnection state: " + " Device is not null");
mConnectionState = mBluetoothManager.getConnectionState(device, BluetoothProfile.GATT);
}
Log.w(TAG, "Connection state: " + mConnectionState);
details.append("\nConnection state: " + mConnectionState);
if (mConnectionState == STATE_DISCONNECTED || mConnectionState == STATE_DISCONNECTING) {
ActiveBluetoothDevice btDevice = new Select().from(ActiveBluetoothDevice.class)
.orderBy("_ID desc")
.executeSingle();
if (btDevice != null) {
details.append("\nBT Device: " + btDevice.name);
mDeviceName = btDevice.name;
mDeviceAddress = btDevice.address;
mBluetoothAdapter = mBluetoothManager.getAdapter();
boolean newConnection = true;
if(newConnection) {
is_connected = connect(mDeviceAddress);
details.append("\nConnecting...: ");
}
}
}
}
public void attemptRead() {
final ReadDataShare readData = new ReadDataShare(this);
final Action1 systemTimeListener = new Action1() {
@Override
public void call(Long s) {
Log.d(TAG, "Made the full round trip, got " + s + " as the system time");
Log.d("SYSTTIME", "Made the full round trip, got " + s + " as the system time");
final long addativeSystemTimeOffset = new Date().getTime() - s;
Log.d(TAG, "Made the full round trip, got " + addativeSystemTimeOffset + " offset");
Log.d("SYSTTIME", "Made the full round trip, got " + addativeSystemTimeOffset + " offset");
final Action1 calRecordListener = new Action1() {
@Override
public void call(CalRecord[] calRecords) {
Log.d(TAG, "Made the full round trip, got " + calRecords.length + " Cal Records");
Calibration.create(calRecords, addativeSystemTimeOffset, getApplicationContext());
final Action1 sensorRecordListener = new Action1() {
@Override
public void call(SensorRecord[] sensorRecords) {
Log.d(TAG, "Made the full round trip, got " + sensorRecords.length + " Sensor Records");
BgReading.create(sensorRecords, addativeSystemTimeOffset, getApplicationContext());
final Action1 evgRecordListener = new Action1() {
@Override
public void call(EGVRecord[] egvRecords) {
Log.d(TAG, "Made the full round trip, got " + egvRecords.length + " EVG Records");
BgReading.create(egvRecords, addativeSystemTimeOffset, getApplicationContext());
}
};
readData.getRecentEGVs(evgRecordListener);
}
};
readData.getRecentSensorRecords(sensorRecordListener);
}
};
readData.getRecentCalRecords(calRecordListener);
}
};
readData.readSystemTime(systemTimeListener);
}
public void bond(BluetoothGatt gatt) {
reconnecting = true;
attemptConnection();
}
public boolean connect(final String address) {
details.append("\nConnecting to device");
Log.w(TAG, "CONNECTING TO DEVICE");
if (mBluetoothAdapter == null || address == null) {
details.append("\nBT adapter is null");
Log.w(TAG, "BluetoothAdapter not initialized or unspecified address.");
return false;
}
if (mBluetoothDeviceAddress != null && address.equals(mBluetoothDeviceAddress) && mBluetoothGatt != null) {
details.append("\nTrying to use an existing mBluetoothGatt for connection.");
if (mBluetoothGatt.connect()) {
mConnectionState = STATE_CONNECTING;
return true;
} else {
return false;
}
} else {
device = mBluetoothAdapter.getRemoteDevice(address);
device.setPin("000000".getBytes());
if (device == null) {
Log.w(TAG, "Device not found. Unable to connect.");
details.append("\nDevice not found. Unable to connect.");
return false;
}
mBluetoothGatt = device.connectGatt(getApplicationContext(), true, mGattCallback);
Log.w(TAG, "Trying to create a new connection.");
details.append("\nTrying to create a new connection to device");
mConnectionState = STATE_CONNECTING;
return true;
}
}
public void authenticateConnection(BluetoothGatt bluetoothGatt) {
Log.w(TAG, "Trying to auth");
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(getApplicationContext());
String receiverSn = prefs.getString("share_key", "SM00000000").toUpperCase();
if(bluetoothGatt != null) {
mBluetoothGatt = bluetoothGatt;
mShareService = mBluetoothGatt.getService(DexShareAttributes.CradleService);
if (mShareService != null) {
mAuthenticationCharacteristic = mShareService.getCharacteristic(DexShareAttributes.AuthenticationCode);
if(mAuthenticationCharacteristic != null) {
Log.w(TAG, "Auth Characteristic found: " + mAuthenticationCharacteristic.toString());
mAuthenticationCharacteristic.setValue((receiverSn + "000000").getBytes(StandardCharsets.US_ASCII));
currentGattTask = GATT_SETUP;
step = 1;
bluetoothGatt.writeCharacteristic(mAuthenticationCharacteristic);
} else {
Log.w(TAG, "Authentication Characteristic IS NULL");
}
} else {
Log.w(TAG, "CRADLE SERVICE IS NULL");
}
}
}
public void assignCharacteristics() {
mSendDataCharacteristic = mShareService.getCharacteristic(DexShareAttributes.ShareMessageReceiver);
mReceiveDataCharacteristic = mShareService.getCharacteristic(DexShareAttributes.ShareMessageResponse);
mHeartBeatCharacteristic = mShareService.getCharacteristic(DexShareAttributes.HeartBeat);
mCommandCharacteristic = mShareService.getCharacteristic(DexShareAttributes.Command);
mResponseCharacteristic = mShareService.getCharacteristic(DexShareAttributes.Response);
}
public void setListeners(int listener_number) {
Log.w(TAG, "Setting Listener: #" + listener_number);
if(listener_number == 1) {
step = 3;
setCharacteristicIndication(mReceiveDataCharacteristic);
} else if(listener_number == 3) {
setCharacteristicIndication(mResponseCharacteristic);
step = 5;
}
}
public void disconnect() {
if (mBluetoothAdapter == null || mBluetoothGatt == null) {
Log.w(TAG, "BluetoothAdapter not initialized");
return;
}
mBluetoothGatt.disconnect();
}
public void close() {
disconnect();
if (mBluetoothGatt == null) {
return;
}
mBluetoothGatt.close();
mBluetoothGatt = null;
mConnectionState = STATE_DISCONNECTED;
Log.w(TAG, "bt Disconnected");
}
public void readCharacteristic(BluetoothGattCharacteristic characteristic) {
if (mBluetoothAdapter == null || mBluetoothGatt == null) {
Log.w(TAG, "BluetoothAdapter not initialized");
return;
}
mBluetoothGatt.readCharacteristic(characteristic);
}
public void setCharacteristicNotification(BluetoothGattCharacteristic characteristic){ setCharacteristicNotification(characteristic, true);}
public void setCharacteristicNotification(BluetoothGattCharacteristic characteristic, boolean enabled) {
Log.w(TAG, "Characteristic setting notification");
mBluetoothGatt.setCharacteristicNotification(characteristic, enabled);
Log.w(TAG, "UUID FOUND: " + characteristic.getUuid());
BluetoothGattDescriptor descriptor = characteristic.getDescriptor(UUID.fromString(HM10Attributes.CLIENT_CHARACTERISTIC_CONFIG));
Log.w(TAG, "Descriptor found: " + descriptor.getUuid());
descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
mBluetoothGatt.writeDescriptor(descriptor);
}
public void setCharacteristicIndication(BluetoothGattCharacteristic characteristic){ setCharacteristicIndication(characteristic, true);}
public void setCharacteristicIndication(BluetoothGattCharacteristic characteristic, boolean enabled) {
Log.w(TAG, "Characteristic setting notification");
mBluetoothGatt.setCharacteristicNotification(characteristic, enabled);
Log.w(TAG, "UUID FOUND: " + characteristic.getUuid());
BluetoothGattDescriptor descriptor = characteristic.getDescriptor(UUID.fromString(HM10Attributes.CLIENT_CHARACTERISTIC_CONFIG));
Log.w(TAG, "Descriptor found: " + descriptor.getUuid());
descriptor.setValue(BluetoothGattDescriptor.ENABLE_INDICATION_VALUE);
mBluetoothGatt.writeDescriptor(descriptor);
}
private final BroadcastReceiver mPairReceiver = new BroadcastReceiver() {
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (BluetoothDevice.ACTION_BOND_STATE_CHANGED.equals(action)) {
final int state = intent.getIntExtra(BluetoothDevice.EXTRA_BOND_STATE, BluetoothDevice.ERROR);
final int prevState = intent.getIntExtra(BluetoothDevice.EXTRA_PREVIOUS_BOND_STATE, BluetoothDevice.ERROR);
if (state == BluetoothDevice.BOND_BONDED) {
Log.d(TAG, "CALLBACK RECIEVED Bonded");
currentGattTask = GATT_SETUP;
mBluetoothGatt.discoverServices();
} else if (state == BluetoothDevice.BOND_NONE){
Log.d(TAG, "CALLBACK RECIEVED: Not Bonded");
Toast.makeText(getApplicationContext(), "unBonded", Toast.LENGTH_LONG).show();
} else if (state == BluetoothDevice.BOND_BONDING) {
Log.d(TAG, "CALLBACK RECIEVED: Trying to bond");
Toast.makeText(getApplicationContext(), "trying to bond", Toast.LENGTH_LONG).show();
}
}
}
};
public void writeCommand(List packets, int aRecordType, Action1 dataResponseListener) {
mDataResponseListener = dataResponseListener;
successfulWrites = 0;
writePackets = packets;
recordType = aRecordType;
step = 0;
currentGattTask = GATT_WRITING_COMMANDS;
gattWritingStep();
}
private void nextGattStep() {
Log.d(TAG, "Next Gatt Step");
step++;
switch (currentGattTask) {
case GATT_NOTHING:
Log.d(TAG, "Next NOTHING: " + step);
break;
case GATT_SETUP:
Log.d(TAG, "Next GATT SETUP: " + step);
gattSetupStep();
break;
case GATT_WRITING_COMMANDS:
Log.d(TAG, "Next GATT WRITING: " + step);
gattWritingStep();
break;
}
}
public void clearGattTask() {
currentGattTask = GATT_NOTHING;
step = 0;
}
private void gattSetupStep() {
step = 1;
assignCharacteristics();
setListeners(1);
}
private void gattWritingStep() {
Log.d(TAG, "Writing command to the Gatt, step: " + step);
int index = step;
if (index <= (writePackets.size() - 1)) {
Log.d(TAG, "Writing: " + writePackets.get(index) + " index: " + index);
mSendDataCharacteristic.setValue(writePackets.get(index));
mBluetoothGatt.writeCharacteristic(mSendDataCharacteristic);
} else {
clearGattTask();
}
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/StartNewSensor.java
================================================
package com.eveningoutpost.dexdrip;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.support.v4.widget.DrawerLayout;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.Button;
import android.widget.DatePicker;
import android.widget.TimePicker;
import android.widget.Toast;
import com.eveningoutpost.dexdrip.UtilityModels.CollectionServiceStarter;
import java.util.Calendar;
import java.util.List;
public class StartNewSensor extends Activity implements NavigationDrawerFragment.NavigationDrawerCallbacks {
private String menu_name = "Start Sensor";
private NavigationDrawerFragment mNavigationDrawerFragment;
public Button button;
public DatePicker dp;
public TimePicker tp;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if(Sensor.isActive() == false) {
setContentView(R.layout.activity_start_new_sensor);
button = (Button)findViewById(R.id.startNewSensor);
dp = (DatePicker)findViewById(R.id.datePicker);
tp = (TimePicker)findViewById(R.id.timePicker);
addListenerOnButton();
} else {
Intent intent = new Intent(this, StopSensor.class);
startActivity(intent);
finish();
}
}
@Override
protected void onResume(){
super.onResume();
NavigationDrawerFragment mNavigationDrawerFragment;
mNavigationDrawerFragment = (NavigationDrawerFragment) getFragmentManager().findFragmentById(R.id.navigation_drawer);
mNavigationDrawerFragment.setUp(R.id.navigation_drawer, (DrawerLayout) findViewById(R.id.drawer_layout), menu_name, this);
}
@Override
public void onNavigationDrawerItemSelected(int position) {
NavDrawerBuilder navDrawerBuilder = new NavDrawerBuilder(getApplicationContext());
List menu_option_list = navDrawerBuilder.nav_drawer_options;
int menu_position = menu_option_list.indexOf(menu_name);
if (position != menu_position) {
List intent_list = navDrawerBuilder.nav_drawer_intents;
Intent[] intent_array = intent_list.toArray(new Intent[intent_list.size()]);
startActivity(intent_array[position]);
finish();
}
}
public void addListenerOnButton() {
button = (Button)findViewById(R.id.startNewSensor);
button.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
Calendar calendar = Calendar.getInstance();
calendar.set(dp.getYear(), dp.getMonth(), dp.getDayOfMonth(),
tp.getCurrentHour(), tp.getCurrentMinute(), 0);
long startTime = calendar.getTime().getTime();
Sensor sensor = Sensor.create(startTime);
Log.w("NEW SENSOR", "Sensor started at " + startTime);
Toast.makeText(getApplicationContext(), "NEW SENSOR STARTED", Toast.LENGTH_LONG).show();
Intent intent = new Intent(getApplicationContext(), Home.class);
CollectionServiceStarter.newStart(getApplicationContext());
startActivity(intent);
finish();
}
});
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/StopSensor.java
================================================
package com.eveningoutpost.dexdrip;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.support.v4.widget.DrawerLayout;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;
import java.util.Date;
public class StopSensor extends Activity implements NavigationDrawerFragment.NavigationDrawerCallbacks {
private String menu_name = "Stop Sensor";
private NavigationDrawerFragment mNavigationDrawerFragment;
public Button button;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if(Sensor.isActive() == false) {
Intent intent = new Intent(this, StartNewSensor.class);
startActivity(intent);
finish();
} else {
setContentView(R.layout.activity_stop_sensor);
button = (Button)findViewById(R.id.stop_sensor);
addListenerOnButton();
}
}
@Override
protected void onResume(){
super.onResume();
mNavigationDrawerFragment = (NavigationDrawerFragment) getFragmentManager().findFragmentById(R.id.navigation_drawer);
mNavigationDrawerFragment.setUp(R.id.navigation_drawer, (DrawerLayout) findViewById(R.id.drawer_layout), menu_name, this);
}
@Override
public void onNavigationDrawerItemSelected(int position) {
mNavigationDrawerFragment.swapContext(position);
}
public void addListenerOnButton() {
button = (Button)findViewById(R.id.stop_sensor);
button.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
Sensor sensor = Sensor.currentSensor();
sensor.stopped_at = new Date().getTime();
Log.w("NEW SENSOR", "Sensor stopped at " + sensor.stopped_at);
sensor.save();
Toast.makeText(getApplicationContext(), "Sensor stopped", Toast.LENGTH_LONG).show();
Intent intent = new Intent(getApplicationContext(), Home.class);
startActivity(intent);
finish();
}
});
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/SystemStatus.java
================================================
package com.eveningoutpost.dexdrip;
import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothManager;
import android.bluetooth.BluetoothProfile;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.support.v4.widget.DrawerLayout;
import android.text.TextUtils;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ImageButton;
import android.widget.TextView;
import com.eveningoutpost.dexdrip.Models.ActiveBluetoothDevice;
import com.eveningoutpost.dexdrip.Models.Calibration;
import com.eveningoutpost.dexdrip.UtilityModels.CollectionServiceStarter;
import java.lang.reflect.Method;
public class SystemStatus extends Activity implements NavigationDrawerFragment.NavigationDrawerCallbacks {
private String menu_name = "System Status";
private NavigationDrawerFragment mNavigationDrawerFragment;
public TextView collection_method;
public TextView current_device;
public TextView connection_status;
public TextView notes;
public Button restart_collection_service;
public Button forget_device;
public ImageButton refresh;
public SharedPreferences prefs;
public BluetoothManager mBluetoothManager;
public ActiveBluetoothDevice activeBluetoothDevice;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_system_status);
prefs = PreferenceManager.getDefaultSharedPreferences(getApplicationContext());
mNavigationDrawerFragment = (NavigationDrawerFragment) getFragmentManager().findFragmentById(R.id.navigation_drawer);
mNavigationDrawerFragment.setUp(R.id.navigation_drawer, (DrawerLayout) findViewById(R.id.drawer_layout), menu_name, this);
collection_method = (TextView)findViewById(R.id.collection_method);
connection_status = (TextView)findViewById(R.id.connection_status);
current_device = (TextView)findViewById(R.id.remembered_device);
notes = (TextView)findViewById(R.id.other_notes);
restart_collection_service = (Button)findViewById(R.id.restart_collection_service);
forget_device = (Button)findViewById(R.id.forget_device);
refresh = (ImageButton)findViewById(R.id.refresh_current_values);
set_current_values();
restartButtonListener();
forgetDeviceListener();
refreshButtonListener();
}
@Override
public void onNavigationDrawerItemSelected(int position) {
mNavigationDrawerFragment.swapContext(position);
}
private void set_current_values() {
activeBluetoothDevice = ActiveBluetoothDevice.first();
mBluetoothManager = (BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);
setCollectionMethod();
setCurrentDevice();
setConnectionStatus();
setNotes();
}
public void setCollectionMethod() {
collection_method.setText(prefs.getString("dex_collection_method", "BluetoothWixel"));
}
public void setCurrentDevice() {
if(activeBluetoothDevice != null) {
current_device.setText(activeBluetoothDevice.name);
} else {
current_device.setText("None Set");
}
}
public void setConnectionStatus() {
boolean connected = false;
if (mBluetoothManager != null && activeBluetoothDevice != null) {
for (BluetoothDevice bluetoothDevice : mBluetoothManager.getConnectedDevices(BluetoothProfile.GATT)) {
if (bluetoothDevice.getAddress().compareTo(activeBluetoothDevice.address) == 0) {
connected = true;
}
}
}
if(connected) {
connection_status.setText("Connected");
} else {
connection_status.setText("Not Connected");
}
}
public void setNotes() {
if(mBluetoothManager == null) {
notes.append("\n- This device does not seem to support bluetooth");
} else {
if(!mBluetoothManager.getAdapter().isEnabled()) {
notes.append("\n- Bluetooth seems to be turned off");
} else {
if(android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.JELLY_BEAN_MR2){
notes.append("\n- The android version of this device is not compatible with Bluetooth Low Energy");
}
}
}
}
public void restartButtonListener() {
restart_collection_service.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
CollectionServiceStarter.restartCollectionService(getApplicationContext());
set_current_values();
}
});
}
public void forgetDeviceListener() {
forget_device.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
if(mBluetoothManager != null && ActiveBluetoothDevice.first() != null) {
BluetoothAdapter bluetoothAdapter = mBluetoothManager.getAdapter();
if(bluetoothAdapter != null) {
for( BluetoothDevice bluetoothDevice : bluetoothAdapter.getBondedDevices()) {
if(bluetoothDevice.getAddress().compareTo(ActiveBluetoothDevice.first().address) == 0) {
try {
Method m = bluetoothDevice.getClass().getMethod("removeBond", (Class[]) null);
m.invoke(bluetoothDevice, (Object[]) null);
notes.append("\n- Bluetooth unbonded, if using share tell it to forget your device.");
notes.append("\n- Scan for devices again to set connection back up!");
} catch (Exception e) { Log.e("SystemStatus", e.getMessage()); }
}
}
ActiveBluetoothDevice.forget();
bluetoothAdapter.disable();
bluetoothAdapter.enable();
try {
wait(1000);
} catch(Exception e) {
Log.e("SystemStatus", "Error stalling");
}
}
}
CollectionServiceStarter.restartCollectionService(getApplicationContext());
set_current_values();
}
});
}
public void refreshButtonListener() {
refresh.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
set_current_values();
}
});
}
}
================================================
FILE: app/src/main/java/com/eveningoutpost/dexdrip/Tables/BgReadingTable.java
================================================
package com.eveningoutpost.dexdrip.Tables;
import android.app.ListActivity;
import android.content.Context;
import android.database.Cursor;
import android.os.Bundle;
import android.support.v4.widget.DrawerLayout;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.ListAdapter;
import android.widget.TextView;
import com.eveningoutpost.dexdrip.Models.BgReading;
import com.eveningoutpost.dexdrip.NavigationDrawerFragment;
import com.eveningoutpost.dexdrip.R;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
public class BgReadingTable extends ListActivity implements NavigationDrawerFragment.NavigationDrawerCallbacks {
private String menu_name = "BG Data Table";
private NavigationDrawerFragment mNavigationDrawerFragment;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.raw_data_list);
}
@Override
protected void onResume() {
super.onResume();
mNavigationDrawerFragment = (NavigationDrawerFragment) getFragmentManager().findFragmentById(R.id.navigation_drawer);
mNavigationDrawerFragment.setUp(R.id.navigation_drawer, (DrawerLayout) findViewById(R.id.drawer_layout), menu_name, this);
getData();
}
@Override
public void onNavigationDrawerItemSelected(int position) {
mNavigationDrawerFragment.swapContext(position);
}
private void getData() {
final List latest = BgReading.latest(50);
ListAdapter adapter = new BgReadingAdapter(this, latest);
this.setListAdapter(adapter);
}
public static class BgReadingCursorAdapterViewHolder {
TextView raw_data_id;
TextView raw_data_value;
TextView raw_data_slope;
TextView raw_data_timestamp;
public BgReadingCursorAdapterViewHolder(View root) {
raw_data_id = (TextView) root.findViewById(R.id.raw_data_id);
raw_data_value = (TextView) root.findViewById(R.id.raw_data_value);
raw_data_slope = (TextView) root.findViewById(R.id.raw_data_slope);
raw_data_timestamp = (TextView) root.findViewById(R.id.raw_data_timestamp);
}
}
public static class BgReadingAdapter extends BaseAdapter {
private final Context context;
private final List readings;
public BgReadingAdapter(Context context, List
***
================================================
FILE: app/.gitignore
================================================
/build
================================================
FILE: app/app.iml
================================================