01. Overview and Initialization - shenjudev/UNIWatchMate-Android-Sample GitHub Wiki

1.1 UNIWatchMate

  • Perform operations such as initialization, scanning, searching, reconnection, and restarting devices using UNIWatchMate.
package com.base.sdk

import com.base.sdk.entity.WmBindInfo
import com.base.sdk.entity.WmDevice
import com.base.sdk.entity.WmDeviceModel
import com.base.sdk.entity.WmMuslimLocation
import com.base.sdk.entity.WmSupportTypeBean
import com.base.sdk.entity.common.WmDiscoverDevice
import com.base.sdk.entity.apps.WmConnectState
import com.base.sdk.entity.common.WmDeviceStorageInfo
import com.base.sdk.entity.common.WmStorageType
import com.base.sdk.entity.common.WmTimeUnit
import com.base.sdk.entity.data.WmBatteryInfo
import com.base.sdk.entity.settings.WmDeviceInfo
import com.base.sdk.entity.settings.WmFunctionSupport
import com.base.sdk.port.AbWmSyncTestFile
import com.base.sdk.port.log.AbWmLog
import com.base.sdk.port.AbWmTransferFile
import com.base.sdk.port.app.AbWmApps
import com.base.sdk.port.setting.AbWmSettings
import com.base.sdk.port.sync.AbWmSyncs
import io.reactivex.rxjava3.core.Completable
import io.reactivex.rxjava3.core.Observable
import io.reactivex.rxjava3.core.Single

/**
 * sdk接口抽象类
 * 封装了几大功能模块
 * sdk需要实现此接口，并实现每一个功能模块下的功能
 * 拿到此接口实例即可操作sdk实现的所有功能
 *
 * sdk interface abstract class
 * Encapsulates several major functional modules
 * The sdk implementation class needs to implement this interface and implement the functions under each functional module
 * App can operate all functions implemented by sdk after getting an instance of this interface implementation class.
 */
abstract class AbUniWatch {
    companion object {
        var mSupportDeviceTypeList: List<WmSupportTypeBean> =
                arrayListOf()
    }

    /**
     * 设置模块(Settings module)
     */
    abstract val wmSettings: AbWmSettings

    /**
     * 应用模块(Application module)
     */
    abstract val wmApps: AbWmApps

    /**
     * 同步模块(Sync module)
     */
    abstract val wmSync: AbWmSyncs

    /**
     * 文件传输(File transfer)
     */
    abstract val wmTransferFile: AbWmTransferFile

    /**
     * 测试文件同步(Test file sync)
     */
    abstract val wmSyncTestFile: AbWmSyncTestFile

    /**
     * 日志(Log)
     */
    abstract val wmLog: AbWmLog

    /**
     * 是否支持日志打印(Whether to print log)
     * @param logEnable Whether to print log
     */
    abstract fun setLogEnable(logEnable: Boolean)

    /**
     * 扫描二维码连接(connect by scanning qr code)
     * @return if the return value is null, it means that the device type cannot be recognized
     */
    abstract fun connectBtDevice(
            bindInfo: WmBindInfo,
    ): WmDevice?

    /**
     * 断开连接(Disconnect)
     */
    abstract fun disconnect()

    /**
     * 恢复出厂设置(Restore factory settings)
     */
    abstract fun reset(): Completable

    /**
     * 关机(power off)
     */
    abstract fun powerOff(): Single<Int>

    /**
     * 发送自定义消息回复(send custom msg)
     * 1 成功
     * 0 失败
     *
     * return
     * 1 发送成功
     * 0 发送失败
     */
    abstract fun sendCustomDataResponse(respondData: ByteArray): Single<Int>

    /**
     * 监听连接状态(Observe connect state)
     */
    abstract val observeConnectState: Observable<WmConnectState>

    /**
     * 获取连接状态(Get connect state)
     */
    abstract fun getConnectState(): WmConnectState

    /**
     * 获取当前设备模式(Get current device mode)
     * @return null if the current device mode is not supported
     */
    abstract fun getDeviceModel(): WmDeviceModel?

    /**
     * 设置设备模式，支持多个SDK实现(Set device mode, support multiple SDK implementations)
     * If a SDK supports multiple modes, save the current mode so that [getDeviceModel] can be obtained.
     *
     * @param wmDeviceModel device model
     * @return if the return value is false, it means that the device mode is not supported
     */
    abstract fun setDeviceModel(wmDeviceModel: WmDeviceModel): Boolean

    /**
     * 监听系统蓝牙回连事件(Observe reconnect event)
     */
    abstract val observeConnectBack: Observable<String>

    /**
     * App当前连接的设备(App current connected device)
     */
    abstract fun setAppCurrentDevice(wmDevice: WmDevice)

    /**
     * 获取设备信息(Get device information)
     */
    abstract fun getDeviceInfo(): Single<WmDeviceInfo>

    /**
     * 获取电量信息(Get battery information)
     */
    abstract fun getBatteryInfo(): Single<WmBatteryInfo>

