Haroon6138
/
PatientApp-KKUMC
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Completed the oxymeter category

Browse Source
dev_3.3_BLE
Faiz Hashmi 2 years ago
parent 0a700270f4
commit 70ca4071fc
29 changed files with 1055 additions and 312 deletions
Show Stats Download Patch File Download Diff File

445
android/app/src/main/kotlin/com/cloud/diplomaticquarterapp/ble/BleBridge.kt
Unescape Escape View File

@ -10,13 +10,13 @@ import io.flutter.plugin.common.MethodChannel
import io.flutter.plugin.common.EventChannel
import android.util.SparseArray
import androidx.annotation.RequiresApi
import com.cloud.diplomaticquarterapp.ble.OxymeterModel
import com.cloud.diplomaticquarterapp.ble.utils.EcgData
import com.google.gson.Gson
//Ble
import com.jeremyliao.liveeventbus.LiveEventBus
import com.lepu.blepro.constants.Constant
import com.lepu.blepro.event.EventMsgConst
import com.lepu.blepro.event.EventMsgConst.Ble.*
import com.lepu.blepro.event.InterfaceEvent
@ -31,15 +31,11 @@ import com.lepu.blepro.ext.er2.Er2File
import com.lepu.blepro.ext.er2.RtData
import com.lepu.blepro.ext.bp2.*
import com.lepu.blepro.ext.pc60fw.RtParam
import com.lepu.blepro.ext.sp20.GetConfigResult
import com.lepu.blepro.ext.sp20.RtWave
import com.lepu.blepro.ext.sp20.SetConfigResult
import com.lepu.blepro.ext.sp20.TempResult
import com.lepu.blepro.objs.Bluetooth
import com.lepu.blepro.objs.BluetoothController
import com.lepu.blepro.utils.DateUtil
import com.lepu.blepro.utils.Er1Decompress
import kotlin.reflect.KFunction2
class BleBridge(private var flutterEngine: FlutterEngine, private var mainActivity: MainActivity) {
@ -58,6 +54,7 @@ class BleBridge(private var flutterEngine: FlutterEngine, private var mainActivi
private const val CHANNEL = "BLE-Platform-Bridge"
private const val EVENTCHANNEL = "BLE-Platform-Bridge-Event"
private const val SCAN_DEVICE = "scan"
private const val CONNECT_DEVICE = "connectDevice"
private const val SCAN_DEVICE_EKG = "scan_ekg"
private const val EKG_FILES_LIST = "ekg_files_list"
private const val BP2_FILES_LIST = "bp2_files_list"
@ -171,7 +168,9 @@ class BleBridge(private var flutterEngine: FlutterEngine, private var mainActivi
channel.setMethodCallHandler { methodCall: MethodCall, result: MethodChannel.Result ->
if (methodCall.method == SCAN_DEVICE) {
scanDevice(methodCall, result)
scanDevice()
} else if (methodCall.method == CONNECT_DEVICE) {
connectDevice(methodCall.arguments as List<String>)
} else if (methodCall.method == DISCONNECT_DEVICE) {
disconnectDevice(methodCall, result)
} else if (methodCall.method == SCAN_DEVICE_EKG) {
@ -201,6 +200,7 @@ class BleBridge(private var flutterEngine: FlutterEngine, private var mainActivi
}
@RequiresApi(Build.VERSION_CODES.Q)
fun disconnectDevice(methodCall: MethodCall, result: MethodChannel.Result) {
if (rtHandler.hasCallbacks(rtTask)) rtHandler.removeCallbacks(rtTask)
@ -208,7 +208,7 @@ class BleBridge(private var flutterEngine: FlutterEngine, private var mainActivi
}
private fun scanDevice(methodCall: MethodCall, result: MethodChannel.Result) {
private fun scanDevice() {
LiveEventBus.get<Boolean>(EventMsgConst.Ble.EventServiceConnectedAndInterfaceInit).observe(this.mainActivity) {
@ -218,274 +218,285 @@ class BleBridge(private var flutterEngine: FlutterEngine, private var mainActivi
println("EventServiceConnectedAndInterfaceInit")
}
LiveEventBus.get<Boolean>(EventMsgConst.Ble.EventServiceConnectedAndInterfaceInit).observe(this.mainActivity) {
// BleService init success
println("EventServiceConnectedAndInterfaceInit---------")
BleServiceHelper.BleServiceHelper.startScan(models)
println("EventServiceConnectedAndInterfaceInit")
}
LiveEventBus.get<Bluetooth>(EventMsgConst.Discovery.EventDeviceFound).observe(this.mainActivity) {
var deviceName: String = ""
for (b in BluetoothController.getDevices()) {
println(b.name)
//TODO: UNCOMMENT THIS
// if (b.name.contains("POD-1_SN8187", true) || b.name.contains(
// "O2M 1670", true
// ) || b.name.contains("DuoEK", true) || b.name.contains("BP2", true) || b.name.contains("SP-20", true)
// ) {
if (b.name.contains("SP-20", true)) {
model = b.model
deviceName = b.name
BleServiceHelper.BleServiceHelper.setInterfaces(b.model)
BleServiceHelper.BleServiceHelper.stopScan()
BleServiceHelper.BleServiceHelper.connect(
this.mainActivity.applicationContext, b.model, b.device
)
}
}
val deviceName: String = ""
val returnData = mapOf("type" to "devicesList", "data" to gson.toJson(BluetoothController.getDevices()))
println("devicesList: ${BluetoothController.getDevices()}");
eventSink?.success(returnData)
println("EventDeviceFound")
println(deviceName)
if (deviceName == "POD-1_SN8187") {
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.PC60Fw.EventPC60FwRtParam).observe(this.mainActivity) {
val data = it.data as RtParam
println("OXY DATA POD-1W: $data")
eventSink?.success(data.toString())
}
}
}
val rawFolders = SparseArray<String>()
try {
BleServiceHelper.BleServiceHelper.initRawFolder(rawFolders).initService(this.mainActivity.application)
} catch (e: Exception) {
println(e)
}
}
if (deviceName.contains("DuoEK", ignoreCase = true)) {
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.ER2.EventEr2Info).observe(this.mainActivity) {
val data = it.data as DeviceInfo
println("DuoEK INFO DATA: $data")
val returnData = mapOf("type" to "infoData", "data" to data.toString())
eventSink?.success(returnData)
}
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.ER2.EventEr2FileList).observe(this.mainActivity) {
BleServiceHelper.BleServiceHelper.stopRtTask(model)
ecgFileNames = it.data as ArrayList<String>
readFile()
@RequiresApi(Build.VERSION_CODES.Q)
private fun subscribeToStreams(deviceName: String) {
// ECG TRACKER
if (deviceName.contains("DuoEK", ignoreCase = true)) {
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.ER2.EventEr2Info).observe(this.mainActivity) {
val data = it.data as DeviceInfo
println("DuoEK INFO DATA: $data")
val returnData = mapOf("type" to "infoData", "data" to data.toString())
eventSink?.success(returnData)
}
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.ER2.EventEr2FileList).observe(this.mainActivity) {
BleServiceHelper.BleServiceHelper.stopRtTask(model)
ecgFileNames = it.data as ArrayList<String>
readFile()
// val fileNames = it.data as ArrayList<String>
// println("DuoEK FileNames List: ${fileNames}")
// val returnData =
// mapOf("type" to "fileList", "data" to fileNames)
// eventSink?.success(returnData)
}
}
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.ER2.EventEr2SetTime).observe(this.mainActivity) {
println("EventEr2SetTime")
// Get Device Info
BleServiceHelper.BleServiceHelper.er2GetInfo(model)
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.ER2.EventEr2SetTime).observe(this.mainActivity) {
println("EventEr2SetTime")
// Get Device Info
BleServiceHelper.BleServiceHelper.er2GetInfo(model)
// ecgRTTask.run()
}
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.ER2.EventEr2ReadFileComplete).observe(this.mainActivity) {
println("EventEr2ReadFileComplete")
val data = it.data as Er2File
if (data.fileName.contains("R")) {
val file = Er2EcgFile(data.content)
val ecgShorts = Er1Decompress.unCompressAlgECG(file.waveData)
val ecgData = EcgData()
val startTime = DateUtil.getSecondTimestamp(data.fileName.replace("R", ""))
ecgData.fileName = data.fileName
ecgData.duration = file.recordingTime
ecgData.shortData = ecgShorts
ecgData.startTime = startTime
ecgList.add(ecgData)
print(ecgList)
}
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.ER2.EventEr2ReadFileComplete).observe(this.mainActivity) {
println("EventEr2ReadFileComplete")
val data = it.data as Er2File
if (data.fileName.contains("R")) {
val file = Er2EcgFile(data.content)
val ecgShorts = Er1Decompress.unCompressAlgECG(file.waveData)
val ecgData = EcgData()
val startTime = DateUtil.getSecondTimestamp(data.fileName.replace("R", ""))
ecgData.fileName = data.fileName
ecgData.duration = file.recordingTime
ecgData.shortData = ecgShorts
ecgData.startTime = startTime
ecgList.add(ecgData)
print(ecgList)
// val returnData =
// mapOf("type" to "fileDetail", "data" to gson.toJson(ecgList))
// eventSink?.success(returnData)
}
ecgFileNames.removeAt(0)
readFile()
}
ecgFileNames.removeAt(0)
readFile()
}
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.ER2.EventEr2RtData).observe(this.mainActivity) {
val data = it.data as RtData
println("EventEr2RtData")
val returnData = mapOf("type" to "realtimeDataECG", "data" to gson.toJson(data))
println(returnData)
eventSink?.success(returnData)
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.ER2.EventEr2RtData).observe(this.mainActivity) {
val data = it.data as RtData
println("EventEr2RtData")
val returnData = mapOf("type" to "realtimeDataECG", "data" to gson.toJson(data))
println(returnData)
eventSink?.success(returnData)
// DataController.receive(data.wave.ecgFloats)
// hr.text = "${data.param.hr}"
// data_log.text = "${data.param}"
// sampling rate：125HZ
// mV = n * 0.002467（data.wave.ecgFloats = data.wave.ecgShorts * 0.002467）
// data.param.batteryState：0（no charge），1（charging），2（charging complete），3（low battery）
// data.param.battery：0-100
// data.param.recordTime：unit（s）
// data.param.curStatus：0（idle），1（preparing），2（measuring），3（saving file），4（saving succeed），
// 5（less than 30s, file not saved），6（6 retests），7（lead off）
}
// sampling rate：125HZ
// mV = n * 0.002467（data.wave.ecgFloats = data.wave.ecgShorts * 0.002467）
// data.param.batteryState：0（no charge），1（charging），2（charging complete），3（low battery）
// data.param.battery：0-100
// data.param.recordTime：unit（s）
// data.param.curStatus：0（idle），1（preparing），2（measuring），3（saving file），4（saving succeed），
// 5（less than 30s, file not saved），6（6 retests），7（lead off）
}
}
// OXYMETER
if (deviceName == "POD-1_SN8187" || deviceName == "PC-60FW") { //DONE
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.PC60Fw.EventPC60FwRtParam).observe(this.mainActivity) {
val data = it.data as RtParam
println("POD-1_SN8187: $data")
println("PC-60FW: $data")
val oxyModel = OxymeterModel(data.spo2, data.pr, data.pi, data.isProbeOff, data.isPulseSearching, true, 100);
val returnData = mapOf("type" to "OxyRtParam", "data" to gson.toJson(oxyModel))
eventSink?.success(returnData)
}
}
if (deviceName == "O2M 1670") {
rtHandler.removeCallbacks(rtTask)
rtHandler.post(rtTask)
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.Oxy.EventOxyRtParamData).observe(this.mainActivity) {
val data = it.data as com.lepu.blepro.ext.oxy.RtParam
println("OXY DATA O2M: $data")
eventSink?.success(data.toString())
// tv_oxy.text = data.spo2.toString()
// tv_pr.text = data.pr.toString()
// tv_pi.text = data.pi.toString()
// data_log.text = "$data"
// data.battery：0-100
// data.batteryState：0（no charge），1（charging），2（charging complete）
// data.state：0（lead off），1（lead on），other（error）
}
if (deviceName == "O2M 1670" || deviceName == "O2Ring 4135") { // DONE
rtHandler.removeCallbacks(rtTask)
rtHandler.post(rtTask)
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.Oxy.EventOxyRtParamData).observe(this.mainActivity) {
val data = it.data as com.lepu.blepro.ext.oxy.RtParam
println("O2M 1670: $data")
println("O2Ring 4135: $data")
val oxyModel = OxymeterModel(data.spo2, data.pr, data.pi, false, true, true, data.battery);
val returnData = mapOf("type" to "OxyRtParam", "data" to gson.toJson(oxyModel))
eventSink?.success(returnData)
}
}
if (deviceName.contains("BP2", ignoreCase = true)) {
if (deviceName.contains("SP-20", ignoreCase = true)) { //DONE
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.BP2.EventBp2SyncTime).observe(this.mainActivity) {
println("EventBp2SyncTime")
// Get Device Info
BleServiceHelper.BleServiceHelper.bp2GetInfo(model)
}
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.SP20.EventSp20SetTime).observe(this.mainActivity) {
println("EventSp20SetTime")
BleServiceHelper.BleServiceHelper.bp2GetInfo(model)
}
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.BP2.EventBp2Info).observe(this.mainActivity) {
val data = it.data as com.lepu.blepro.ext.bp2.DeviceInfo
println("BP2 INFO DATA: $data")
val returnData = mapOf("type" to "infoData", "data" to data.toString(), "deviceName" to deviceName)
eventSink?.success(returnData)
BleServiceHelper.BleServiceHelper.startRtTask(model)
}
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.SP20.EventSp20DeviceInfo).observe(this.mainActivity) {
val data = it.data as com.lepu.blepro.ext.sp20.DeviceInfo
println("EventSp20DeviceInfo: $data")
val returnData = mapOf("type" to "infoData", "data" to data.toString(), "deviceName" to deviceName)
eventSink?.success(returnData)
BleServiceHelper.BleServiceHelper.startRtTask(model)
}
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.BP2.EventBp2FileList).observe(this.mainActivity) {
bpFileNames = it.data as ArrayList<String>
}
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.SP20.EventSp20RtParam).observe(this.mainActivity) {
val data = it.data as com.lepu.blepro.ext.sp20.RtParam
println("OxyRtParam: $data")
val oxyModel = OxymeterModel(data.spo2, data.pr, data.pi, data.isProbeOff, data.isPulseSearching, data.isCheckProbe, data.battery);
val returnData = mapOf("type" to "OxyRtParam", "data" to gson.toJson(oxyModel))
eventSink?.success(returnData)
}
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.SP20.EventSp20RtWave).observe(this.mainActivity) {
val data = it.data as RtWave
println("OxyRtParam: $data")
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.BP2.EventBp2ReadFileComplete).observe(this.mainActivity) {
val data = it.data as Bp2File
// data.type: 1(BP), 2(ECG)
println("LiveEventBus with BP2 : $data")
if (data.type == 1) {
val file = BpFile(data.content)
// file.measureTime：unit（s）
println("BpFile : $file")
} else if (data.type == 2) {
val file = EcgFile(data.content)
val ecgData = EcgData()
val startTime = DateUtil.getSecondTimestamp(data.fileName)
ecgData.fileName = data.fileName
ecgData.duration = file.recordingTime
ecgData.shortData = Er1Decompress.unCompressAlgECG(file.waveData)
// ecgData.shortData = FilterUtil.getEcgFileFilterData(it.model, data.content)
ecgData.startTime = startTime
ecgList.add(ecgData)
// sampling rate：125HZ
// mV = file.waveShortData * 0.003098
// file.measureTime：unit（s）
// file.recordingTime：unit（s）
// file.connectCable: Whether the cable is connected
// file.diagnosis：EcgDiagnosis
// diagnosis.isRegular：Whether Regular ECG Rhythm
// diagnosis.isPoorSignal：Whether Unable to analyze
// diagnosis.isLeadOff：Whether Always lead off
// diagnosis.isFastHr：Whether Fast Heart Rate
// diagnosis.isSlowHr：Whether Slow Heart Rate
// diagnosis.isIrregular：Whether Irregular ECG Rhythm
// diagnosis.isPvcs：Whether Possible ventricular premature beats
// diagnosis.isHeartPause：Whether Possible heart pause
// diagnosis.isFibrillation：Whether Possible Atrial fibrillation
// diagnosis.isWideQrs：Whether Wide QRS duration
// diagnosis.isProlongedQtc：Whether QTc is prolonged
// diagnosis.isShortQtc：Whether QTc is short
println("EcgFile : $file")
}
bpFileNames.removeAt(0)
readFileForBp2()
}
}
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.BP2.EventBp2RtData).observe(this.mainActivity) {
val data = it.data as com.lepu.blepro.ext.bp2.RtData
// data.status: RtStatus
// data.status.deviceStatus: 0(STATUS_SLEEP), 1(STATUS_MEMERY), 2(STATUS_CHARGE), 3(STATUS_READY),
// 4(STATUS_BP_MEASURING), 5(STATUS_BP_MEASURE_END),
// 6(STATUS_ECG_MEASURING), 7(STATUS_ECG_MEASURE_END), 20(STATUS_VEN)
// data.status.batteryStatus: 0(no charge), 1(charging), 2(charging complete), 3(low battery)
// data.status.percent: 0-100
// data.param: RtParam
// data.param.paramDataType: 0(Bp measuring), 1(Bp end), 2(Ecg measuring), 3(Ecg end)
}
when (data.param.paramDataType) {
0 -> {
val bpIng = RtBpIng(data.param.paramData)
val returnData = mapOf("type" to "RealTimeDataBP2Measuring", "data" to gson.toJson(bpIng))
eventSink?.success(returnData)
//BLOOD PRESSURE
if (deviceName.contains("BP2", ignoreCase = true)) {
}
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.BP2.EventBp2SyncTime).observe(this.mainActivity) {
println("EventBp2SyncTime")
// Get Device Info
BleServiceHelper.BleServiceHelper.bp2GetInfo(model)
}
1 -> {
val bpResult = RtBpResult(data.param.paramData)
val returnData = mapOf("type" to "RealTimeDataBP2Result", "data" to gson.toJson(bpResult))
println("RealTimeDataBP2Result FOR BP : $returnData")
eventSink?.success(returnData)
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.BP2.EventBp2Info).observe(this.mainActivity) {
val data = it.data as com.lepu.blepro.ext.bp2.DeviceInfo
println("BP2 INFO DATA: $data")
val returnData = mapOf("type" to "infoData", "data" to data.toString(), "deviceName" to deviceName)
eventSink?.success(returnData)
BleServiceHelper.BleServiceHelper.startRtTask(model)
}
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.BP2.EventBp2FileList).observe(this.mainActivity) {
bpFileNames = it.data as ArrayList<String>
}
}
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.BP2.EventBp2ReadFileComplete).observe(this.mainActivity) {
val data = it.data as Bp2File
// data.type: 1(BP), 2(ECG)
println("LiveEventBus with BP2 : $data")
if (data.type == 1) {
val file = BpFile(data.content)
// file.measureTime：unit（s）
println("BpFile : $file")
} else if (data.type == 2) {
val file = EcgFile(data.content)
val ecgData = EcgData()
val startTime = DateUtil.getSecondTimestamp(data.fileName)
ecgData.fileName = data.fileName
ecgData.duration = file.recordingTime
ecgData.shortData = Er1Decompress.unCompressAlgECG(file.waveData)
// ecgData.shortData = FilterUtil.getEcgFileFilterData(it.model, data.content)
ecgData.startTime = startTime
ecgList.add(ecgData)
// sampling rate：125HZ
// mV = file.waveShortData * 0.003098
// file.measureTime：unit（s）
// file.recordingTime：unit（s）
// file.connectCable: Whether the cable is connected
// file.diagnosis：EcgDiagnosis
// diagnosis.isRegular：Whether Regular ECG Rhythm
// diagnosis.isPoorSignal：Whether Unable to analyze
// diagnosis.isLeadOff：Whether Always lead off
// diagnosis.isFastHr：Whether Fast Heart Rate
// diagnosis.isSlowHr：Whether Slow Heart Rate
// diagnosis.isIrregular：Whether Irregular ECG Rhythm
// diagnosis.isPvcs：Whether Possible ventricular premature beats
// diagnosis.isHeartPause：Whether Possible heart pause
// diagnosis.isFibrillation：Whether Possible Atrial fibrillation
// diagnosis.isWideQrs：Whether Wide QRS duration
// diagnosis.isProlongedQtc：Whether QTc is prolonged
// diagnosis.isShortQtc：Whether QTc is short
println("EcgFile : $file")
}
bpFileNames.removeAt(0)
readFileForBp2()
}
}
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.BP2.EventBp2RtData).observe(this.mainActivity) {
val data = it.data as com.lepu.blepro.ext.bp2.RtData
// data.status: RtStatus
// data.status.deviceStatus: 0(STATUS_SLEEP), 1(STATUS_MEMERY), 2(STATUS_CHARGE), 3(STATUS_READY),
// 4(STATUS_BP_MEASURING), 5(STATUS_BP_MEASURE_END),
// 6(STATUS_ECG_MEASURING), 7(STATUS_ECG_MEASURE_END), 20(STATUS_VEN)
// data.status.batteryStatus: 0(no charge), 1(charging), 2(charging complete), 3(low battery)
// data.status.percent: 0-100
// data.param: RtParam
// data.param.paramDataType: 0(Bp measuring), 1(Bp end), 2(Ecg measuring), 3(Ecg end)
when (data.param.paramDataType) {
0 -> {
val bpIng = RtBpIng(data.param.paramData)
}
val returnData = mapOf("type" to "RealTimeDataBP2Measuring", "data" to gson.toJson(bpIng))
eventSink?.success(returnData)
}
}
if (deviceName.contains("SP-20", ignoreCase = true)) {
1 -> {
val bpResult = RtBpResult(data.param.paramData)
val returnData = mapOf("type" to "RealTimeDataBP2Result", "data" to gson.toJson(bpResult))
println("RealTimeDataBP2Result FOR BP : $returnData")
eventSink?.success(returnData)
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.SP20.EventSp20SetTime).observe(this.mainActivity) {
println("EventSp20SetTime")
BleServiceHelper.BleServiceHelper.bp2GetInfo(model)
}
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.SP20.EventSp20DeviceInfo).observe(this.mainActivity) {
val data = it.data as com.lepu.blepro.ext.sp20.DeviceInfo
println("EventSp20DeviceInfo: $data")
val returnData = mapOf("type" to "infoData", "data" to data.toString(), "deviceName" to deviceName)
eventSink?.success(returnData)
BleServiceHelper.BleServiceHelper.startRtTask(model)
}
}
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.SP20.EventSp20RtParam).observe(this.mainActivity) {
val data = it.data as com.lepu.blepro.ext.sp20.RtParam
println("EventSp20RtParam: $data")
val returnData = mapOf("type" to "EventSp20RtParam", "data" to gson.toJson(data))
eventSink?.success(returnData)
}
LiveEventBus.get<InterfaceEvent>(InterfaceEvent.SP20.EventSp20RtWave).observe(this.mainActivity) {
val data = it.data as RtWave
println("EventSp20RtWave: $data")
}
}
}
val rawFolders = SparseArray<String>()
try {
BleServiceHelper.BleServiceHelper.initRawFolder(rawFolders).initService(this.mainActivity.application)
} catch (e: Exception) {
println(e)
}
private fun connectDevice(device: List<String>) {
println("connectDevice: $device");
model = device[1].toInt()
val deviceName = device[0]
for (b in BluetoothController.getDevices()) {
println("getDevices device: ${b.name}")
if (b.name == deviceName) {
BleServiceHelper.BleServiceHelper.setInterfaces(b.model)
// BleServiceHelper.BleServiceHelper.stopScan()
BleServiceHelper.BleServiceHelper.connect(
this.mainActivity.applicationContext, model, b.device
)
subscribeToStreams(deviceName);
}
}
}
private fun readFile() {
if (ecgFileNames.size == 0) {
val returnData = mapOf("type" to "fileDetail", "data" to gson.toJson(ecgList))

22
android/app/src/main/kotlin/com/cloud/diplomaticquarterapp/ble/OxymeterModel.java
Unescape Escape View File

@ -0,0 +1,22 @@
package com.cloud.diplomaticquarterapp.ble;
public class OxymeterModel {
public int spo2;
public int pr;
public float pi;
public boolean isProbeOff;
public boolean isPulseSearching;
public boolean isCheckProbe;
public int battery;
public OxymeterModel(int spo2, int pr, float pi, boolean isProbeOff, boolean isPulseSearching, boolean isCheckProbe, int battery) {
this.spo2 = spo2;
this.pr = pr;
this.pi = pi;
this.isProbeOff = isProbeOff;
this.isPulseSearching = isPulseSearching;
this.isCheckProbe = isCheckProbe;
this.battery = battery;
}
}

8
lib/main.dart
Unescape Escape View File

@ -3,6 +3,7 @@ import 'dart:io';
import 'package:diplomaticquarterapp/core/viewModels/PharmacyPagesViewModel.dart';
import 'package:diplomaticquarterapp/core/viewModels/dashboard_view_model.dart';
import 'package:diplomaticquarterapp/models/Appointments/toDoCountProviderModel.dart';
import 'package:diplomaticquarterapp/pages/medical/my_trackers/my_trackers_view_model/my_trackers_view_model.dart';
import 'package:diplomaticquarterapp/routes.dart';
import 'package:diplomaticquarterapp/services/robo_search/event_provider.dart';
import 'package:diplomaticquarterapp/services/robo_search/search_provider.dart';
@ -118,12 +119,15 @@ class _MyApp extends State<MyApp> {
),
ChangeNotifierProvider<CompareList>(create: (context) => CompareList()),
ChangeNotifierProvider<OrderPreviewViewModel>(create: (context) => OrderPreviewViewModel()),
ChangeNotifierProvider<MyTrackersViewModel>(create: (context) => MyTrackersViewModel()),
],
child: Consumer<ProjectViewModel>(
builder: (context, projectProvider, child) => MaterialApp(
builder: (BuildContext context, Widget child) {
builder: (BuildContext context, Widget child) {
return MediaQuery(
data: MediaQuery.of(context).copyWith(textScaleFactor: 1.0,), //set desired text scale factor here
data: MediaQuery.of(context).copyWith(
textScaleFactor: 1.0,
), //set desired text scale factor here
child: child,
);
},

24
lib/models/ble_devices/viatom_devices/bp_rt_data_measuring_model.dart
Unescape Escape View File

@ -1,24 +0,0 @@
class BpRtDataMeasuringModel {
bool deflate;
int pr;
int pressure;
bool pulse;
BpRtDataMeasuringModel({this.deflate, this.pr, this.pressure, this.pulse});
BpRtDataMeasuringModel.fromJson(Map<String, dynamic> json) {
deflate = json['deflate'];
pr = json['pr'];
pressure = json['pressure'];
pulse = json['pulse'];
}
Map<String, dynamic> toJson() {
final Map<String, dynamic> data = new Map<String, dynamic>();
data['deflate'] = this.deflate;
data['pr'] = this.pr;
data['pressure'] = this.pressure;
data['pulse'] = this.pulse;
return data;
}
}

33
lib/models/ble_devices/viatom_devices/bp_rt_data_result_model.dart
Unescape Escape View File

@ -1,33 +0,0 @@
class BpRtDataResultModel {
bool deflate;
int dia;
int mean;
int pr;
int pressure;
int result;
int sys;
BpRtDataResultModel({this.deflate, this.dia, this.mean, this.pr, this.pressure, this.result, this.sys});
BpRtDataResultModel.fromJson(Map<String, dynamic> json) {
deflate = json['deflate'];
dia = json['dia'];
mean = json['mean'];
pr = json['pr'];
pressure = json['pressure'];
result = json['result'];
sys = json['sys'];
}
Map<String, dynamic> toJson() {
final Map<String, dynamic> data = new Map<String, dynamic>();
data['deflate'] = this.deflate;
data['dia'] = this.dia;
data['mean'] = this.mean;
data['pr'] = this.pr;
data['pressure'] = this.pressure;
data['result'] = this.result;
data['sys'] = this.sys;
return data;
}
}

2
lib/pages/ble_screen.dart
Unescape Escape View File

@ -1,4 +1,4 @@
import 'package:diplomaticquarterapp/viatom_ble/ble_connect.dart';
import 'package:diplomaticquarterapp/pages/medical/my_trackers/ble_helpers/ble_connect_helper.dart';
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';

2
lib/pages/medical/medical_profile_page_new.dart
Unescape Escape View File

@ -15,7 +15,9 @@ import 'package:provider/provider.dart';
class MedicalProfilePageNew extends StatefulWidget {
Function onTap;
String a;
MedicalProfilePageNew({this.onTap});
@override
_MedicalProfilePageState createState() => _MedicalProfilePageState();
}

93
lib/pages/medical/my_trackers/ble_device_type_screens/ble_devices_screen.dart
Unescape Escape View File

@ -0,0 +1,93 @@
import 'dart:developer';
import 'package:diplomaticquarterapp/pages/medical/my_trackers/ble_device_type_screens/device_types/oxymeter_connect_screen.dart';
import 'package:diplomaticquarterapp/pages/medical/my_trackers/ble_models/ble_devices_model.dart';
import 'package:diplomaticquarterapp/pages/medical/my_trackers/my_trackers_view_model/my_trackers_view_model.dart';
import 'package:diplomaticquarterapp/widgets/data_display/medical/medical_profile_item.dart';
import 'package:diplomaticquarterapp/widgets/others/app_scaffold_widget.dart';
import 'package:diplomaticquarterapp/widgets/transitions/fade_page.dart';
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
class BleDevicesScreen extends StatefulWidget {
@override
State<BleDevicesScreen> createState() => _BleDevicesScreenState();
}
class _BleDevicesScreenState extends State<BleDevicesScreen> {
MyTrackersViewModel myTrackersVm;
@override
void dispose() {
myTrackersVm.resetList();
super.dispose();
}
@override
void initState() {
myTrackersVm = context.read<MyTrackersViewModel>();
myTrackersVm.startSearchingForTracker();
super.initState();
}
@override
Widget build(BuildContext context) {
return AppScaffold(
appBarTitle: "BLE Tracker",
showNewAppBar: true,
isShowDecPage: false,
showNewAppBarTitle: true,
backgroundColor: Color(0xffF8F8F8),
body: Container(
child: SingleChildScrollView(
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
Consumer(
builder: (BuildContext context, MyTrackersViewModel myTrackerVm, Widget child) {
if (myTrackerVm.devicesList.isEmpty) {
return Padding(
padding: const EdgeInsets.all(24.0),
child: Center(
child: Text(
"Searching for Devices Animation",
style: TextStyle(fontSize: 9.0),
),
),
);
}
return Padding(
padding: EdgeInsets.only(left: 12, right: 12, top: 20),
child: GridView.builder(
shrinkWrap: true,
primary: false,
physics: NeverScrollableScrollPhysics(),
gridDelegate: SliverGridDelegateWithFixedCrossAxisCount(crossAxisCount: 3, childAspectRatio: 2 / 2, crossAxisSpacing: 12, mainAxisSpacing: 12),
padding: EdgeInsets.zero,
itemCount: myTrackerVm.devicesList.length,
itemBuilder: (BuildContext context, int index) {
BleDeviceModel device = myTrackerVm.devicesList[index];
return InkWell(
onTap: () {
myTrackerVm.oxyRtModel = null;
Navigator.pushReplacement(context, FadePage(page: OxymeterConnectScreen(deviceModel: device)));
},
child: MedicalProfileItem(
title: "${device.name}",
imagePath: 'tracker.svg',
subTitle: "",
isEnable: true,
),
);
},
),
);
},
),
],
),
),
),
);
}
}

0
lib/pages/medical/my_trackers/ble_device_type_screens/device_types/all_in_one_tracker_connect_screen.dart
Unescape Escape View File

140
lib/pages/medical/my_trackers/ble_device_type_screens/device_types/bloodpressure_connect_screen.dart
Unescape Escape View File

@ -0,0 +1,140 @@
import 'package:diplomaticquarterapp/pages/medical/my_trackers/ble_models/ble_devices_model.dart';
import 'package:diplomaticquarterapp/pages/medical/my_trackers/my_trackers_view_model/my_trackers_view_model.dart';
import 'package:diplomaticquarterapp/uitl/utils_new.dart';
import 'package:diplomaticquarterapp/widgets/buttons/defaultButton.dart';
import 'package:diplomaticquarterapp/widgets/others/app_scaffold_widget.dart';
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
class BloodPressureConnectScreen extends StatefulWidget {
final BleDeviceModel deviceModel;
const BloodPressureConnectScreen({this.deviceModel});
@override
State<BloodPressureConnectScreen> createState() => _BloodPressureConnectScreenState();
}
class _BloodPressureConnectScreenState extends State<BloodPressureConnectScreen> {
MyTrackersViewModel myTrackersVm;
@override
void initState() {
myTrackersVm = context.read<MyTrackersViewModel>();
myTrackersVm.connectDevice(widget.deviceModel);
super.initState();
}
@override
void dispose() {
myTrackersVm.disConnectDevice();
super.dispose();
}
@override
Widget build(BuildContext context) {
return AppScaffold(
appBarTitle: "${widget.deviceModel.name}",
showNewAppBar: true,
isShowDecPage: false,
showNewAppBarTitle: true,
backgroundColor: Color(0xffF8F8F8),
body: Padding(
padding: const EdgeInsets.all(24.0),
child: Consumer(
builder: (BuildContext context, MyTrackersViewModel myTrackersViewModel, Widget child) {
return Column(
crossAxisAlignment: CrossAxisAlignment.start,
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: [
Expanded(
child: ListView(
children: [
if (myTrackersViewModel.bpCurrentStatus == "RealTimeDataBP2Measuring") ...[
Row(
mainAxisAlignment: MainAxisAlignment.center,
children: [
mHeight(24.0),
Column(
children: [
Text(myTrackersViewModel.bpRtMeasuringModel.pressure.toString(), style: TextStyle(fontSize: 100, fontWeight: FontWeight.bold)),
Text("Pressure", style: TextStyle(fontSize: 20)),
],
),
mHeight(24.0),
],
),
] else if (myTrackersViewModel.bpCurrentStatus == "RealTimeDataBP2Result") ...[
Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
mHeight(24.0),
Row(
mainAxisAlignment: MainAxisAlignment.spaceEvenly,
children: [
Column(
children: [
Text("Dia", style: TextStyle(fontSize: 20)),
Text(myTrackersViewModel.bpRtResultModel.dia.toString(), style: TextStyle(fontSize: 50, fontWeight: FontWeight.bold)),
Text("mmHg", style: TextStyle(fontSize: 10)),
],
),
Column(
children: [
Text("Sys", style: TextStyle(fontSize: 20)),
Text(myTrackersViewModel.bpRtResultModel.sys.toString(), style: TextStyle(fontSize: 50, fontWeight: FontWeight.bold)),
Text("mmHg", style: TextStyle(fontSize: 10)),
],
),
Column(
children: [
Text("♥︎", style: TextStyle(fontSize: 20)),
Text(myTrackersViewModel.bpRtResultModel.pr.toString(), style: TextStyle(fontSize: 50, fontWeight: FontWeight.bold)),
Text("/min", style: TextStyle(fontSize: 10)),
],
),
],
),
mHeight(24.0),
],
),
] else ...[
Padding(
padding: const EdgeInsets.all(24.0),
child: Center(
child: Text(
"Some animation with the instruction",
style: TextStyle(fontSize: 9.0),
),
),
)
],
],
),
),
if (myTrackersViewModel.bpCurrentStatus != null) ...[
Row(
children: [
Expanded(
child: DefaultButton(
"Disconnect with ${widget.deviceModel.name}",
() async {
myTrackersVm.bpCurrentStatus = null;
myTrackersVm.bpRtMeasuringModel = null;
myTrackersVm.bpRtResultModel = null;
Navigator.pop(context);
},
textColor: Colors.white,
),
),
],
),
]
],
);
},
),
),
);
}
}

