VPOperateManager.getInstance()

init(context)

startScanDevice(searchResponse)

/**
* Start scanning devices
*/
fun onSearchStarted()

/**
* Discover scanning devices
*
* @param device Currently discovered device
*/
fun onDeviceFounded(device:SearchResult)

/**
* Stop scanning device callback
*/
fun onSearchStopped()

/**
* Cancel scanning device callback
*/
fun onSearchCanceled()

//kotlin code
VPOperateManager.getInstance()
            .startScanDevice(object : SearchResponse {
                override fun onSearchStarted() {

                }

                override fun onDeviceFounded(p0: SearchResult) {
                    
                }

                override fun onSearchStopped() {
                    
                }

                override fun onSearchCanceled() {
                }
            })

stopScanDevice()

//kotlin code
VPOperateManager.getInstance().stopScanDevice()

connectDevice(mac,connectResponse,bleNotifyResponse)

/**
* Return of connection status
*
* @param code Connection status, only when the value is Code.REQUEST_SUCCESS, it means the connection is successful
* @param profile Bluetooth properties of the device
* @param isOadModel The device has two modes [normal mode/firmware upgrade mode]. In most cases, it is in normal mode. Only when the device fails to perform a firmware upgrade operation, it will enter the firmware upgrade mode
*/
fun connectState(code:Int, profile:BleGattProfile, isOadModel:boolean);

/**
* Set the return of data monitoring
*
* @param state is successful only when the value is equal to Code.REQUEST_SUCCESS
*/
fun notifyState(state:Int);

confirmDevicePwd(bleWriteResponse,pwdDataListener,deviceFuctionDataListener，socialMsgDataListener，customSettingDataListener，pwd，mModelIs24)  

confirmDevicePwd(bleWriteResponse,pwdDataListener,deviceFuctionDataListener，socialMsgDataListener，customSettingDataListener，pwd，mModelIs24,deviceTimeSetting)

/**
* Returns the data of password operation
* @param pwdData Password operation data
*/
fun onPwdDataChange(pwdData:PwdData);

/**
 * Returns device functional status
 *
 * @param functionSupport
 */
fun onFunctionSupportDataChange(functionSupport:FunctionDeviceSupportData)

// kotlin code
VPOperateManager.getInstance()
    .confirmDevicePwd({
        //                连接失败
        if (it != Code.REQUEST_SUCCESS) {
            Log.e("TAG", "confirmDevicePwd fail:check fail")
        }
    },
        {
            val message =
                "PwdData:$it"
            if (it.getmStatus() != EPwdStatus.CHECK_FAIL) {
               Log.e("TAG", "confirmDevicePwd fail:check fail")
            } else {
                Log.e("TAG", "confirmDevicePwd fail:check fail")
                VPOperateManager.getInstance()
                    .disconnectWatch { }
            }
        },
        {
            val message =
                "FunctionSupport:$it"
            Log.e("TAG", message)
        }, object : ISocialMsgDataListener {
            override fun onSocialMsgSupportDataChange(p0: FunctionSocailMsgData?) {
                val message =
                    "FunctionSocailMsgData:${p0.toString()}"
                Log.e("TAG", message)
            }

            override fun onSocialMsgSupportDataChange2(p0: FunctionSocailMsgData?) {
                val message =
                    "FunctionSocailMsgData2:${p0.toString()}"
                Log.e("TAG", message)
            }

        }, customSettingDataListener, "0000", false
    )

//kotlin code
VPOperateManager.getInstance().disconnectWatch {

}

syncPersonInfo(bleWriteResponse, personInfoDataListener, personInfoData)

/**
* Return the status of the operation
*
* @param EOprateStauts: OPRATE_SUCCESS: operation successful, OPRATE_FAIL: operation failed, UNKNOW: unknown
*/
fun OnPersoninfoDataChange(eOprateStauts:EOprateStauts)

//        kotlin code
VPOperateManager.getInstance().syncPersonInfo(writeResponse,
    { EOprateStauts ->
        val message = "syncPersonInfo:\n$EOprateStauts"

    }, PersonInfoData(ESex.MAN, 178, 60, 20, 8000)
)

settingDeviceLanguage(bleWriteResponse, languageDataListener, language)

/**
* Returns the state of the language
*
* @param languageData language data
*/
fun onLanguageDataChange( languageData:LanguageData)

readSportStep(bleWriteResponse, sportDataListener)

/**
* Returns step counting data
*
* @param sportData Current sport data
*/
fun onSportDataChange(sportData:SportData)