    /**
     * 获取设备存储空间信息(Get device storage space information)
     */
    abstract fun getDeviceStorageInfo(memoryType: WmStorageType): Single<WmDeviceStorageInfo>

    /**
     * 监听电量信息变化(Observe battery information change)
     */
    abstract val observeBatteryChange: Observable<WmBatteryInfo>

    /**
     * 监听设备端自定的数据(Observe Custom Data From Device)
     */
    abstract val observeCustomDataFromDevice: Observable<ByteArray>

    /**
     * 开始扫描设备(Start scanning device)
     *
     * @param scanTime 扫描时间(scan time, unit: second)
     * @param wmTimeUnit 扫描时间单位(scan time unit)
     * @param deviceModel 设备类型(device type)
     * @param tag 过滤设备名字前/后缀(filter device name prefix/suffix, eg. oraimo Watch Neo)
     */
    abstract fun startDiscovery(
            scanTime: Int,
            wmTimeUnit: WmTimeUnit,
            deviceModel: WmDeviceModel,
            tag: String
    ): Observable<WmDiscoverDevice>

    /**
     * 停止蓝牙扫描(Stop Bluetooth scanning)
     */
    abstract fun stopDiscovery()

    /**
     * 设备重启(Device reboot)
     */
    abstract fun reboot(): Single<Boolean>

    /**
     * 删除配对关系(Delete pairing relationship)
     */
    abstract fun removeBond(address: String): Boolean

    abstract fun release()

    /**
     * 查询功能清单配置(Query function list configuration)
     */
    abstract fun getFunctionSupportState(): WmFunctionSupport

    /**
     * 设置支持的设备型号
     */
    open fun setSupportDeviceTypeList(deviceTypeList: List<WmSupportTypeBean>?) {
        deviceTypeList?.let {
            mSupportDeviceTypeList = it
        }
    }

    /**
     * 设置经纬度/时区
     */
    abstract fun setLocation(wmMuslimLocation: WmMuslimLocation): Single<Boolean>

}

1.2 AbWmApps

  • Use UNIWatchMate.wmApps for application-related operations. The interface layer is AbWmApps.
 /**
 * 应用模块功能聚合(The application module function collection)
 */
abstract class AbWmApps {
    /**
     * 闹钟功能(The alarm function)
     */
    abstract val appAlarm: AbAppAlarm

    /**
     * 相机功能(The camera function)
     */
    abstract val appCamera: AbAppCamera

    /**
     * 通讯录(The address book)
     */
    abstract val appContact: AbAppContact

    /**
     * 查找功能(The find function)
     */
    abstract val appFind: AbAppFind

    /**
     * 天气功能(The weather function)
     */
    abstract val appWeather: AbAppWeather

    /**
     * 运动功能(The sport function)
     */
    abstract val appSport: AbAppSport

    /**
     * 通知功能(The notification function)
     */
    abstract val appNotification: AbAppNotification

    /**
     * 表盘(The dial)
     */
    abstract val appDial: AbAppDial

    /**
     * 语言(The language)
     */
    abstract val appLanguage: AbAppLanguage

    /**
     * 音乐控制(The music control)
     */
    abstract val appMusicControl: AbAppMusicControl

    /**
     * 时间设置(The time setting)
     */
    abstract val appDateTime: AbAppDateTime

    /**
     * 组件设置(The component setting)
     */
    abstract val appWidget: AbAppWidget

    /**
     * 监听电话挂断事件(The listen phone hang up event)
     */
    abstract val appPhone: AbAppPhone

    /**
     * 导航(The navigation)
     */
    abstract val appNavigation: AbAppMapNavigation

    /**
     * 数据采集（The data collection)
     */
    abstract val appSensorCollector: AbAppSensorCollector

    /**
     * 穆斯林（muslim)
     */
    abstract val appMuslim: AbAppMuslim

    /**
     * 快捷恢复（quick reply)
     */
    abstract val appQuickReply: AbAppQuickReply

}

1.3 AbWmSettings

  • Use UNIWatchMate.AbWmSettings for setting-related operations. The interface layer is AbWmSettings.
abstract class AbWmSettings {
    /**
    * Sport goal setting
    */
    abstract val settingSportGoal: AbWmSetting<WmSportGoal>

    /**
    * Personal information setting
    */
    abstract val settingPersonalInfo: AbWmSetting<WmPersonalInfo>

    /**
    * Sedentary reminder
    */
    abstract val settingSedentaryReminder: AbWmSetting<WmSedentaryReminder>

    /**
    * Sound and haptic setting
    */
    abstract val settingSoundAndHaptic: AbWmSetting<WmSoundAndHaptic>

    /**
    * Unit info setting
    */
    abstract val settingUnitInfo: AbWmSetting<WmUnitInfo>

    /**
    * Wrist raise setting
    */
    abstract val settingWistRaise: AbWmSetting<WmWistRaise>

    /**
    * App view setting
    */
    abstract val settingAppView: AbWmSetting<WmAppView>