0
lib/pages/medical/my_trackers/ble_device_type_screens/device_types/bloodsugar_connect_screen.dart
Unescape Escape View File

0
lib/pages/medical/my_trackers/ble_device_type_screens/device_types/ecg_connect_screen.dart
Unescape Escape View File

129
lib/pages/medical/my_trackers/ble_device_type_screens/device_types/oxymeter_connect_screen.dart
Unescape Escape View File

@ -0,0 +1,129 @@
import 'package:diplomaticquarterapp/pages/medical/my_trackers/ble_models/ble_devices_model.dart';
import 'package:diplomaticquarterapp/pages/medical/my_trackers/my_trackers_view_model/my_trackers_view_model.dart';
import 'package:diplomaticquarterapp/uitl/utils_new.dart';
import 'package:diplomaticquarterapp/widgets/buttons/defaultButton.dart';
import 'package:diplomaticquarterapp/widgets/others/app_scaffold_widget.dart';
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
class OxymeterConnectScreen extends StatefulWidget {
final BleDeviceModel deviceModel;
const OxymeterConnectScreen({this.deviceModel});
@override
State<OxymeterConnectScreen> createState() => _OxymeterConnectScreenState();
}
class _OxymeterConnectScreenState extends State<OxymeterConnectScreen> {
MyTrackersViewModel myTrackersVm;
@override
void initState() {
myTrackersVm = context.read<MyTrackersViewModel>();
myTrackersVm.connectDevice(widget.deviceModel);
super.initState();
}
@override
void dispose() {
myTrackersVm.disConnectDevice();
super.dispose();
}
@override
Widget build(BuildContext context) {
return AppScaffold(
appBarTitle: "${widget.deviceModel.name}",
showNewAppBar: true,
isShowDecPage: false,
showNewAppBarTitle: true,
backgroundColor: Color(0xffF8F8F8),
body: Padding(
padding: const EdgeInsets.all(24.0),
child: Consumer(
builder: (BuildContext context, MyTrackersViewModel myTrackersViewModel, Widget child) {
return Column(
crossAxisAlignment: CrossAxisAlignment.start,
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: [
Expanded(
child: ListView(
children: [
if (myTrackersViewModel.oxyRtModel != null) ...[
Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
mHeight(24.0),
Row(
mainAxisAlignment: MainAxisAlignment.spaceEvenly,
children: [
if (myTrackersViewModel.oxyRtModel.isProbeOff) ...[
Text("Check Probe", style: TextStyle(fontSize: 50, fontWeight: FontWeight.bold)),
] else ...[
Column(
children: [
Text("SPO₂", style: TextStyle(fontSize: 20)),
Text(myTrackersViewModel.oxyRtModel.spo2.toString(), style: TextStyle(fontSize: 50, fontWeight: FontWeight.bold)),
Text("%", style: TextStyle(fontSize: 10)),
],
),
Column(
children: [
Text("Pulse", style: TextStyle(fontSize: 20)),
Text(myTrackersViewModel.oxyRtModel.pr.toString(), style: TextStyle(fontSize: 50, fontWeight: FontWeight.bold)),
Text("bpm", style: TextStyle(fontSize: 10)),
],
),
Column(
children: [
Text("PI", style: TextStyle(fontSize: 20)),
Text(myTrackersViewModel.oxyRtModel.pi.toString(), style: TextStyle(fontSize: 50, fontWeight: FontWeight.bold)),
Text("%", style: TextStyle(fontSize: 10)),
],
),
],
],
),
mHeight(24.0),
],
)
],
if (myTrackersViewModel.oxyRtModel == null) ...[
Padding(
padding: const EdgeInsets.all(24.0),
child: Center(
child: Text(
"Some animation with the instruction",
style: TextStyle(fontSize: 9.0),
),
),
),
]
],
),
),
if (myTrackersViewModel.oxyRtModel != null) ...[
Row(
children: [
Expanded(
child: DefaultButton(
"Disconnect with ${widget.deviceModel.name}",
() async {
myTrackersVm.oxyRtModel = null;
Navigator.pop(context);
},
textColor: Colors.white,
),
),
],
),
]
],
);
},
),
),
);
}
}