//kotlin code
VPOperateManager.getInstance().readSportStep({
    if (it != Code.REQUEST_SUCCESS) {
        Log.e("Test", "write cmd failed")
    }
}) { sportData ->  }

readBattery(bleWriteResponse, batteryDataListener)

/**
 * 返回电量的数据
 */
fun onDataChange(batteryData:BatteryData)

//kotlin code
VPOperateManager.getInstance().readBattery({
    if (it != Code.REQUEST_SUCCESS) { 
        
    }
}, {
    
})

/**
* Read progress callback
*
* @param progress progress value, range [0-1]
*/
void onProgress(float progress);

/**
* Returns sleep data
*
* @param day indicates the day of the data being read 0: today, 1: yesterday, 2: the day before yesterday.
* @param sleepData sleep data
*/
void onSleepDataChange(String day, SleepData sleepData);

/**
* callback for reading the end of sleep
*/
void onReadSleepComplete();

/**
* callback for reading 5 minutes of raw data
*
* @param originData 5 minutes of raw data
*/
void onOringinFiveMinuteDataChange(OriginData originData);

/**
* callback for 30 minutes of raw data, from 5 minutes of raw data, but data processing is done internally
*
* @param originHalfHourData
*/
void onOringinHalfHourDataChange(OriginHalfHourData originHalfHourData);

/**
* end of reading all data
*/
void onReadOriginComplete();

//kotlin code
VPOperateManager.getInstance().readAllHealthData(object :IAllHealthDataListener{
    override fun onProgress(progress: Float) {
		
    }

    override fun onSleepDataChange(day: String?, sleepData: SleepData?) {

    }

    override fun onReadSleepComplete() {

    }

    override fun onOringinFiveMinuteDataChange(originData: OriginData?) {

    }

    override fun onOringinHalfHourDataChange(originHalfHourData: OriginHalfHourData?) {

    }

    override fun onReadOriginComplete() {

    }

},3)

readOriginData(bleWriteResponse, originDataListener, watchday)

readOriginDataFromDay(bleWriteResponse, originDataListener, day, position, watchday)

readOriginDataSingleDay(bleWriteResponse, originDataListener, day, position, watchday)

val originProtocolVersion = VpSpGetUtil.getVpSpVariInstance(mContext).getOriginProtocolVersion()
if(originProtocolVersion==3 || originProtocolVersion == 5){
//Read daily data and use IOriginData3Listener for data monitoring
}else{
//Read daily data and use IOriginDataListener for data monitoring
}

/**
* Return 5 minutes of raw data
*
* @param originData 5 minutes of raw data
*/
fun onOringinFiveMinuteDataChange(originData:OriginData)

/**
* Return 30 minutes of raw data, the data comes from 5 minutes of raw data, but it is returned after internal processing
*
* @param originHalfHourData 30 minutes of raw data
*/
fun onOringinHalfHourDataChange(originHalfHourData:OriginHalfHourData )

/***
* Return the details of the reading. The location of this package needs to be remembered. When reading data next time, pass in the location of this package to avoid repeated reading
*
* @param day The flag of the data in the watch [0=today, 1=yesterday, 2=the day before yesterday]
* @param date The date of the data, in the format of yyyy-mm-dd
* @param allPackage The total number of packages of data on the day
* @param currentPackage The location of this package
*/
fun onReadOriginProgressDetail(day: Int,date: String?,allPackage: Int,currentPackage: Int)

/**
* Returns the reading progress
*
* @param progress progress value, range [0-1]
*/
fun onReadOriginProgress(progress:Float)

/**
* Reading completed
*/
fun onReadOriginComplete();

/**
* This interface will be called back after the data reading for that day is completed. (An OriginData3 data represents a five-minute raw data, and a day is at most 24 hours * 60 minutes / 5 minutes = 288 five-minute raw data)
* For example, reading three days of raw data will return a list of five-minute raw data from today, yesterday, and the day before yesterday.
* Specifically, it depends on how many days of raw data are read. The interface will be called several times for each day of reading.
*
* @param originDataList returns a list of 5-minute data. The heart rate value is an array. The corresponding field is getPpgs(), not getRateValue().
*/
fun onOriginFiveMinuteListDataChange(originDataList:List<OriginData3>)

/**
* When the raw data of the day is finished reading, the five-minute raw data bureau list is counted to produce a 30-minute data list.
*
* @param originHalfHourDataList returns an object of 30-minute data.
*/
fun onOriginHalfHourDataChange(originHalfHourDataList:OriginHalfHourData)

/**
* After reading the original data of the day, the statistics are generated to generate the HRV data list of the day
*
* @param originHrvDataList returns a list of hrv data
*/
fun onOriginHRVOriginListDataChange(originHrvDataList:List<HRVOriginData>)