    /**
    * Drink water reminder setting
    */
    abstract val settingDrinkWater: AbWmSetting<WmSedentaryReminder>

    /**
    * Heart rate reminder setting
    */
    abstract val settingHeartRate: AbWmSetting<WmHeartRateAlerts>

    /**
    * Sleep setting
    */
    abstract val settingSleepSettings: AbWmSetting<WmSleepSettings>
  }

1.4 AbWmSyncs

  • Use UNIWatchMate.AbWmSyncs for data synchronization-related operations. The interface layer is AbWmSyncs.
/**
 * Synchronize data
 */
abstract class AbWmSyncs {
    /**
     * Sync steps
     */
    abstract val syncStepData: AbSyncData<List<WmStepData>>

    /**
     * Sync oxygen
     */
    abstract val syncOxygenData: AbSyncData<List<WmOxygenData>>

    /**
     * Sync calories
     */
    abstract val syncCaloriesData: AbSyncData<List<WmCaloriesData>>

    /**
     * Sync sleep
     */
    abstract val syncSleepData: AbSyncData<List<WmSleepData>>

    /**
     * Sync real-time heart rate
     */
    abstract val syncRealtimeRateData: AbSyncData<List<WmRealtimeRateData>>

    /**
     * Sync average heart rate
     */
    abstract val syncHeartRateData: AbSyncData<List<WmHeartRateData>>

    /**
     * Sync distance
     */
    abstract val syncDistanceData: AbSyncData<List<WmDistanceData>>

    /**
     * Sync daily activity
     */
    abstract val syncActivityDurationData: AbSyncData<WmSyncData<WmActivityDurationData>>

    /**
     * Sync sports summary
     */
    abstract val syncSportSummaryData: AbSyncData<List<WmSportSummaryData>>

    /**
     * Sync today's data
     */
    abstract val syncDailyActivityDuration: AbSyncData<WmSyncData<WmDailyActivityDurationData>>

    /**
     * Sync all data
     */
    abstract val syncAllData: AbSyncData<WmSyncData<out WmBaseSyncData>>
}
  • Use UNIWatchMate.wmTransferFile for file transfer (OTA, installing dials, music, etc.) related operations, AbWmTransferFile.
// OTA operation
 val fileList = mutableListOf<File>()
  fileList.add(otaFile)
UNIWatchMate.wmTransferFile.startTransfer(FileType.OTA_UPEX, fileList)
                            .asFlow()
                            .catch {
                                dealThrowable(it)
                            }
                            .collect {
                                otaFileResult(it)
                            }

/**
 * File transfer type
 */
enum class FileType(val type: Int) {
    MUSIC(1),// MP3 type
    OTA(2),// Device ota
    DIAL(3),// Dial
    DIAL_COVER(4),// Dial cover
    OTA_UPEX(5),// Device ota_upex
    TXT(6),
    AVI(7),
    SPORT(8),// Sport file (spare, undecided)
}

1.5 Initialization

sample project: Refer to uniWatchInit.kt.

Call UNIWatchMate's init method to register the device operation object to be used. Different manufacturers may have different objects, as shown in the code below.

 //配置支持不同厂商的手表(Configurations Support watches from different manufacturers)
    val sjUniWatch = SJUniWatchImpl(application, 10000,"");//绅聚设备操作对象(shenju device operation objects)
    
    sjUniWatch.setLogEnable(true)
    val supportDeviceList = arrayListOf<WmSupportTypeBean>()

    supportDeviceList.add(
        WmSupportTypeBean("T09",
            "T09",
            "https://cdniotpub.aiframe.net/media/spark/device/784a30834a783866bfe34a19be29a2c0/9eb573c72e183dfb932a7872230daa42.png",
            "https://cdniotpub.aiframe.net/media/spark/device/784a30834a783866bfe34a19be29a2c0/58f5ef91d2cb3026b8909447b30966b1.png")
    )

    supportDeviceList.add(
        WmSupportTypeBean("802N",
        "oraimo Watch Nova V",
        "https://cdniotpub.aiframe.net/media/spark/device/1279142e7dd9331bb8259d34acb81885/bc328ac1036a3ad48b8d0d68becc0aea.png",
        "https://cdniotpub.aiframe.net/media/spark/device/1279142e7dd9331bb8259d34acb81885/d404e8fb4c9333ab9352bb8743099b5f.png")
    )

    supportDeviceList.add(
        WmSupportTypeBean("Spark Watch",
            "Spark Watch",
            "https://cdniotpub.aiframe.net/media/spark/device/784a30834a783866bfe34a19be29a2c0/b34a75927b93366b9c7d41d9e4e3a67c.png",
            "https://cdniotpub.aiframe.net/media/spark/device/784a30834a783866bfe34a19be29a2c0/4a2ec1313e593ffabc3917f787927638.png")
    )

    sjUniWatch.setSupportDeviceTypeList(supportDeviceList)
    
    UNIWatchMate.init(
        application, listOf(
            sjUniWatch
        )
    )
⚠️ **GitHub.com Fallback** ⚠️