114
lib/pages/medical/my_trackers/ble_device_type_screens/select_tracker_type.dart
Unescape Escape View File

@ -0,0 +1,114 @@
import 'package:diplomaticquarterapp/pages/medical/my_trackers/ble_device_type_screens/ble_devices_screen.dart';
import 'package:diplomaticquarterapp/pages/medical/my_trackers/my_trackers_view_model/my_trackers_view_model.dart';
import 'package:diplomaticquarterapp/widgets/data_display/medical/medical_profile_item.dart';
import 'package:diplomaticquarterapp/widgets/others/app_scaffold_widget.dart';
import 'package:diplomaticquarterapp/widgets/transitions/fade_page.dart';
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
class SelectTrackerType extends StatelessWidget {
const SelectTrackerType();
List<Widget> myTrackersTypeList({BuildContext context}) {
List<Widget> medical = [];
medical.add(InkWell(
onTap: () {
context.read<MyTrackersViewModel>().updateSelectedTrackerType(TrackerTypeEnum.OxymeterTracker);
Navigator.of(context).push(FadePage(page: BleDevicesScreen()));
},
child: MedicalProfileItem(
title: "Oxymeter",
imagePath: 'tracker.svg',
subTitle: "Tracker",
isEnable: true,
),
));
medical.add(InkWell(
onTap: () {
context.read<MyTrackersViewModel>().updateSelectedTrackerType(TrackerTypeEnum.BloodPressureTracker);
Navigator.of(context).push(FadePage(page: BleDevicesScreen()));
},
child: MedicalProfileItem(
title: "Blood Pressure",
imagePath: 'tracker.svg',
subTitle: "Tracker",
isEnable: true,
),
));
medical.add(InkWell(
onTap: () {
context.read<MyTrackersViewModel>().updateSelectedTrackerType(TrackerTypeEnum.BloodSugarTracker);
Navigator.of(context).push(FadePage(page: BleDevicesScreen()));
},
child: MedicalProfileItem(
title: "Blood Sugar",
imagePath: 'tracker.svg',
subTitle: "Tracker",
isEnable: true,
),
));
medical.add(InkWell(
onTap: () {
context.read<MyTrackersViewModel>().updateSelectedTrackerType(TrackerTypeEnum.ECGTracker);
Navigator.of(context).push(FadePage(page: BleDevicesScreen()));
},
child: MedicalProfileItem(
title: "ECG",
imagePath: 'tracker.svg',
subTitle: "Tracker",
isEnable: true,
),
));
medical.add(InkWell(
onTap: () {
context.read<MyTrackersViewModel>().updateSelectedTrackerType(TrackerTypeEnum.AllInOneTracker);
Navigator.of(context).push(FadePage(page: BleDevicesScreen()));
},
child: MedicalProfileItem(
title: "All in one Monitor",
imagePath: 'tracker.svg',
subTitle: "Tracker",
isEnable: true,
),
));
return medical;
}
@override
Widget build(BuildContext context) {
List<Widget> myMedicalList = myTrackersTypeList(context: context);
return AppScaffold(
isShowDecPage: false,
isShowAppBar: false,
showNewAppBar: true,
isHelp: true,
showNewAppBarTitle: true,
appBarTitle: "Select Tracker",
body: Container(
child: SingleChildScrollView(
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
Padding(
padding: EdgeInsets.only(left: 12, right: 12, top: 20),
child: GridView.builder(
shrinkWrap: true,
primary: false,
physics: NeverScrollableScrollPhysics(),
gridDelegate: SliverGridDelegateWithFixedCrossAxisCount(crossAxisCount: 3, childAspectRatio: 2 / 2, crossAxisSpacing: 12, mainAxisSpacing: 12),
padding: EdgeInsets.zero,
itemCount: myMedicalList.length,
itemBuilder: (BuildContext context, int index) {
return myMedicalList[index];
},
),
),
],
),
),
),
);
}
}