/**
* After reading the original data of the day, the statistics are generated to generate the blood oxygen data list of the day
*
* @param originSpo2hDataList returns a list of blood oxygen data
*/
fun onOriginSpo2OriginListDataChange(originSpo2hDataList:List<Spo2hOriginData>)

//kotlin code
VPOperateManager.getInstance().readOriginData({
                                              
},object :IOriginDataListener{
    override fun onReadOriginProgressDetail(
        day: Int,
        date: String?,
        allPackage: Int,
        currentPackage: Int
    ) {
    }

    override fun onReadOriginProgress(progress: Float) {
    }

    override fun onReadOriginComplete() {
    }

    override fun onOringinFiveMinuteDataChange(originData: OriginData?) {
    }

    override fun onOringinHalfHourDataChange(originHalfHourData: OriginHalfHourData?) {
    }

},3)

readCustomSetting(bleWriteResponse,customSettingDataListener)

/**
* Returns the personalized setting data
*
* @param customSettingData Personalized setting data
*/
fun OnSettingDataChange(customSettingData: CustomSettingData?)

//        kotlin code
VPOperateManager.getInstance().readCustomSetting({

},object :ICustomSettingDataListener{
    override fun OnSettingDataChange(customSettingData: CustomSettingData?) {

    }

})

changeCustomSetting(bleWriteResponse, customSettingDataListener, customSetting)

//kotlin code
VPOperateManager.getInstance().changeCustomSetting({

},object :ICustomSettingDataListener{
    override fun OnSettingDataChange(customSettingData: CustomSettingData?) {

    }

},customSetting)

VpSpGetUtil.getVpSpVariInstance(applicationContext).isSupportNightturnSetting

/**
* Returns the data of turning the wrist to light up the screen [also known as raising the hand to light up the screen]
*
* @param nightTurnWristeData Data of raising the hand to light up the screen
*/
fun onNightTurnWristeDataChange(nightTurnWristeData:NightTurnWristeData)

VPOperateManager.getInstance().readNightTurnWriste({
    if (it != Code.REQUEST_SUCCESS) {
        // "write cmd failed"
    }
}, { nightTurnWristeData ->
    //success
})

//kotlin code
val nightTurnWristSetting = NightTurnWristSetting(
    true,
    TimeData(20, 0), TimeData
        (8, 0), 5
)
VPOperateManager.getInstance().settingNightTurnWriste({
    if (it != Code.REQUEST_SUCCESS) {

    }
}, {

}, nightTurnWristSetting)

VpSpGetUtil.getVpSpVariInstance(applicationContext).isSupportScreenlight

readScreenLight(bleWriteResponse, screenLightListener)

/**
 * 屏幕亮度调节的回调
 *
 * @param screenLightData
 */
fun onScreenLightDataChange(screenLightData:ScreenLightData);

VPOperateManager.getInstance().readScreenLight(
    writeResponse
) { screenLightData ->
    val message = "屏幕调节数据-读取:$screenLightData"
}

settingScreenLight(bleWriteResponse, screenLightListener, screensetting)

//The default setting is [22:00-07:00] is set to level 2, and other times are set to level 4. Users can customize
VPOperateManager.getInstance().settingScreenLight(writeResponse,
{ screenLightData ->
val message = "Screen adjustment data-setting: $screenLightData"
}, ScreenSetting(22, 0, 7, 0, 2, 4)
)

VpSpGetUtil.getVpSpVariInstance(applicationContext).isSupportScreenlightTime

readScreenLightTime(bleWriteResponse, screenLightTimeListener)

/**
 * 屏幕亮屏时长的回调
 *
 * @param screenLightTimeData
 */
fun onScreenLightTimeDataChange(screenLightTimeData:ScreenLightTimeData)

//kotlin code
VPOperateManager.getInstance()
    .readScreenLightTime(writeResponse, object : IScreenLightTimeListener {
        override fun onScreenLightTimeDataChange(screenLightTimeData: ScreenLightTimeData?) {
        
        }
    }
    )

setScreenLightTime(IBleWriteResponse bleWriteResponse, IScreenLightTimeListener screenLightTimeListener, int time) 

//kotlin code
VPOperateManager.getInstance()
    .setScreenLightTime(
        writeResponse, object : IScreenLightTimeListener {
            override fun onScreenLightTimeDataChange(screenLightTimeData: ScreenLightTimeData?) {

            }
        }, 10
    )

readHealthRemind(healthRemindType, listener, bleWriteResponse)

/**
* This function is not supported
*/
fun functionNotSupport()

