ECG

DeviceApiManager.kt

override fun getEcgListWithOffset(offset: Int): Single<DeviceEcgList> {
        val request = ru.cardiomarker.p1.rpc.ecg.list.Request.newBuilder()
            .addLeads(Lead.II)
            .addLeads(Lead.CM5)
            .apply {
                if (offset != 0) {
                    setOffset(offset)
                }
            }
            .build()

        return dispatcher.sendMessage(0x20, request)
            .map(ru.cardiomarker.p1.rpc.ecg.list.Response::parseFrom)
    }

    override fun getCurrentEcg(): Single<List<DeviceEcgRecord>> {
        return getInfo().map {
            it.storageSummary.ecgRecordCount - 1
        }.flatMap { offset ->
            getEcgListWithOffset(offset)
        }.map {
            it.recordsList
        }
    }

    override fun getAllEcg(): Single<ArrayList<DeviceEcgRecord>> {
        return getInfo().map {
            it.storageSummary.ecgRecordCount
        }.flatMap { totalRecordCount ->
            var offset = totalRecordCount - 50
            val records = ArrayList<DeviceEcgRecord>()

            return@flatMap Single.defer {
                if (offset < 0)
                    offset = 0
                getEcgListWithOffset(offset)
                    .map {
                        records.addAll(it.recordsList)
                        offset -= 50
                    }
            }
                .repeatUntil { offset <= -50 }
                .ignoreElements()
                .toSingle { records }
        }
    }

    override fun getEcgList(max: Int): Single<DeviceEcgList> {
        val request = ru.cardiomarker.p1.rpc.ecg.list.Request.newBuilder()
            .addLeads(Lead.II)
            .addLeads(Lead.CM5)
            .clearLimit()
            .clearOffset()
            .clearFrom().clearTo()
            .setLimit(max)
            .build()

        return dispatcher.sendMessage(0x20, request)
            .map(ru.cardiomarker.p1.rpc.ecg.list.Response::parseFrom)
    }

    override fun getEcgList(startSeconds: Int, endSeconds: Int): Single<DeviceEcgList> {
        val request = ru.cardiomarker.p1.rpc.ecg.list.Request.newBuilder()
            .addLeads(Lead.II).addLeads(Lead.CM5)
            .clearLimit().clearOffset()
            .setFrom(Timestamp.newBuilder().setSeconds(startSeconds).build())
            .setTo(Timestamp.newBuilder().setSeconds(endSeconds).build())
            .build()

        return dispatcher.sendMessage(0x20, request)
            .map(ru.cardiomarker.p1.rpc.ecg.list.Response::parseFrom)
    }

    override fun getEcgRecord(timestamp: Timestamp, offset: Int, lead: Lead): Single<DeviceEcgRead> {
        val request = ru.cardiomarker.p1.rpc.ecg.get.Request.newBuilder()
            .setTimestamp(timestamp)
            .setLead(lead)
            .clearLimit()
            .setOffset(offset)
            .build()

        return dispatcher.sendMessage(0x21, request)
            .map(ru.cardiomarker.p1.rpc.ecg.get.Response::parseFrom)
    }

    override fun getEcgStreamData(lead: Lead): Single<DeviceEcgPeek> {
        val request = Request.newBuilder()
            .setLead(lead)
            .clearLimit()
            .build()

        return dispatcher.sendMessage(0x23, request)
            .map(ru.cardiomarker.p1.rpc.ecg.peek.Response::parseFrom)
    }