23
lib/viatom_ble/ble_connect.dart → lib/pages/medical/my_trackers/ble_helpers/ble_connect_helper.dart
Unescape Escape View File

@ -10,14 +10,14 @@ class BleChannel {
// static const platform_ios_ekg = MethodChannel('BLE-Platform-Bridge-IOS-EKG');
//BLE-Platform-Bridge
static Future<String> getScanningResult(List<String> deviceType) async {
static Future<String> scanResults(List<String> deviceType) async {
try {
String result;
print("----------Flutter Init -------");
// if (Platform.isIOS && deviceType[0] == "ekg") {
// result = await platform_ios_ekg.invokeMethod('scanEKG', deviceType);
// } else {
result = await platform.invokeMethod('scan', deviceType);
result = await platform.invokeMethod('scan');
// }
print("----------Flutter Result -------");
print(result);
@ -27,6 +27,23 @@ class BleChannel {
}
}
static Future<String> connectDevice(List<String> device) async {
try {
String result;
print("----------Flutter init connectDevice -------");
// if (Platform.isIOS && deviceType[0] == "ekg") {
// result = await platform_ios_ekg.invokeMethod('scanEKG', deviceType);
// } else {
result = await platform.invokeMethod('connectDevice', device);
// }
print("----------Flutter Result connectDevice -------");
print(result);
return result;
} catch (e) {
return "Error: $e";
}
}
static Future<String> getEKGFilesList(List<String> deviceType) async {
try {
print("----------Flutter Init -------");
@ -65,7 +82,7 @@ class BleChannel {
static Future<String> disconnect() async {
try {
print("----------Flutter Init -------");
print("----------Flutter Init disconnect_device -------");
final String result = await platform.invokeMethod('disconnect_device');
print("----------Flutter Result -------");
print(result);

29
lib/pages/medical/my_trackers/ble_models/ble_devices_model.dart
Unescape Escape View File

@ -0,0 +1,29 @@
class BleDeviceModel {
String macAddr;
int model;
String name;
int rssi;
BleDeviceModel({this.macAddr, this.model, this.name, this.rssi});
BleDeviceModel.fromJson(Map<String, dynamic> json) {
macAddr = json['macAddr'];
model = json['model'];
name = json['name'];
rssi = json['rssi'];
}
Map<String, dynamic> toJson() {
final Map<String, dynamic> data = new Map<String, dynamic>();
data['macAddr'] = this.macAddr;
data['model'] = this.model;
data['name'] = this.name;
data['rssi'] = this.rssi;
return data;
}
@override
String toString() {
return 'BleDeviceModel{macAddr: $macAddr, model: $model, name: $name, rssi: $rssi}';
}
}

58
lib/pages/medical/my_trackers/ble_models/viatom_devices/bp_rt_model.dart
Unescape Escape View File

@ -0,0 +1,58 @@
class BpRtMeasuringModel {
bool deflate;
int pr;
int pressure;
bool pulse;
BpRtMeasuringModel({this.deflate, this.pr, this.pressure, this.pulse});
BpRtMeasuringModel.fromJson(Map<String, dynamic> json) {
deflate = json['deflate'];
pr = json['pr'];
pressure = json['pressure'];
pulse = json['pulse'];
}
Map<String, dynamic> toJson() {
final Map<String, dynamic> data = new Map<String, dynamic>();
data['deflate'] = this.deflate;
data['pr'] = this.pr;
data['pressure'] = this.pressure;
data['pulse'] = this.pulse;
return data;
}
}
class BpRtResultModel {
bool deflate;
int dia;
int mean;
int pr;
int pressure;
int result;
int sys;
BpRtResultModel({this.deflate, this.dia, this.mean, this.pr, this.pressure, this.result, this.sys});
BpRtResultModel.fromJson(Map<String, dynamic> json) {
deflate = json['deflate'];
dia = json['dia'];
mean = json['mean'];
pr = json['pr'];
pressure = json['pressure'];
result = json['result'];
sys = json['sys'];
}
Map<String, dynamic> toJson() {
final Map<String, dynamic> data = new Map<String, dynamic>();
data['deflate'] = this.deflate;
data['dia'] = this.dia;
data['mean'] = this.mean;
data['pr'] = this.pr;
data['pressure'] = this.pressure;
data['result'] = this.result;
data['sys'] = this.sys;
return data;
}
}

0
lib/models/ble_devices/viatom_devices/ekg_file_detail_response_model.dart → lib/pages/medical/my_trackers/ble_models/viatom_devices/ekg_file_detail_response_model.dart
Unescape Escape View File

0
lib/models/ble_devices/viatom_devices/ekg_realtime_data_response.dart → lib/pages/medical/my_trackers/ble_models/viatom_devices/ekg_realtime_data_response.dart
Unescape Escape View File

6
lib/models/ble_devices/viatom_devices/oxy_sp20_rt_param_model.dart → lib/pages/medical/my_trackers/ble_models/viatom_devices/oxy_rt_param_model.dart
Unescape Escape View File

@ -1,4 +1,4 @@
class SP20RTParamModel {
class OxyRtParamModel {
int battery;
bool isCheckProbe;
bool isProbeOff;
@ -7,9 +7,9 @@ class SP20RTParamModel {
int pr;
int spo2;
SP20RTParamModel({this.battery, this.isCheckProbe, this.isProbeOff, this.isPulseSearching, this.pi, this.pr, this.spo2});
OxyRtParamModel({this.battery, this.isCheckProbe, this.isProbeOff, this.isPulseSearching, this.pi, this.pr, this.spo2});
SP20RTParamModel.fromJson(Map<String, dynamic> json) {
OxyRtParamModel.fromJson(Map<String, dynamic> json) {
battery = json['battery'];
isCheckProbe = json['isCheckProbe'];
isProbeOff = json['isProbeOff'];

0
lib/models/ble_devices/weight_scale_data.dart → lib/pages/medical/my_trackers/ble_models/weight_scale_data.dart
Unescape Escape View File

171
lib/pages/medical/my_trackers/my_trackers_view_model/my_trackers_view_model.dart
Unescape Escape View File

@ -0,0 +1,171 @@
import 'dart:convert';
import 'dart:developer';
import 'package:diplomaticquarterapp/pages/medical/my_trackers/ble_models/ble_devices_model.dart';
import 'package:diplomaticquarterapp/pages/medical/my_trackers/ble_models/viatom_devices/bp_rt_model.dart';
import 'package:diplomaticquarterapp/pages/medical/my_trackers/ble_models/viatom_devices/oxy_rt_param_model.dart';
import 'package:flutter/services.dart';
import 'package:flutter/cupertino.dart';
import 'package:permission_handler/permission_handler.dart';
import 'package:diplomaticquarterapp/pages/medical/my_trackers/ble_helpers/ble_connect_helper.dart';
import 'package:flutter/material.dart';
enum TrackerTypeEnum { OxymeterTracker, BloodPressureTracker, BloodSugarTracker, ECGTracker, AllInOneTracker }
class MyTrackersViewModel extends ChangeNotifier {
EventChannel eventChannel = EventChannel('BLE-Platform-Bridge-Event');
List<BleDeviceModel> devicesList = [];
var devicesInfoJson = {
"OxymeterTracker": [
{"model": "SP-20"}, // DONE
{"model": "POD-1"}, // DONE
{"model": "O2M"}, // DONE
{"model": "PC-60"}, //DONE
{"model": "O2Ring"}, // DONE
],
"BloodPressureTracker": [
{"model": "BP2"},
{"model": ""},
{"model": ""},
{"model": ""},
],
"BloodSugarTracker": [
{"model": ""},
{"model": ""},
{"model": ""},
{"model": ""},
],
"ECGTracker": [
{"model": "DuoEK"},
{"model": ""},
{"model": ""},
{"model": ""},
],
"AllInOneTracker": [
{"model": ""},
{"model": ""},
{"model": ""},
{"model": ""},
],
};
//************************************* OXYMETER *************************************
OxyRtParamModel oxyRtModel;
void updateOxyRtModel(Map<String, dynamic> mapData) {
oxyRtModel = OxyRtParamModel.fromJson(mapData);
notifyListeners();
}
// ************************************* BLOOD PRESSURE *************************************
BpRtMeasuringModel bpRtMeasuringModel;
void updateBpRtMeasuringModel(Map<String, dynamic> mapData) {
bpRtMeasuringModel = BpRtMeasuringModel.fromJson(mapData);
notifyListeners();
}
BpRtResultModel bpRtResultModel;
void updateBpRtResultModel(Map<String, dynamic> mapData) {
bpRtResultModel = BpRtResultModel.fromJson(mapData);
notifyListeners();
}
String bpCurrentStatus;
updateBpCurrentStatus(var value) {
bpCurrentStatus = value;
notifyListeners();
}
void filterOutTheSearchedDevices(List<BleDeviceModel> allDevices) {
devicesList.clear();
notifyListeners();
if (devicesInfoJson.containsKey(currentSelectedTrackerType.name)) {
allDevices.forEach((foundDevice) {
List devicesInSelectedType = devicesInfoJson[currentSelectedTrackerType.name];
for (var device in devicesInSelectedType) {
log("foundDevice.name: ${foundDevice.name.toString()}");
log("device['model']: ${device['model']}");
if (device['model'] != "" && foundDevice.name.contains(device['model'])) {
devicesList.add(foundDevice);
}
}
});
notifyListeners();
}
}
TrackerTypeEnum currentSelectedTrackerType = TrackerTypeEnum.OxymeterTracker;
updateSelectedTrackerType(var value) {
devicesList.clear();
currentSelectedTrackerType = value;
notifyListeners();
}
Future checkBLEPermissions() async {
return [Permission.location, Permission.storage, Permission.bluetooth, Permission.bluetoothConnect, Permission.bluetoothScan].request();
}
Future<void> startSearchingForTracker() async {
log("selectedStracker: ${currentSelectedTrackerType.name}");
await checkBLEPermissions();
eventChannel.receiveBroadcastStream().listen((event) {
print('Received event---: $event');
print(event['type']);
if (event['type'] == "devicesList") {
parsesDevicesList(json.decode(event['data']) as List);
}
if (event['type'] == "OxyRtParam") {
updateOxyRtModel(json.decode(event['data']));
}
if (event['type'] == "fileList") {
print(event['data']);
}
if (event['type'] == 'fileDetail') {
print(event['data']);
}
if (event['type'] == "RealTimeDataBP2Measuring") {
updateBpRtMeasuringModel(json.decode(event['data']));
updateBpCurrentStatus("RealTimeDataBP2Measuring");
}
if (event['type'] == "RealTimeDataBP2Result") {
updateBpRtResultModel(json.decode(event['data']));
updateBpCurrentStatus("RealTimeDataBP2Result");
}
});
await scanDevices();
}
void parsesDevicesList(List returnData) {
var devicesList = List.generate(returnData.length, (index) => BleDeviceModel.fromJson(returnData[index]));
filterOutTheSearchedDevices(devicesList);
}
void resetList() {
devicesList.clear();
// BleChannel.disconnect();
}
Future<void> connectDevice(BleDeviceModel device) async {
await BleChannel.connectDevice([device.name, device.model.toString()]);
}
Future<void> disConnectDevice() async {
await BleChannel.disconnect();
}
Future<void> scanDevices() async {
await BleChannel.scanResults([]);
}
}

23
lib/pages/medical/my_trackers/viatom_devices/bp_tracker_ble.dart
Unescape Escape View File

@ -1,10 +1,9 @@
import 'dart:convert';
import 'dart:io';
import 'package:diplomaticquarterapp/models/ble_devices/viatom_devices/bp_rt_data_measuring_model.dart';
import 'package:diplomaticquarterapp/models/ble_devices/viatom_devices/bp_rt_data_result_model.dart';
import 'package:diplomaticquarterapp/pages/medical/my_trackers/ble_models/viatom_devices/bp_rt_model.dart';
import 'package:diplomaticquarterapp/uitl/utils_new.dart';
import 'package:diplomaticquarterapp/viatom_ble/ble_connect.dart';
import 'package:diplomaticquarterapp/pages/medical/my_trackers/ble_helpers/ble_connect_helper.dart';
import 'package:diplomaticquarterapp/widgets/buttons/defaultButton.dart';
import 'package:diplomaticquarterapp/widgets/others/app_scaffold_widget.dart';
import 'package:flutter/material.dart';
@ -19,8 +18,8 @@ class BpTrackerBLE extends StatefulWidget {
class _BpTrackerBLEState extends State<BpTrackerBLE> {
EventChannel eventChannel = EventChannel('BLE-Platform-Bridge-Event');
final bpDataNotifierMeasuring = ValueNotifier<BpRtDataMeasuringModel>(BpRtDataMeasuringModel());
final bpDataNotifierResult = ValueNotifier<BpRtDataResultModel>(BpRtDataResultModel());
final bpDataNotifierMeasuring = ValueNotifier<BpRtMeasuringModel>(BpRtMeasuringModel());
final bpDataNotifierResult = ValueNotifier<BpRtResultModel>(BpRtResultModel());
final bpStatusNotifier = ValueNotifier<String>("status");
final bpDeviceDataNotifier = ValueNotifier<String>("");
String deviceName = "BP2";
@ -31,7 +30,7 @@ class _BpTrackerBLEState extends State<BpTrackerBLE> {
bpDataNotifierResult.dispose();
bpStatusNotifier.dispose();
super.dispose();
BleChannel.disconnect();
// BleChannel.disconnect();
}
@override
@ -81,7 +80,7 @@ class _BpTrackerBLEState extends State<BpTrackerBLE> {
if (value == "RealTimeDataBP2Measuring") {
return ValueListenableBuilder(
valueListenable: bpDataNotifierMeasuring,
builder: (context, BpRtDataMeasuringModel bpRtDataMeasuringModel, _) {
builder: (context, BpRtMeasuringModel bpRtDataMeasuringModel, _) {
return Row(
mainAxisAlignment: MainAxisAlignment.center,
children: [
@ -100,7 +99,7 @@ class _BpTrackerBLEState extends State<BpTrackerBLE> {
} else if (value == "RealTimeDataBP2Result") {
return ValueListenableBuilder(
valueListenable: bpDataNotifierResult,
builder: (context, BpRtDataResultModel bpRtDataResultModel, _) {
builder: (context, BpRtResultModel bpRtDataResultModel, _) {
return Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
@ -255,15 +254,15 @@ class _BpTrackerBLEState extends State<BpTrackerBLE> {
bpStatusNotifier.value = "RealTimeDataBP2Result";
}
});
await BleChannel.getScanningResult(["bloodpressure", "BP2"]);
await BleChannel.scanResults(["bloodpressure", "BP2"]);
});
}
void parseBpRtMeasuringObject(dynamic returnData) {
bpDataNotifierMeasuring.value = BpRtDataMeasuringModel.fromJson(json.decode(returnData));
bpDataNotifierMeasuring.value = BpRtMeasuringModel.fromJson(json.decode(returnData));
}
void parseBpRtResultObject(dynamic returnData) {
bpDataNotifierResult.value = BpRtDataResultModel.fromJson(json.decode(returnData));
bpDataNotifierResult.value = BpRtResultModel.fromJson(json.decode(returnData));
}
}

2
lib/pages/medical/my_trackers/viatom_devices/ekg_chart_view.dart
Unescape Escape View File

@ -1,4 +1,4 @@
import 'package:diplomaticquarterapp/models/ble_devices/viatom_devices/ekg_file_detail_response_model.dart';
import 'package:diplomaticquarterapp/pages/medical/my_trackers/ble_models/viatom_devices/ekg_file_detail_response_model.dart';
import 'package:diplomaticquarterapp/widgets/others/app_scaffold_widget.dart';
import 'package:fl_chart/fl_chart.dart';
import 'package:flutter/material.dart';

9
lib/pages/medical/my_trackers/viatom_devices/ekg_tracker_ble.dart
Unescape Escape View File

@ -1,12 +1,11 @@
import 'dart:async';
import 'dart:convert';
import 'package:diplomaticquarterapp/models/ble_devices/viatom_devices/ekg_file_detail_response_model.dart';
import 'package:diplomaticquarterapp/models/ble_devices/viatom_devices/ekg_realtime_data_response.dart';
import 'package:diplomaticquarterapp/pages/medical/my_trackers/ble_models/viatom_devices/ekg_file_detail_response_model.dart';
import 'package:diplomaticquarterapp/pages/medical/my_trackers/ble_models/viatom_devices/ekg_realtime_data_response.dart';
import 'package:diplomaticquarterapp/pages/medical/my_trackers/viatom_devices/ekg_chart_view.dart';
import 'package:diplomaticquarterapp/uitl/date_uitl.dart';
import 'package:diplomaticquarterapp/uitl/utils_new.dart';
import 'package:diplomaticquarterapp/viatom_ble/ble_connect.dart';
import 'package:diplomaticquarterapp/pages/medical/my_trackers/ble_helpers/ble_connect_helper.dart';
import 'package:diplomaticquarterapp/widgets/buttons/defaultButton.dart';
import 'package:diplomaticquarterapp/widgets/others/app_scaffold_widget.dart';
import 'package:diplomaticquarterapp/widgets/transitions/fade_page.dart';
@ -170,7 +169,7 @@ class _EKG_BLEState extends State<EKG_BLE> {
// eventChannelIOSEKG.receiveBroadcastStream().listen((event) {
// print('Received eventChannelIOSEKG event---: $event');
// });
await BleChannel.getScanningResult(["ekg", "DuoEK"]);
await BleChannel.scanResults(["ekg", "DuoEK"]);
},
textColor: Colors.white,
),

4
lib/pages/medical/my_trackers/viatom_devices/oxymeter_ble.dart
Unescape Escape View File

@ -1,6 +1,6 @@
import 'dart:io';
import 'package:diplomaticquarterapp/viatom_ble/ble_connect.dart';
import 'package:diplomaticquarterapp/pages/medical/my_trackers/ble_helpers/ble_connect_helper.dart';
import 'package:diplomaticquarterapp/widgets/others/app_scaffold_widget.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
@ -110,7 +110,7 @@ class _Oxymeter_BLEState extends State<Oxymeter_BLE> {
// POD-1W response: RtParam{spo2=98, pr=104, pi=5.8, isProbeOff=false, isPulseSearching=false}
});
await BleChannel.getScanningResult(["oximeter", deviceName]);
await BleChannel.scanResults(["oximeter", deviceName]);
});
}

12
lib/pages/medical/my_trackers/viatom_devices/sp20_pulse_tracker.dart
Unescape Escape View File

@ -1,7 +1,7 @@
import 'dart:convert';
import 'package:diplomaticquarterapp/models/ble_devices/viatom_devices/oxy_sp20_rt_param_model.dart';
import 'package:diplomaticquarterapp/pages/medical/my_trackers/ble_models/viatom_devices/oxy_rt_param_model.dart';
import 'package:diplomaticquarterapp/uitl/utils_new.dart';
import 'package:diplomaticquarterapp/viatom_ble/ble_connect.dart';
import 'package:diplomaticquarterapp/pages/medical/my_trackers/ble_helpers/ble_connect_helper.dart';
import 'package:diplomaticquarterapp/widgets/buttons/defaultButton.dart';
import 'package:diplomaticquarterapp/widgets/others/app_scaffold_widget.dart';
import 'package:flutter/material.dart';
@ -17,7 +17,7 @@ class _SP20PulseTrackerState extends State<SP20PulseTracker> {
EventChannel eventChannel = EventChannel('BLE-Platform-Bridge-Event');
// final bpDataNotifierMeasuring = ValueNotifier<BpRtDataMeasuringModel>(BpRtDataMeasuringModel());
final sp20RtParamNotifier = ValueNotifier<SP20RTParamModel>(SP20RTParamModel());
final sp20RtParamNotifier = ValueNotifier<OxyRtParamModel>(OxyRtParamModel());
final sp20StatusNotifier = ValueNotifier<String>("");
final bpDeviceDataNotifier = ValueNotifier<String>("");
String deviceName = "SP20";
@ -78,7 +78,7 @@ class _SP20PulseTrackerState extends State<SP20PulseTracker> {
if (value == "EventSp20RtParam") {
return ValueListenableBuilder(
valueListenable: sp20RtParamNotifier,
builder: (context, SP20RTParamModel sp20RtModel, _) {
builder: (context, OxyRtParamModel sp20RtModel, _) {
return Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
@ -190,11 +190,11 @@ class _SP20PulseTrackerState extends State<SP20PulseTracker> {
}
if (event['type'] == "EventSp20RtParam") {
sp20RtParamNotifier.value = SP20RTParamModel.fromJson(json.decode(event['data']));
sp20RtParamNotifier.value = OxyRtParamModel.fromJson(json.decode(event['data']));
sp20StatusNotifier.value = "EventSp20RtParam";
}
});
await BleChannel.getScanningResult(["Pulse Oxymeter", "SP-20"]);
await BleChannel.scanResults(["Pulse Oxymeter", "SP-20"]);
});
}
}

2
lib/pages/medical/my_trackers/weight_scale_ble.dart
Unescape Escape View File

@ -1,6 +1,6 @@
import 'dart:async';
import 'package:diplomaticquarterapp/models/ble_devices/weight_scale_data.dart';
import 'package:diplomaticquarterapp/pages/medical/my_trackers/ble_models/weight_scale_data.dart';
import 'package:diplomaticquarterapp/theme/colors.dart';
import 'package:diplomaticquarterapp/uitl/app_toast.dart';
import 'package:diplomaticquarterapp/uitl/ble_utils.dart';

16
lib/uitl/utils.dart
Unescape Escape View File

@ -28,6 +28,7 @@ import 'package:diplomaticquarterapp/pages/medical/doctor/doctor_home_page.dart'
import 'package:diplomaticquarterapp/pages/medical/eye/EyeMeasurementsPage.dart';
import 'package:diplomaticquarterapp/pages/medical/labs/labs_home_page.dart';
import 'package:diplomaticquarterapp/pages/medical/my_invoices/my_invoice_page.dart';
import 'package:diplomaticquarterapp/pages/medical/my_trackers/ble_device_type_screens/select_tracker_type.dart';
import 'package:diplomaticquarterapp/pages/medical/my_trackers/my_trackers.dart';
import 'package:diplomaticquarterapp/pages/medical/patient_sick_leave_page.dart';
import 'package:diplomaticquarterapp/pages/medical/prescriptions/prescriptions_home_page.dart';
@ -494,13 +495,24 @@ class Utils {
),
));
// Oxymeter
// BloodPressure
// Blood Sugar
// ECG
// Holter
// All in one Monitor
medical.add(InkWell(
onTap: () => projectViewModel.havePrivilege(24) ? Navigator.push(context, FadePage(page: MyTrackers())) : null,
onTap: () {
if (projectViewModel.havePrivilege(30)) {
Navigator.push(context, FadePage(page: SelectTrackerType()));
}
},
child: MedicalProfileItem(
title: "Connect",
imagePath: 'tracker.svg',
subTitle: "BLE",
isEnable: projectViewModel.havePrivilege(24),
isEnable: projectViewModel.havePrivilege(30),
),
));

Write Preview
Loading…
Cancel
Save