/**
* Health reminder read callback
* @param healthRemind health reminder
*/
fun onHealthRemindRead(healthRemind: HealthRemind)

/**
* Health reminder read failed
*/
fun onHealthRemindReadFailed()

/**
* Health reminder active reporting callback
* @param healthRemind health reminder
*/
fun onHealthRemindReport(healthRemind: HealthRemind)

/**
* Health reminder active reporting failed
*/
fun onHealthRemindReportFailed()

/**
* Health reminder setting success
* @param healthRemind health reminder
*/
fun onHealthRemindSettingSuccess(healthRemind: HealthRemind)

/**
* Health reminder setting failed
* @param healthRemindType Setting failed health reminder type
*/
fun onHealthRemindSettingFailed(healthRemindType: HealthRemindType)

//kotlin code
VPOperateManager.getInstance()
    .readHealthRemind(HealthRemindType.ALL, object : IHealthRemindListener {
        override fun functionNotSupport() {
        }

        override fun onHealthRemindRead(healthRemind: HealthRemind) {
        }

        override fun onHealthRemindReadFailed() {
        }

        override fun onHealthRemindReport(healthRemind: HealthRemind) {
        }

        override fun onHealthRemindReportFailed() {
        }

        override fun onHealthRemindSettingSuccess(healthRemind: HealthRemind) {
        }

        override fun onHealthRemindSettingFailed(healthRemindType: HealthRemindType) {
        }

    }, {
        
    })

settingHealthRemind(healthRemind, listener, bleWriteResponse)

//kotlin code
val healthRemind =
    HealthRemind(HealthRemindType.ALL, TimeData(8, 0), TimeData(20, 0), 20, true)
VPOperateManager.getInstance()
    .settingHealthRemind(healthRemind, object : IHealthRemindListener {
        override fun functionNotSupport() {
        }

        override fun onHealthRemindRead(healthRemind: HealthRemind) {
        }

        override fun onHealthRemindReadFailed() {
        }

        override fun onHealthRemindReport(healthRemind: HealthRemind) {
        }

        override fun onHealthRemindReportFailed() {
        }

        override fun onHealthRemindSettingSuccess(healthRemind: HealthRemind) {
        }

        override fun onHealthRemindSettingFailed(healthRemindType: HealthRemindType) {
        }

    }) {
        
    }

startDetectHeart(bleWriteResponse,heartDataListener)

/**
* Return heart rate data
*
* @param heartData heart rate data
*/
fun onDataChange(heartData:HeartData);

//kotlin code
VPOperateManager.getInstance().startDetectHeart({

},object :IHeartDataListener{
    override fun onDataChange(heartData: HeartData?) {
        
    }

})

//kotlin code
VPOperateManager.getInstance().stopDetectHeart(){
    
}

settingHeartWarning(bleWriteResponse, heartWaringDataListener, heartWaringSetting)

/**
* Returns the heart rate alarm data
*
* @param heartWaringData Heart rate alarm data
*/
fun onHeartWaringDataChange(heartWaringData:HeartWaringData);

// kotlin code
val heartWaringSetting = HeartWaringSetting(120,40,true)
VPOperateManager.getInstance().settingHeartWarning({

},object :IHeartWaringDataListener{
    override fun onHeartWaringDataChange(heartWaringData: HeartWaringData?) {
        
    }

},heartWaringSetting)

readHeartWarning(bleWriteResponse,heartWaringDataListener)

// kotlin code
VPOperateManager.getInstance().readHeartWarning({

},object :IHeartWaringDataListener{
    override fun onHeartWaringDataChange(heartWaringData: HeartWaringData?) {

    }

})

VpSpGetUtil.getVpSpVariInstance(applicationContext).isSupportReadTempture

1.VpSpGetUtil.getVpSpVariInstance(applicationContext).isSupportReadTempture 2.VpSpGetUtil.getVpSpVariInstance(applicationContext).isSupportCheckTemptureByApp

startDetectTempture(bleWriteResponse, responseListener)

/**
* Return temperature data
*
* @param temptureDetectData Temperature data
*/
fun onDataChange(temptureDetectData:TemptureDetectData)

//        kotlin code
        VPOperateManager.getInstance().startDetectTempture({

        },object :ITemptureDetectDataListener{
            override fun onDataChange(temptureDetectData: TemptureDetectData?) {

            }
        })

//        kotlin code
VPOperateManager.getInstance().stopDetectTempture({

},null)

VpSpGetUtil.getVpSpVariInstance(requireContext()).isSupportReadTempture

readTemptureDataBySetting(bleWriteResponse, temptureDataListener, readOriginSetting)

//kotlin code
/**
* Callback for reading daily temperature data
*
* @param temptureDataList Temperature data list
*/
fun onTemptureDataListDataChange(temptureDataList:List<TemptureData>)

/***
* Returns the details of the reading. The location of this package needs to be remembered. When reading data next time, pass in the location of this package to avoid repeated reading
*
* @param day Data flag in the watch [0=today, 1=yesterday, 2=the day before yesterday]
* @param date Data date, format is yyyy-mm-dd
* @param allPackage Total number of packages of data for the day
* @param currentPackage Location of this package
*/
fun onReadOriginProgressDetail(day:Int, date:String, allPackage:Int, currentPackage：Int)

/**
* Returns the progress of reading
*
* @param progress Progress value, range [0-1]
*/
fun onReadOriginProgress(progress:Float)

/**
* Reading completed
*/
fun onReadOriginComplete()

//        kotlin code
if (!VpSpGetUtil.getVpSpVariInstance(applicationContext).isSupportReadTempture){
    return
}
VPOperateManager.getInstance().readTemptureDataBySetting({

},object :ITemptureDataListener{
    override fun onReadOriginProgressDetail(
        day: Int,
        date: String?,
        allPackage: Int,
        currentPackage: Int
    ) {
    }

    override fun onReadOriginProgress(progress: Float) {
    }

    override fun onReadOriginComplete() {
    }

    override fun onTemptureDataListDataChange(temptureDataList: MutableList<TemptureData>?) {
    }

}, readOriginSetting)

VpSpGetUtil.getVpSpVariInstance(applicationContext).isSupportECG

startDetectECG(bleWriteResponse, isNeedCurve, ecgDetectListener) 

/**
* Basic information of ECG measurement (waveform frequency, sampling frequency)
*
* @param ecgDetectInfo
*/
fun onEcgDetectInfoChange(ecgDetectInfo: EcgDetectInfo?)

/**
* Status during ECG measurement
*
* @param ecgDetectState
*/
fun onEcgDetectStateChange(ecgDetectState: EcgDetectState?)

/**
* The final result of ECG measurement, when abnormal, that is, when there is a disease, the value will be output
*
* @param ecgDetectResult
*/
fun onEcgDetectResultChange(ecgDetectResult: EcgDetectResult?)

/**
* ECG waveform data
*
* @param data
*
* * Draw the ecg waveform on the interface using this data. When drawing, you need to convert #data into a voltage value.
* Refer to [com.veepoo.protocol.util.EcgUtil.convertToMvWithValue] for the conversion method
* If the array data has no value, it means that reasonable waveform data has not been generated yet. When measuring ecg, the data will be updated continuously.
* When the data is Int.MAX_VALUE, that is, 2147483647 (hexadecimal is 0x7FFFFFFF), it is necessary to filter and not draw this point.
* * Fatigue operation callback, return fatigue data: whether it is supported, on/off status, progress, fatigue value
*
*/
fun onEcgADCChange(data: IntArray?)

//        kotlin code
if (!VpSpGetUtil.getVpSpVariInstance(applicationContext).isSupportECG){
    return
}
VPOperateManager.getInstance().startDetectECG({

},true,object :IECGDetectListener{
    override fun onEcgDetectInfoChange(ecgDetectInfo: EcgDetectInfo?) {
    }

    override fun onEcgDetectStateChange(ecgDetectState: EcgDetectState?) {
    }

    override fun onEcgDetectResultChange(ecgDetectResult: EcgDetectResult?) {
    }

    override fun onEcgADCChange(data: IntArray?) {
    }
})

stopDetectECG(bleWriteResponse, isNeedCurve, ecgDetectListener)

//kotlin code
VPOperateManager.getInstance()
    .stopDetectECG(bleWriteResponse, isNeedCurve, ecgDetectListener)

readECGData(bleWriteResponse, timeData, eEcgDataType, onReadDataIdFinishCallBack)

/**
* Data reading completed
*
* @param resultList ecg measurement array
*/
fun readDataFinish(resultList:List<EcgDetectResult>)

//        kotlin code
if (!VpSpGetUtil.getVpSpVariInstance(applicationContext).isSupportECG){
    return
}
val timedata = TimeData(0,0,0,0,0,0,0)
VPOperateManager.getInstance().readECGData({

},timedata,EEcgDataType.ALL,object :IECGReadDataListener{
    override fun readDataFinish(resultList: MutableList<EcgDetectResult>?) {

    }

})

readECGId(bleWriteResponse, timeData, eEcgDataType, onReadIdFinishCallBack)

/**
* Callback for the end of reading data ID
* @param ids ecg data id list
*/
fun readIdFinish(ids:IntArray?)

//        kotlin code
if (!VpSpGetUtil.getVpSpVariInstance(applicationContext).isSupportECG){
    return
}
val timedata = TimeData(0,0,0,0,0,0,0)
VPOperateManager.getInstance().readECGId({

},timedata,EEcgDataType.ALL,object :IECGReadIdListener{
    override fun readIdFinish(ids: IntArray?) {

    }
})

/**
* ECG switch status changed
*
* @param ecgFunctionStatus ecg function status: UNSUPPORT not supported, SUPPORT supported, SUPPORT_OPEN open, SUPPORT_CLOSE closed, UNKONW unknown
*/
fun onECGSwitchStatusChanged(ecgFunctionStatus:EFunctionStatus)

//        kotlin code
if (!VpSpGetUtil.getVpSpVariInstance(applicationContext).isSupportECG){
    return
}
VPOperateManager.getInstance().readECGSwitchStatus({

},object :IECGSwitchListener{
    override fun onECGSwitchStatusChanged(ecgFunctionStatus: EFunctionStatus?) {

    }
})

//        kotlin code
if (!VpSpGetUtil.getVpSpVariInstance(applicationContext).isSupportECG){
    return
}
VPOperateManager.getInstance().openECGSwitch({

},object :IECGSwitchListener{
    override fun onECGSwitchStatusChanged(ecgFunctionStatus: EFunctionStatus?) {

    }
})

//        kotlin code
if (!VpSpGetUtil.getVpSpVariInstance(applicationContext).isSupportECG){
    return
}
VPOperateManager.getInstance().closeECGSwitch({

},object :IECGSwitchListener{
    override fun onECGSwitchStatusChanged(ecgFunctionStatus: EFunctionStatus?) {

    }
})

//        kotlin code
if (!VpSpGetUtil.getVpSpVariInstance(applicationContext).isSupportECG){
    return
}
VPOperateManager.getInstance().startReadPttSignData({

},true,object :IECGDetectListener{
    override fun onEcgDetectInfoChange(ecgDetectInfo: EcgDetectInfo?) {
    }

    override fun onEcgDetectStateChange(ecgDetectState: EcgDetectState?) {
    }

    override fun onEcgDetectResultChange(ecgDetectResult: EcgDetectResult?) {
    }

    override fun onEcgADCChange(data: IntArray?) {
    }
})

if (!VpSpGetUtil.getVpSpVariInstance(applicationContext).isSupportECG){
    return
}
VPOperateManager.getInstance().stopReadPttSignData({

},true,object :IECGDetectListener{
    override fun onEcgDetectInfoChange(ecgDetectInfo: EcgDetectInfo?) {
    }

    override fun onEcgDetectStateChange(ecgDetectState: EcgDetectState?) {
    }

    override fun onEcgDetectResultChange(ecgDetectResult: EcgDetectResult?) {
    }

    override fun onEcgADCChange(data: IntArray?) {
    }
})

VpSpGetUtil.getVpSpVariInstance(applicationContext).isSupportHRV

readSleepData(bleWriteResponse, sleepReadDatalistener, watchday)

readSleepDataFromDay(bleWriteResponse, sleepReadDatalistener, day, watchday)

readSleepDataSingleDay(bleWriteResponse, sleepReadDatalistener, day, watchday)

readSleepDataBySetting(bleWriteResponse, sleepReadDatalistener, readSleepSetting)

/**
* Return data, sleep may be normal sleep or precision sleep,
* If it is precision sleep, it needs to be forced to convert to SleepPrecisionData
* There are two ways to judge:
* 1. According to the function flag after the password is passed;
* 2. According to the instanceof keyword, if (sleepData instanceof SleepPrecisionData)
*
* @param day indicates the data of which day is being read 0: today, 1: yesterday, 2: the day before yesterday.
* @param sleepData sleep data
*/
fun onSleepDataChange(day: String?, sleepData: SleepData?)

/**
* Returns the progress of sleep reading, range [0-1]
*
* @param progress progress
*/
fun onSleepProgress(progress: Float)

/**
* Returns the details of reading sleep. This interface is only used for testing, which is convenient for developers to view the reading progress
*
* @param day indicates the data of the day being read. The data of three days in a day is read in the order of today-yesterday-the day before yesterday
* @param packagenumber indicates the package number. The data of a day is returned starting from the largest package and decreasing in sequence
*/
fun onSleepProgressDetail(day: String?, packagenumber: Int)

/**
* Sleep reading ends
*/
fun onReadSleepComplete()

//kotlin code
VPOperateManager.getInstance().readSleepData({

},object :ISleepDataListener{
    override fun onSleepDataChange(day: String?, sleepData: SleepData?) {
    }

    override fun onSleepProgress(progress: Float) {
    }

    override fun onSleepProgressDetail(day: String?, packagenumber: Int) {
    }

    override fun onReadSleepComplete() {
    }

},3)

/**
* Screen style setting callback
*
* @param screenStyleData Screen style data
*/
fun onScreenStyleDataChange(screenStyleData:ScreenStyleData);

//        kotlin code
VPOperateManager.getInstance().readScreenStyle({

}, object : IScreenStyleListener {
    override fun onScreenStyleDataChange(screenStyleData: ScreenStyleData?) {

    }
}
)

settingScreenStyle(IBleWriteResponse bleWriteResponse, IScreenStyleListener screenStyleListener, int style)

//kotlin code
val uiFromType = EUIFromType.DEFAULT
val style = 2
VPOperateManager.getInstance().settingScreenStyle(
    {
        if (it != Code.REQUEST_SUCCESS) {
//                    Log.e("Test", "write cmd failed")
        }
    }, screenStyleListener, style, uiFromType
)

//kotlin code
val uiFromType = EUIFromType.DEFAULT
val style = 2
VPOperateManager.getInstance().settingScreenStyle(
    {
        if (it != Code.REQUEST_SUCCESS) {
//                    Log.e("Test", "write cmd failed")
        }
    }, screenStyleListener, style, uiFromType
)

val bigTranType = VpSpGetUtil.getVpSpVariInstance(applicactionContext).bigTranType
val serverUICount = VpSpGetUtil.getVpSpVariInstance(applicactionContext).watchuiServer
var isSupport = (bigTranType == 2 && serverUICount > 0)

val mUiUpdateUtil = UiUpdateUtil.getInstance();
val uiUpdateCheckOprate = UiServerHttpUtil();

//Support server dials
if (mUiUpdateUtil.isSupportChangeServerUi()) {
mUiUpdateUtil.init(context)
} else {
//Does not support server dials

}

/**
* Returns basic UI information - server,
*
* @param uiDataServer basic UI information - server UI
*/
fun onBaseUiInfoFormServer(uiDataServer:UIDataServer);

UiUpdateUtil.getInstance().getServerWatchUiInfo { uiDataServer ->
    //"2.服务器的表盘基本信息 uiDataServer:$uiDataServer"
}

getThemeInfo(uiDataServer, deviceNumber, deviceTestVersion, appPackName, appVersion):List<TUiTheme>

Thread {
    val appPackName = "com.timaimee.watch"
    val appVersion = "3.1.9"
    val themeInfoList = uiUpdateCheckOprate.getThemeInfo(
        mUiDataServer,
        deviceNumber,
        deviceTestVersion,
        appPackName,
        appVersion
    )
    //拿到themeInfoList 页面做展示
    
}.start()

/**
* Return the progress value of downloading firmware, range [0-1]
* @param progress
*/
fun onProgress(progress:Float);

/**
* Download completed
*/
fun onFinish();

Thread {
    uiUpdateCheckOprate.downloadFile(
        fileUrl,
        fileSave,
        object : OnDownLoadListener {
            override fun onProgress(progress: Float) {
                Logger.t(TAG).i("下载进度:$progress")
            }

            override fun onFinish() {
                Logger.t(TAG).i("下载完成")
            }
        })
}.start()

/**
* UI upgrade start callback
*/
fun onUiUpdateStart()

/**
* UI erase starts
* @param sumCount total erase size
*/
fun onStartClearCache(sumCount: Int)

/**
* UI erase progress callback
* @param currentCount current erase count
* @param sumCount total erase size
* @param progress erase progress
*/
fun onClearCacheProgress(currentCount: Int, sumCount: Int, progress: Int)

/**
* UI erase completes
*/
fun onFinishClearCache()

/**
* UI upgrade progress
* @param currentBlock current block
* @param sumBlock total block
* @param progress upgrade progress
*/
fun onUiUpdateProgress(currentBlock: Int, sumBlock: Int, progress: Int)

/**
* UI upgrade successful
*/
fun onUiUpdateSuccess()

/**
* UI update failed
* @param eUiUpdateError reason for upgrade failure
*/
fun onUiUpdateFail(eUiUpdateError: EUiUpdateError?)

al mUritempFile = Uri.fromFile(mUpdatefile)
val inputStream: InputStream =
    getContentResolver().openInputStream(mUritempFile)

/**
 * Upgrade UI steps: Start upgrade - Clear cache data - Send UI data -End sending
 */
UiUpdateUtil.getInstance().startSetUiStream(
    EUIFromType.SERVER,
    inputStream, object : IUiUpdateListener {
        override fun onUiUpdateStart() {
        }

        override fun onStartClearCache(sumCount: Int) {
        }

        override fun onClearCacheProgress(
            currentCount: Int,
            sumCount: Int,
            progress: Int
        ) {
        }

        override fun onFinishClearCache() {
        }

        override fun onUiUpdateProgress(
            currentBlock: Int,
            sumBlock: Int,
            progress: Int
        ) {
        }

        override fun onUiUpdateSuccess() {
        }

        override fun onUiUpdateFail(eUiUpdateError: EUiUpdateError?) {
        }

    }
)

if (mUiUpdateUtil.isSupportChangeCustomUi()) {
//Support custom dial
mUiUpdateUtil.init(context);
} else {
//Do not support custom dial

}

/**
* Return ui basic information - custom
*
* @param uiDataCustom ui basic information - custom ui
*/
fun onBaseUiInfoFormCustom(uiDataCustom:UIDataCustom);

mUiUpdateUtil.getCustomWatchUiInfo(IUIBaseInfoFormCustomListener { uiDataCustom ->
	
})

/**
* Returns basic UI information - custom UI
*
* @param uiDataCustom basic UI information - custom UI
*/
fun onBaseUiInfoFormCustom(uiDataCustom:UIDataCustom);

val timePosition: EWatchUIElementPosition = EWatchUIElementPosition.LEFT_TOP
val upTimeType: EWatchUIElementType = EWatchUIElementType.HEART
val downTimeType: EWatchUIElementType = EWatchUIElementType.STEP
val fontColor: Int = 0xffffff
val uiCustomSetData =
    UICustomSetData(isDefalutUI, timePosition, upTimeType, downTimeType, fontColor)
UiUpdateUtil.getInstance().setCustomWacthUi(uiCustomSetData,
    IUIBaseInfoFormCustomListener { uiDataCustom ->
        val watchColor = uiDataCustom.color888
        val hexColor = ColorUtil.intColorToHexStr(watchColor)
       /**
        * Although the color on the app and the color on the device have the same color value, there will be a difference in display
        * Because the App can display RCG_888, and the device can only display RGB_565
        * So for the display effect, it is best to make a mapping table yourself,
        * For example, if the color A1 on the app and the color A2 on the device are similar, then the color A1 is displayed on the app, and the color A2 is sent to the device.
        */
    })

inputStream = resources.assets.open(fileName)
val bmp = BitmapFactory.decodeStream(inputStream) //原图
val sendInputStream: InputStream =
    mWatchUIType.getSendInputStream(context, bmp)
UiUpdateUtil.getInstance().startSetUiStream(
    EUIFromType.CUSTOM,
    sendInputStream,
    object : IUiUpdateListener {
        override fun onUiUpdateStart() {
        }

        override fun onStartClearCache(sumCount: Int) {
        }

        override fun onClearCacheProgress(
            currentCount: Int,
            sumCount: Int,
            progress: Int
        ) {
        }

        override fun onFinishClearCache() {
        }

        override fun onUiUpdateProgress(
            currentBlock: Int,
            sumBlock: Int,
            progress: Int
        ) {
        }

        override fun onUiUpdateSuccess() {
        }

        override fun onUiUpdateFail(eUiUpdateError: EUiUpdateError) {
        }
    })

/**
* Not supported by mobile phone
*/
fun unSupportFindDeviceByPhone()
/**
* The device has been found
*/
fun foundedDevice()
/**
* The search timed out
*/
fun unFindDevice()
/**
* The device is vibrating and the screen is on, and it is in the search state
*/
fun findingDevice()

//        kotlin code
        if (!VpSpGetUtil.getVpSpVariInstance(applicationContext).isSupportFindDevice){
            return
        }
        VPOperateManager.getInstance().startFindDeviceByPhone({

        },object :IFindDevicelistener{
            override fun unSupportFindDeviceByPhone() {
            }

            override fun findedDevice() {
            }

            override fun unFindDevice() {
            }

            override fun findingDevice() {
            }
        })

//        kotlin code
        if (!VpSpGetUtil.getVpSpVariInstance(applicationContext).isSupportFindDevice){
            return
        }
        VPOperateManager.getInstance().stopFindDeviceByPhone({

        },object :IFindDevicelistener{
            override fun unSupportFindDeviceByPhone() {
            }

            override fun findedDevice() {
            }

            override fun unFindDevice() {
            }

            override fun findingDevice() {
            }
        })