# JtoTestTools

**Repository Path**: singmong/jto-test-tools

## Basic Information

- **Project Name**: JtoTestTools
- **Description**: 杰拓Android蓝牙SDK
- **Primary Language**: Java
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2024-04-30
- **Last Updated**: 2025-01-13

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 杰拓Android 蓝牙SDK文档

# 一、环境配置
## 1.添加aar包
将jto-fit-sdk-Vxxx.aar包复制到app下的libs目录中
配置build.gradle

```
repositories {
    flatDir {
        dirs 'libs'
    }
}

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar', '*.aar'])
}
```


## 2.在AndroidManifest.xml中配置权限

```
<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
<uses-permission android:name="android.permission.BLUETOOTH_SCAN" />
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.BLUETOOTH_PRIVILEGED" />
```

## 3. 声明组件

```
<provider
    android:name="com.watch.jtofitsdk.BleContentProvider.JtoBleContentProvider"
    android:authorities="${applicationId}"
    android:exported="true"
    android:protectionLevel="signature" />
```

# 二、发送蓝牙数据
## 1. 初始化

```objective-c
//参数一：上下文，参数二：是否打印日志
JToBluetoothHelper.getInstance().initSDK(this, true);
//日志是否保存到文件
JToBluetoothHelper.getInstance().setPrintFile(true);
//日志打印
JToLog.i(TAG,"打印日志");
```

## 2.扫描设备
在权限允许和蓝牙开启的状态下，才能开始正常扫描。在扫描过程中发现设备时，通过OnScanDevListener()回调，扫描结束后，通过onScanDev()方法得到所有设备
### 2.1 初始化扫描监听

```java
JToBluetoothHelper.getInstance().scanningDeviceInit(JToApplication.getInstance(), new OnScanDevListener() {
    @Override
    public void onScanDev(int callbackType, ScanResult result, List<JToBleDevice> deviceList, JToBleDevice myBleDevice) {
        JToLog.i(TAG,"扫描到的设备");
    }

    @Override
    public void onScanError(int errorCode) {
        //扫描异常
    }

    @Override
    public void onJLScanDev(JToBleDevice device) {
        
    }

    @Override
    public void onScanComplete(boolean isReconnect) {
        JToLog.i(TAG,"扫描完成");
    }
});
```

### 2.2 开始扫描
`JToBluetoothHelper.getInstance().startScan();`
### 2.3 停止扫描
`JToBluetoothHelper.getInstance().stopScan();`
## 3.蓝牙连接与断开
### 3.1 连接蓝牙
`JToBluetoothHelper.getInstance().connectDev(device);`
### 3.2 蓝牙重连
如果返回true，说明正在重连中，如果返回false，说明不可重连

`JToBluetoothHelper.getInstance().reConnectDev();`

### 3.3 蓝牙是否连接
`JToBluetoothHelper.getInstance().isConnectOk();`

### 3.6 配对
蓝牙连接成功后，进行配对操作

`JToBluetoothHelper.getInstance().startSyncPair(0);`

### 3.5 断开蓝牙
解绑设备步骤：
1. 在已连接状态下，先发送解绑指令，等待手表返回解绑成功指令(查看第三大点的第9小点)。
2. 收到解绑成功指令后，招执行断开蓝牙操作。
3. 如果在未连接状态下，直接执行断开蓝牙操作即可。

```
//解绑指令
JToBluetoothHelper.getInstance().getSendBlueData().setSystemControl(3);
//断开蓝牙ble
JToBluetoothHelper.getInstance().disConnect(true);//true断开经典蓝牙bt，false不断开经典蓝牙bt
```

### 3.6 蓝牙是否可用(是否打开)
`JToBluetoothHelper.getInstance().isEnabled();`
## 4.请求历史数据
时间戳为0:表示请求所有历史数据，不为0：表示从该时间戳开始到当前时间的历史数据，接收历史回调数据，请查看第三大点
### 4.1 请求心率历史数据
`JToBluetoothHelper.getInstance().getSendBlueData().getHisHeart("时间戳")`
### 4.2 请求血氧历史数据
`JToBluetoothHelper.getInstance().getSendBlueData().getHisBO2("时间戳")`
### 4.3 请求血压历史数据
`JToBluetoothHelper.getInstance().getSendBlueData().getHisBP("时间戳");`
### 4.4 请求日常活动历史数据
`JToBluetoothHelper.getInstance().getSendBlueData().getHisSteps("时间戳");`
### 4.5 请求睡眠历史数据
JToBluetoothHelper.getInstance().getSendBlueData().getHisSleep("时间戳");
## 5.天气
### 5.1 实时天气

```
JTo_DATA_TYPE_weatherRT jToDataTypeWeatherRT = new JTo_DATA_TYPE_weatherRT();
jToDataTypeWeatherRT.setHour(9);//时
jToDataTypeWeatherRT.setMin(32);//分
jToDataTypeWeatherRT.setTemperature(28);//温度
jToDataTypeWeatherRT.setClimate(1);//天气
jToDataTypeWeatherRT.setWind_scale(1);//风力
jToDataTypeWeatherRT.setHumidity(81);//百分比数值
jToDataTypeWeatherRT.setPressure(1006);//默认单位：百帕
jToDataTypeWeatherRT.setVisibility(30);//默认单位：公里

JToBluetoothHelper.getInstance().getSendBlueData().sendWeatherNow(jToDataTypeWeatherRT);
```

### 5.2 未来24小时天气

```
JTo_DATA_TYPE_WEATHER24 jToDataTypeWeather24 = new JTo_DATA_TYPE_WEATHER24();
jToDataTypeWeather24.setHour(9);//时
jToDataTypeWeather24.setMin(10);//分
List<JTo_DATA_TYPE_WEATHER24.WeatherData> list = new ArrayList<>();
for (Weather24Bean.WeatherData data : weather24Bean.getList()) {
    JTo_DATA_TYPE_WEATHER24.WeatherData weatherData = new JTo_DATA_TYPE_WEATHER24.WeatherData();
    weatherData.setClimate(data.getClimate());//天气 1
    weatherData.setTemperature(data.getTemperature());//温度 29
    weatherData.setHumidity(data.getHumidity());//湿度 75
    weatherData.setUvIndex(data.getUvIndex());//紫外线
    list.add(weatherData);
}
jToDataTypeWeather24.setList(list);
JToBluetoothHelper.getInstance().getSendBlueData().sendWeather24(jToDataTypeWeather24);
```

### 5.3 未来7天天气

```
JTo_DATA_TYPE_WEATHERDAYS jToDataTypeWeatherDays = new JTo_DATA_TYPE_WEATHERDAYS();
jToDataTypeWeatherDays.setDateTime(1714982400);
jToDataTypeWeatherDays.setFutureDays(7);
List<JTo_DATA_TYPE_WEATHERDAYS.WeatherData> list = new ArrayList<>();
for (Weather7DaysBean.WeatherData data : weather7DaysBean.getList()) {
    JTo_DATA_TYPE_WEATHERDAYS.WeatherData weatherData = new JTo_DATA_TYPE_WEATHERDAYS.WeatherData();
    weatherData.setClimate(data.getClimate());//天气
    weatherData.setSunrise(data.getSunrise());//日出时间
    weatherData.setSunset(data.getSunset());//日落时间
    weatherData.setMaxTemperature(data.getMaxTemperature());//最高温度
    weatherData.setMinTemperature(data.getMinTemperature());//最低温度
    weatherData.setDaytimeHumidity(data.getDaytimeHumidity());//日间湿度
    weatherData.setNightHumidity(data.getNightHumidity());//夜间湿度
    weatherData.setDaytimeUltravioletIndex(data.getDaytimeUltravioletIndex());//日间紫外线指数
    weatherData.setNightUltravioletIndex(data.getNightUltravioletIndex());//夜间紫外线指数
    list.add(weatherData);
}
jToDataTypeWeatherDays.setList(list);
JToBluetoothHelper.getInstance().getSendBlueData().sendWeatherDays(jToDataTypeWeatherDays);
```

### 5.4 日出日落时刻

```
JTo_DATA_TYPE_CITYSUNSET jToDataTypeCitySunset = new JTo_DATA_TYPE_CITYSUNSET();
if (!TextUtils.isEmpty(city)) {
    jToDataTypeCitySunset.setCityName("城市名");
    jToDataTypeCitySunset.setCityLen(3);//城市名长度
}
if (list != null && list.size() > 0) {
    //日出时刻
    jToDataTypeCitySunset.setSunriseHour(5);//时
    jToDataTypeCitySunset.setSunriseMin(50);//分
    //日落时刻
    jToDataTypeCitySunset.setSunsetHour(18);//时
    jToDataTypeCitySunset.setSunsetMin(50);//分
}
JToBluetoothHelper.getInstance().getSendBlueData().sendCitySunSet(jToDataTypeCitySunset);
```

## 6. APP运动
### 6.1 开始运动

```
JTo_DATA_TYPE_SPORTMULTI jToDataTypeSportMulti = new JTo_DATA_TYPE_SPORTMULTI();
jToDataTypeSportMulti.setSportType(1);//运动类型，查看第三大点第8小点多运动
jToDataTypeSportMulti.setSubCMD(JToAction.SUB_CMD.TWO);
JToBluetoothHelper.getInstance().getSendBlueData().sendSportMulti(jToDataTypeSportMulti);
```

### 6.2 暂停运动

```
JTo_DATA_TYPE_SPORTMULTI jToDataTypeSportMulti = new JTo_DATA_TYPE_SPORTMULTI();
jToDataTypeSportMulti.setSportType(1);//运动类型，查看第三大点第8小点多运动
jToDataTypeSportMulti.setSportStatus(JTo_DATA_TYPE_SPORTMULTI.SPORT_STATUS_PAUSE);//暂停状态
jToDataTypeSportMulti.setSubCMD(JToAction.SUB_CMD.THREE);
JToBluetoothHelper.getInstance().getSendBlueData().sendSportMulti(jToDataTypeSportMulti);
```

### 6.3 停止运动

```
JTo_DATA_TYPE_SPORTMULTI jToDataTypeSportMulti = new JTo_DATA_TYPE_SPORTMULTI();
jToDataTypeSportMulti.setSportType(1);//运动类型，查看第三大点第8小点多运动
jToDataTypeSportMulti.setSportStatus(JTo_DATA_TYPE_SPORTMULTI.SPORT_STATUS_STOP);//停止状态
jToDataTypeSportMulti.setSubCMD(JToAction.SUB_CMD.THREE);
JToBluetoothHelper.getInstance().getSendBlueData().sendSportMulti(jToDataTypeSportMulti);
```

### 6.4 发送实时运动数据

```
JTo_DATA_TYPE_SPORTMULTI jToDataTypeSportMulti = new JTo_DATA_TYPE_SPORTMULTI();
jToDataTypeSportMulti.setSubCMD(JToAction.SUB_CMD.FIVE);
jToDataTypeSportMulti.setSportType(1);//运动类型
jToDataTypeSportMulti.setSteps(100);//步数
jToDataTypeSportMulti.setDistance(100);//距离，单位米
jToDataTypeSportMulti.setCalorie(10);//卡路里
jToDataTypeSportMulti.setDuration(500);//运动时长 ，单位秒
jToDataTypeSportMulti.setPacing();// 配速
jToDataTypeSportMulti.setCadence();// 步频
JToBluetoothHelper.getInstance().getSendBlueData().sendSportMulti(jToDataTypeSportMulti);
```

## 7. app前后台标志
0:APP处于前台，1:APP处于后台
`JToBluetoothHelper.getInstance().getSendBlueData().setAppFB(0);`
## 8. 获取相关数据

```
//蓝牙名
JtoBlueCpProxy.getInstance().getDeviceName();
//蓝牙地址
JtoBlueCpProxy.getInstance().getDevAddress();
//手表屏幕宽
JtoBlueCpProxy.getInstance().getScreenWidth();
//手表屏幕高
JtoBlueCpProxy.getInstance().getScreenHigh();
//手表屏幕形状
JtoBlueCpProxy.getInstance().getScreenShape();
//电量
JtoBlueCpProxy.getInstance().getBatValue();
//项目编号
JtoBlueCpProxy.getInstance().getProjectNumber();
//固件版本
JtoBlueCpProxy.getInstance().getDevVersion();
//字库版本
JtoBlueCpProxy.getInstance().getFontVersion();
//UI库版本
JtoBlueCpProxy.getInstance().getPicVersion()
//蓝牙连接状态
JtoBlueCpProxy.getInstance().getConnectStatus();
```

## 9. 消息推送
### 9.1 消息类型

```
public static final byte TYPE_QQ = 0; //QQ消息
public static final byte TYPE_WX = 1; //微信消息
public static final byte TYPE_MSG = 2; //短信消息
public static final byte TYPE_OTHER = 3; //其他消息
public static final byte TYPE_FACEBOOK = 4; //Facebook  
public static final byte TYPE_TWITTER = 5; //Twitter 
public static final byte TYPE_WHATSAPP = 6; //WhatsApp
public static final byte TYPE_SKYPE = 7; //Skype
public static final byte TYPE_FACEBOOK_MESSENGER = 8; //Facebook Messenger
public static final byte TYPE_Hangouts = 9;
public static final byte TYPE_LINE = 10;
public static final byte TYPE_LINKED_IN = 11;
public static final byte TYPE_INSTAGRAM = 12;
public static final byte TYPE_Viber = 13;
public static final byte TYPE_KAKAO = 14;
public static final byte TYPE_VKontakte = 15;
public static final byte TYPE_Snapchat = 16;
public static final byte TYPE_Google_plus = 17;
public static final byte TYPE_EMAIL = 18;
public static final byte TYPE_Flickr = 19;
public static final byte TYPE_Tumblr = 20;
public static final byte TYPE_Pinterest = 21;
public static final byte TYPE_YouTube = 22;
public static final byte TYPE_TELEGRAM = 23;
public static final byte TYPE_Truecaller = 24;
public static final byte TYPE_Paytm = 25;//com.one97.paytm
public static final byte TYPE_Zalo = 26;
public static final byte TYPE_imo = 27;
public static final byte TYPE_Microsoft_Teams = 28;
public static final byte TYPE_Outlook = 29;
public static final byte TYPE_Swiggy = 30;//bundl.swiggy
public static final byte TYPE_Zomato = 31;//com.zomato.zomato
public static final byte TYPE_Gpay = 32;//com.google.paisa
public static final byte TYPE_PhonePe = 33;//com.phonepe.PhonePeApp
public static final byte TYPE_Hotstar = 34;//in.startv.hotstar
public static final byte TYPE_PrimeVideo = 35;//com.amazon.aiv.AIVApp
public static final byte TYPE_Flipkart = 36;//com.appflipkart.flipkart
public static final byte TYPE_Amazon = 37;//com.amazon.AmazonIN
public static final byte TYPE_Myntra = 38;//
public static final byte TYPE_NoiseApp = 39;//
public static final byte TYPE_DailyHunt = 40;//
public static final byte TYPE_Inshorts = 41;//com.nis.app
public static final byte TYPE_BookMyShow = 42;//
public static final byte TYPE_Calendar = 43;//com.google.android.calendar
public static final byte TYPE_Jio_Tv = 44;//com.jio.jioplay
public static final byte TYPE_Make_My_Trip = 45;//com.Iphone.MMT
public static final byte TYPE_Netflix = 46;//com.netflix.Netflix
public static final byte TYPE_Ola = 47;//olacabs.OlaCabs
public static final byte TYPE_Reflex = 48;//com.titan.fastrack.reflex
public static final byte TYPE_Uber = 49;//com.ubercab.UberClient
public static final byte TYPE_YT_Music = 50;//com.google.ios.youtubemusic
public static final byte TYPE_WhatsApp_Business = 51;//com.whatsapp.w4b
public static final byte TYPE_Dunzo = 52;//com.dunzo.user
public static final byte TYPE_Gaana = 53;//com.gaana
public static final byte TYPE_Google_Drive = 54;//com.google.android.apps.docs
public static final byte TYPE_googlechat = 55;//com.google.android.apps.docs
public static final byte TYPE_Wynk_music = 56;//com.bsbportal.music
public static final byte TYPE_Yahoo = 57;//com.yahoo.mobile.client.android.mail
public static final byte TYPE_Titan_Smart_World = 58;//com.titan.smartworld
public static final byte TYPE_Slack = 59;//com.Slack
public static final byte TYPE_Spotify = 60;//com.spotify.music
```

### 9.3 发送消息

```
JTo_DATA_TYPE_MESSAGE msg = new JTo_DATA_TYPE_MESSAGE();
msg.setSubCMD(JToAction.SUB_CMD.SIX);
msg.setMsgId(JTo_DATA_TYPE_MESSAGE.TYPE_WX);//消息类型
msg.setMsgTitle("标题");
msg.setMsgContent("消息内容");
JToBluetoothHelper.getInstance().getSendBlueData().sendAppMessage(msg);
```

## 10. 遥控拍照
0 进入，1 退出，2 拍照
`JToBluetoothHelper.getInstance().getSendBlueData().sendTakePhoto(1);`
## 11. 闹钟
### 11.1 新增闹钟

```
JTo_DATA_TYPE_ALARM alarmData = new JTo_DATA_TYPE_ALARM();
//设置一个闹钟
JTo_DATA_TYPE_ALARM.AlarmItem alarmItem = new JTo_DATA_TYPE_ALARM.AlarmItem();
alarmItem.setSwitchStatus(1);//闹钟开关 1打开 0关闭
alarmItem.setWeek_repeat(0);//重复周期，0表示单次，bit0-bit6依次表示周日-周六
alarmItem.setHour(presenter.hour);//时
alarmItem.setMin(presenter.min);//分

alarmData.getAlarmList().add(item);//在原有的闹钟列表中，加入新增的闹钟
alarmData.setAlarmNum(alarmData.getAlarmList().size());

//将所有闹钟发送至手表
JToBluetoothHelper.getInstance().getSendBlueData().setAlarm(alarmData);
```

### 11.2 修改闹钟
修改好其中一个闹钟后，再将闹钟列表重新发送至手表即可

```
//将所有闹钟发送至手表
JToBluetoothHelper.getInstance().getSendBlueData().setAlarm(alarmData);
```

### 11.3 删除闹钟
删除闹钟列表中的指定闹钟，然后将闹钟列表重新发送至手表即可

```
alarmData.getAlarmList().remove(position);
alarmData.setAlarmNum(alarmData.getAlarmList().size());
//将所有闹钟发送至手表
JToBluetoothHelper.getInstance().getSendBlueData().setAlarm(alarmData);
```

## 12. 通讯录
同步联系数据，请查看第三大点的第11小点
### 12.1 添加联系人

```
//添加联系人列表
List<JTo_DATA_TYPE_CONTACTS.MultipleContacts> contactsList = new ArrayList<JTo_DATA_TYPE_CONTACTS.MultipleContacts>();
JTo_DATA_TYPE_CONTACTS.MultipleContacts contacts = new JTo_DATA_TYPE_CONTACTS.MultipleContacts();
contacts.setName("姓名");
contacts.setPhone("电话号码");
contactsList.add(contacts)

//将联系人封装到JTo_DATA_TYPE_CONTACTS对象中
JTo_DATA_TYPE_CONTACTS jtoDataTypeContacts = new JTo_DATA_TYPE_CONTACTS();
jtoDataTypeContacts.setSubCMD(JToAction.SUB_CMD.FOUR);
jtoDataTypeContacts.setList(contactsList);
jtoDataTypeContacts.setTotal(contactsList.size());

//发送联系数据
JToBluetoothHelper.getInstance().getTransfer().sendContacts(jToDataTypeContacts);
```

### 12.2 删除联系人

```
jtoDataTypeContacts.setDelIndex(position);//要删除的联系人在列表中的角标
jtoDataTypeContacts.setSubCMD(JToAction.SUB_CMD.SEVEN);
JToBluetoothHelper.getInstance().getTransfer().sendContacts(jToDataTypeContacts);
```

## 13. 单位设置

```
JTo_DATA_TYPE_SETUNIT jToDataTypeSetUnit = new JTo_DATA_TYPE_SETUNIT();
jToDataTypeSetUnit.setUnitLength(0);//距离 0国际（米，千米，公里==），1英制（英里，码==）
jToDataTypeSetUnit.setUnitTemperature(0);//温度  0摄氏度C，1华氏度F
jToDataTypeSetUnit.setUnitTime(0);//时间  0:24小时制，1:12小时制
JToBluetoothHelper.getInstance().getSendBlueData().setUnitSettings(jToDataTypeSetUnit);
```

## 14. 查找手表
1：开始查找，0：停止查找
`JToBluetoothHelper.getInstance().getSendBlueData().sendFindWatch(1);`

## 15. 久坐提醒

```
JTo_DATA_TYPE_SETSEDENTARY jToDataTypeSetSedentary = new JTo_DATA_TYPE_SETSEDENTARY();
jToDataTypeSetSedentary.setSwitchStatus(JtoBleConstants.OPENSTATUS.OPEN);//1开启，0关闭
jToDataTypeSetSedentary.setTriggerDuration(60);//触发时长，15，30，45，60，90 单位分钟
jToDataTypeSetSedentary.getList().get(0).setStartHour(8);
jToDataTypeSetSedentary.getList().get(0).setStartMin(0);
jToDataTypeSetSedentary.getList().get(0).setEndHour(22);
jToDataTypeSetSedentary.getList().get(0).setEndMin(0);
JToBluetoothHelper.getInstance().getSendBlueData().sendSetSedentary(jToDataTypeSetSedentary);
```

## 16. 勿扰设置

```
JTo_DATA_TYPE_SETDND jToDataTypeSetDnd = new JTo_DATA_TYPE_SETDND();
jToDataTypeSetDnd.setSwitchStatus(JtoBleConstants.OPENSTATUS.OPEN);//勿扰开关
jToDataTypeSetDnd.getList().get(0).setStartHour(8);
jToDataTypeSetDnd.getList().get(0).setStartMin(0);
jToDataTypeSetDnd.getList().get(0).setEndHour(22);
jToDataTypeSetDnd.getList().get(0).setEndMin(0);
JToBluetoothHelper.getInstance().getSendBlueData().setDND(jToDataTypeSetDnd);
```

## 17. 亮屏时长

```
JTo_DATA_TYPE_SETSYS jToDataTypeSetSys = new JTo_DATA_TYPE_SETSYS();
jToDataTypeSetSys.setScreenTime(5);//5,10,15 单位秒
JToBluetoothHelper.getInstance().getSendBlueData().setSystemSetting(jToDataTypeSetSys);
```

## 18.抬腕亮屏

```
//1打开，0关闭
JToBluetoothHelper.getInstance().getSendBlueData().setHandRaise(JtoBleConstants.OPENSTATUS.OPEN);
```

## 19. 系统控制

```
//0关机，1重启，2恢复出厂设置
JToBluetoothHelper.getInstance().getSendBlueData().setSystemControl(0);
```

## 20.心率设置

```
JToBluetoothHelper.getInstance().getSendBlueData().sendRealTimeHrSwitch(JtoBleConstants.OPENSTATUS.OPEN);//实时心率开关设置开关

JTo_DATA_TYPE_SETHRWARNING setHrWarning = new JTo_DATA_TYPE_SETHRWARNING();
setHrWarning.setHrWarning.setSwitchStatus(JtoBleConstants.OPENSTATUS.OPEN);//心率预警设置形状
setHrWarning.setHrWarning.setUpperLimit(150);//心率上限
setHrWarning.setHrWarning.setLowerLimit(60);//心率下限
JToBluetoothHelper.getInstance().getSendBlueData().setHrWarning(setHrWarning);
```


## 21. 生理周期

```
JTo_DATA_TYPE_SETFEMALECIRCLE jToDataTypeSetFemaleCircle = new JTo_DATA_TYPE_SETFEMALECIRCLE();
jToDataTypeSetFemaleCircle.setSwitchStatus(JtoBleConstants.OPENSTATUS.OPEN);//生理周期开关
jToDataTypeSetFemaleCircle.setLastMenstrualYear(24);//上次月经开始时间-年
jToDataTypeSetFemaleCircle.setLastMenstrualMonth(5);//上次月经开始时间-月
jToDataTypeSetFemaleCircle.setLastMenstrualDay(6);//上次月经开始时间-日
jToDataTypeSetFemaleCircle.setCycleDay(28);//月经间隔周期 单位天
jToDataTypeSetFemaleCircle.setMenstrualDays(5);//经期天数
jToDataTypeSetFemaleCircle.setRemindHour(8);//提醒时间,表示前一天的哪个时间点提醒
jToDataTypeSetFemaleCircle.setRemindMin(0);//提醒时间,表示前一天的哪个时间点提醒

JToBluetoothHelper.getInstance().getSendBlueData().sendFemaleCircle(jToDataTypeSetFemaleCircle);
```

## 22.表盘
### 22.1 自定义表盘

蓝讯平台

```java
ModifyWatchInfo modifyWatchInfo = new ModifyWatchInfo();
//将本地选择的图片转成适合手表屏幕尺寸的图片,
String customDialPath = JtoBitmapUtils.createCustomDialBg(mContext,表盘形状(0圆，1方), "原图片在本地的完整路径", "转换后保存的完整路径，带图片文件名");
modifyWatchInfo.setFilePath(customDialPath);
//自定义表盘文字颜色
modifyWatchInfo.setColor(0xFFFFFFFF);
//时间上方显示 1: 日期，2：睡眠，3：心率，4：计步
modifyWatchInfo.setTime_up(4);
//时间下方显示 1: 日期，2：睡眠，3：心率，4：计步
modifyWatchInfo.setTime_down(3);
//自定义表盘文字位置:0左上方 1顶部居中 2右上方 3居中 4左下方 5底部居中 6右下方
modifyWatchInfo.setTime_pos(3);
modifyWatchInfo.setTime_x(timeX);//时间文字的x坐标
modifyWatchInfo.setTime_y(timeY);//时间文字的y坐标
//带背景图片
JToBluetoothHelper.getInstance().getSendBlueData().sendLanXunCustomDial(modifyWatchInfo);
//无背景图片
JToBluetoothHelper.getInstance().getSendBlueData().sendCustomDialProperty(modifyWatchInfo);
```

杰理平台

```java
ModifyWatchInfo modifyWatchInfo = new ModifyWatchInfo();
//将本地选择的图片转成适合手表屏幕尺寸的图片
String customDialPath = JtoBitmapUtils.createCustomSqDialBg(mContext, "原图片在本地的完整路径", "转换后保存的完整路径，带图片文件名");
modifyWatchInfo.setFilePath(customDialPath);
//自定义表盘文字颜色
modifyWatchInfo.setColor(0xFFFFFFFF);
//自定义表盘文字位置:0左上方 1顶部居中 2右上方 3居中 4左下方 5底部居中 6右下方
modifyWatchInfo.setTime_pos(3);
modifyWatchInfo.setTime_x(timeX);//时间文字的x坐标
modifyWatchInfo.setTime_y(timeY);//时间文字的y坐标
//截取自定义图片缩略图
String customThumb = JtoFileUtil.captureAndSaveLayout(View, "图片保存完整路径，带文件名");
modifyWatchInfo.setThumbFile(customThumb);


//生成自定义表盘bin文件
JToBluetoothHelper.getInstance().getTransfer().getDialBinFile(modifyWatchInfo, new OnCreateBinFileListener() {
    @Override
    public void onCreateBinFile(boolean result, String dialPath) {
        if (result) {//bin文件生成成功
            //发送表盘
            JToBluetoothHelper.getInstance().getTransfer().sendTransferDial(dialPath, JtoBleConstants.FILETYPE.TYPE_CUSTOM_DIAL_TWENTYONE,999 );
        } else {
            //BIN文件生成失败
        }
    }
});
```

### 22.2 在线表盘

```
String onlineDialBin = "在线表盘bin文件在本地路径";
int onlineDialNumber = 20;//表盘编号
JToBluetoothHelper.getInstance().getTransfer().sendTransferDial(onlineDialBin, JtoBleConstants.FILETYPE.TYPE_DIAL_ZERO, onlineDialNumber);
```
### 22.3 表盘传输进度

​	查看第三大点13小点，文件传输进度

### 22.4 切换表盘

```
JToBluetoothHelper.getInstance().getSendBlueData().sendCurrentDialNumber("表盘编号");
```


## 23. OTA升级
### 23.1 蓝讯平台

```
//步骤一：启动OTA，手表会重启，进入OTA
JTo_DATA_TYPE_FILE jToDataTypeFile = new JTo_DATA_TYPE_FILE();
jToDataTypeFile.setDocPurpose(JtoBleConstants.FILETYPE.TYPE_OTA);//用途ota
JToBluetoothHelper.getInstance().getTransfer().sendTransferFiles(jToDataTypeFile);

//步骤二：重启完成后会连接上蓝讯服务,开始OTA
jToDevRcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_LANXUN_SERVICE, new JToBleDataResult<Integer>() {
            @Override
            public boolean bleDataResult(Integer o) {
            	//开始OTA
              JToBluetoothHelper.getInstance().getLanXunWatchOperate().startOTA(updateBinList, pathList);
                return false;
            }
        });
        //蓝讯OTA进度
        jToDevRcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_LANXUN_OTA_PROGRESS, new JToBleDataResult<OtaProgressBean>() {
            @Override
            public boolean bleDataResult(OtaProgressBean otaProgressBean) {
                //当前阶段
                otaProgressBean.getCurStage();
                //总阶段
                otaProgressBean.getTotalStage();
                //当前阶段进度
                otaProgressBean.getProgress();
                return false;
            }
        });
```



### 23.2 杰理平台

OTA升级包分3种类型的包：UI库，字库，固件包，如果这3个包同时进行升级时，升级顺序为 UI库 -> 字库 -> 固件
当UI库或字库升级完成后，等待手表下发版本号，等收到版本后，再升级下一个,或者等待文件传输完成回调后，再升级下一个

升级UI与字库
1. 开始升级

```
JTo_DATA_TYPE_FILE jToDataTypeFile = new JTo_DATA_TYPE_FILE();
jToDataTypeFile.setFilePath("升级包本地路径");
//升级包类型：字库JtoBleConstants.FILETYPE.TYPE_FONT_OTA，UI库JtoBleConstants.FILETYPE.TYPE_OTA_RES
jToDataTypeFile.setDocPurpose(JtoBleConstants.FILETYPE.TYPE_FONT_OTA);
JToBluetoothHelper.getInstance().getTransfer().sendTransferFiles(jToDataTypeFile);
```

2. 升级进度，查看第三大点的第13小点
3. 等待手表下发版本号，收到后，继续升级下一个包，接收手表版本号，查看第三大点的第14小点

升级固件
1. 固件升级的前提，必须等待OTA初始化完成，否则固件升级时会出错，初始化完成回调请查看第三大点28.2

```
//初始化OTA
JToBluetoothHelper.getInstance().getJLWatchOperate().initJtoOtaManager();
```

2. 开始升级
   `JToBluetoothHelper.getInstance().getJLWatchOperate().startOTA("固件包本地路径");`
3. 固件升级进度

```
rcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_JLotaProgress, new JToBleDataResult<OtaProgressBean>() {
    @Override
    public boolean bleDataResult(OtaProgressBean otaProgressBean) {
        if (otaProgressBean.getType() == JtoBleConstants.OTA_STATUS.OTA_NOT_READY) {//OTA未准备好
            //OTA初始化失败，请重新进入该页面
            
        } else if (otaProgressBean.getType() == JtoBleConstants.OTA_STATUS.OTA_START) {
           //升级准备开始
           
        } else if (otaProgressBean.getType() == JtoBleConstants.OTA_STATUS.OTA_LOADER) {//下载固件
            //升级固件第一阶段，下载固件
            otaProgressBean.getProgress();//下载固件进度
            
        } else if (otaProgressBean.getType() == JtoBleConstants.OTA_STATUS.OTA_UPGRADE) {//升级固件
            //升级固件第二阶段，开始升级固件
            otaProgressBean.getProgress();//升级固件进度

        } else if (otaProgressBean.getType() == JtoBleConstants.OTA_STATUS.OTA_COMPLETE) {//升级完成
            
            
        } else if (otaProgressBean.getType() == JtoBleConstants.OTA_STATUS.OTA_ERROR) {//升级出错
            otaProgressBean.getCode();//报错误码
            otaProgressBean.getErrorMsg();//报错信息
        }
        return false;
    }
});
```

4. 蓝牙连接状态要传给sdk
   固件升级中，中途会回连蓝牙的过程，所以要将蓝牙连接状态传给sdk

```
rcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CONNECT_STATE_CHANGE, new JToBleDataResult<Integer>() {
            @Override
            public boolean bleDataResult(Integer connectStatus) {
                JToBluetoothHelper.getInstance().getJLWatchOperate().setOtaNotifyBtDeviceConnection(
                                JToBluetoothHelper.getInstance().getJToDevProxy().getJToBlueTooth().getBluetoothDevice(), 
                                connectStatus);
                return false;
            }
        });
```

5. 需要强制升级固件

```
rcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_mandatoryUpgradeFlag, new JToBleDataResult<Integer>() {
    @Override
    public boolean bleDataResult(Integer integer) {
        //只要收到此消息，说明需要强制升级固件
        return false;
    }
});
```
## 24. 请求电量

```
JToBluetoothHelper.getInstance().getSendBlueData().sendRequestBat();
```
## 25. 请求蓝牙名

```
JToBluetoothHelper.getInstance().getSendBlueData().sendRequestBleName();
```
## 26. 请求蓝牙地址

```
JToBluetoothHelper.getInstance().getSendBlueData().sendRequestBleAddress();
```
## 27. 读取Rssi

```
JToBluetoothHelper.getInstance().readRemoteRssi();
```
## 28. 设置用户信息
```
JtoUserInfo jtoUserInfo = new JtoUserInfo();
jtoUserInfo.setSex(0);//性别
jtoUserInfo.setAge(22);//年龄
jtoUserInfo.setWeight(55);//体重
jtoUserInfo.setHeight(170);//身高
JToBluetoothHelper.getInstance().getSendBlueData().setPersonInfo(userInfo);
```
## 29. 设置目标
```
JTo_DATA_TYPE_SETTARGET setTarget = new JTo_DATA_TYPE_SETTARGET();
setTarget.setSwitchStatus(1);//1打开，0关闭
setDistance(5000);//距离 米
setCalorie(500);//上路里 千卡
setStep(10000);//步
JToBluetoothHelper.getInstance().getSendBlueData().setTarget(setTarget);
```
## 30. 电子烟
### 30.1 设置功率
```
JToBluetoothHelper.getInstance().getSendBlueData().sendPowerLevel(24);
```
### 30.2 抽烟口次历史数据
时间戳为0:表示请求所有历史数据，不为0：表示从该时间戳开始到当前时间的历史数据，接收历史回调数据，请查看第三大点
```
JToBluetoothHelper.getInstance().getSendBlueData().getHisECig(时间戳);
```



# 三、接收蓝牙数据监听
## 1. 获取蓝牙数据接收监听器
`IJToDevRcvDataManager rcvDataManager = JToBluetoothHelper.getInstance().getJToDevRcvDataManager()`
## 2. 监听蓝牙连接状态

```
rcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CONNECT_STATE_CHANGE, new JToBleDataResult<Integer>() {
            @Override
            public boolean bleDataResult(Integer status) {
                if (status == JtoBleConstants.BLUE_CONNECTED) {//已连接
                
                } else if(status == JtoBleConstants.BLUE_CONNECTING){//正在连接
                
                } else if(status == JtoBleConstants.BLUE_DISCONNECT){//断开连接    
                                                
                } 
                return false;
            }
        });
```

## 3. 日常活动数据
实时步数，卡路里，距离

```
rcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_realTimeStep, new JToBleDataResult<JTo_DATA_TYPE_REALTIMESTEP>() {
    @Override
    public boolean bleDataResult(JTo_DATA_TYPE_REALTIMESTEP data) {
        if (data.getSubCMD() == JToAction.SUB_CMD.THREE) {//3 手表按app的申请信息下发的历史分段数据
            for (JTo_DATA_TYPE_REALTIMESTEP.ActiveData stepData : data.getList()) {
                stepData.getTime();时间戳
                stepData.getSteps();//步数
                stepData.getCalories();//卡路里
                stepData.getDistance();//距离
            }
        }else if (data.getSubCMD() == JToAction.SUB_CMD.ZERO) {//0 手表推送的实时数据
                data.getTime();时间戳
                data.getSteps();//步数
                data.getCalories();//卡路里
                data.getDistance();//距离
        }
        return false;
    }
});
```

## 4. 睡眠数据
### 4.1 睡眠类型

```
JTo_DATA_TYPE_SLEEP.SLEEP_LATENCY //-1 入睡
JTo_DATA_TYPE_SLEEP.AWAKENING //0清醒
JTo_DATA_TYPE_SLEEP.REM //1动眼
JTo_DATA_TYPE_SLEEP.LIGHT_SLEEP //2浅睡
JTo_DATA_TYPE_SLEEP.DEEP_SLEEP //3深睡
JTo_DATA_TYPE_SLEEP.SLEEP_OUT //4出睡
JTo_DATA_TYPE_SLEEP.JUMP_SLEEP //5跳到下一段睡眠
```

### 4.2 睡眠数据

```
rcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_sleep, new JToBleDataResult<JTo_DATA_TYPE_SLEEP>() {
    @Override
    public boolean bleDataResult(JTo_DATA_TYPE_SLEEP jTo_data_type_sleep) {
        if (jTo_data_type_sleep.getSubCMD() == JToAction.SUB_CMD.THREE) {//手表下发的睡眠数据
            jToDataTypeSleep.getStartTime();//当前睡眠段的开始时间戳
            jToDataTypeSleep.getSleepBelongTo();//这段睡眠属于哪一天
            jToDataTypeSleep.getEndTime();//当前睡眠段的结束时间戳
            jToDataTypeSleep.getDeepDuration();//深睡时长
            jToDataTypeSleep.getLightDuration();//浅睡时长
            jToDataTypeSleep.getRemDuration();//REM眼动时长
            jToDataTypeSleep.getAwakenDuration();//清醒时长
            jToDataTypeSleep.getReviveTimes();//苏醒次数
            jToDataTypeSleep.getSleepDetail();//睡眠详情，一段json数据
            jToDataTypeSleep.getRawData();//睡眠原始数据
        }
        return false;
    }
});
```

## 5. 心率数据

```
rcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_realTimeHr, new JToBleDataResult<JTO_DATA_TYPE_REALTIMEHR>() {
    @Override
    public boolean bleDataResult(JTO_DATA_TYPE_REALTIMEHR heartData) {
        if (heartData.getSubCMD() == JToAction.SUB_CMD.THREE) {//3 手表按app的申请信息下发历史分段数据
            for (int i = 0; i < heartData.getList().size(); i++) {
                heartData.getList().get(i).getTime();//心率时间
                heartData.getList().get(i).getData();//心率值
            }
        } else if (heartData.getSubCMD() == JToAction.SUB_CMD.ZERO) {//0 手表推送实时数据
            heartData.getTime();//心率时间
            heartData.getHeartValue();//心率值
            heartData.getAvgHeart();//平均心率值
            heartData.getMinHeart();//最小心率值
            heartData.getMaxHeart();//最大心率值
        } else if(heartData.getSubCMD() == JToAction.SUB_CMD.SEVEN){//7 实时心率开关
            heartData.getRealTimeHrSwitch();//1打开，0关闭
        }
        return false;
    }
});
```

## 6. 血氧数据

```
rcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_realTimeSpo2, new JToBleDataResult<JTO_DATA_TYPE_REALTIMESPO2>() {
    @Override
    public boolean bleDataResult(JTO_DATA_TYPE_REALTIMESPO2 boData) {
        if (boData.getSubCMD() == JToAction.SUB_CMD.THREE) {//3 手表按app的申请信息下发历史分段数据
            for (int i = 0; i < boData.getList().size(); i++) {
                boData.getList().get(i).getTime();//血氧时间
                boData.getList().get(i).getData();//血氧值
            }
        }else if (boData.getSubCMD() == JToAction.SUB_CMD.ZERO) {//实时数据
            boData.getTime();//血氧时间
            boData.getBloodOxygenValue();//血氧值
            boData.getAvgBo();//平均血氧值
            boData.getMinBo();//最小血氧值
            boData.getMaxBo();//最大血氧值
        }
        return false;
    }
});
```

## 7. 血压数据

```
rcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_realTimeBp, new JToBleDataResult<JTO_DATA_TYPE_REALTIMEBP>() {
    @Override
    public boolean bleDataResult(JTO_DATA_TYPE_REALTIMEBP bpData) {
        if (bpData.getSubCMD() == JToAction.SUB_CMD.THREE) {//手表按app的申请信息下发历史分段数据
            for (int i = 0; i < bpData.getList().size(); i++) {
                bpData.getList().get(i).getTime();//时间
                bpData.getList().get(i).getSystolicPressure();//收缩压
                bpData.getList().get(i).getDiastolicPressure();//舒张压
            }
        }else if (bpData.getSubCMD() == JToAction.SUB_CMD.ZERO) {//手表推送的实时数据
            bpData.getTime();//时间
            bpData.getDiastolicPressure();//收缩压
            bpData.getSystolicPressure();//舒张压
        }
        return false;
    }
});
```

## 8. 手表运动数据
### 8.1 运动类型

```
JtoBleConstants.SPORT_TYPE.WALK;
public class JtoBleConstants {
    /**
     * 运动类型
     */
    public static final class SPORT_TYPE {
        public static final int WALK = 0;//步行
        public static final int RUNNING = 1;//跑步
        public static final int OUTDOOR_RIDING = 2;//户外骑行
        public static final int JUMP_ROPE = 3;//跳绳
        public static final int BADMINTON = 4;//羽毛球
        public static final int BASKETBALL = 5;//篮球
        public static final int FOOTBALL = 6;//足球
        public static final int SWIM = 7;//游泳
        public static final int MOUNTAIN_CLIMBING = 8;//登山
        public static final int TENNIS = 9;//网球
        public static final int RUGBY = 10;//橄榄球
        public static final int GOLF = 11;//高尔夫
        public static final int YOGA = 12;//瑜珈
        public static final int FITNESS = 13;//健身
        public static final int DANCE = 14;//跳舞
        public static final int BASEBALL = 15;//棒球
        public static final int ELLIPTICAL_MACHINE = 16;//椭圆机
        public static final int INDOOR_CYCLING = 17;//室内骑行
        public static final int FREE_TRAINING = 18;//自由训练
        public static final int ROWING_MACHINE = 19;//划船机
        public static final int SAILBOAT = 20;//帆船
        public static final int WATER_POLO = 21;//水球
        public static final int OTHER_WATER_SPORTS = 22;//其他水上运动
        public static final int PADDLEBOARDING = 23;//桨板运动
        public static final int WATER_SKIING = 24;//滑水运动
        public static final int KAYAK = 25;//皮划艇
        public static final int DRIFTING = 26;//漂流
        public static final int ROWING = 27;//赛艇
        public static final int MOTORBOAT = 28;//摩托艇
        public static final int WEB_SWIMMING = 29;//蹼泳
        public static final int DIVING = 30;//跳水
        public static final int SYNCHRONISED_SWIMMING = 31;//花样游泳
        public static final int SNORKELING = 32;//浮潜
        public static final int KITESURFING = 33;//风筝冲浪
        public static final int OPEN_WATER_SWIMMING = 34;//开放水域游泳
        public static final int ROCK_CLIMBING = 35;//攀岩
        public static final int SKATEBOARD = 36;//滑板
        public static final int ROLLER_SKATING = 37;//轮滑
        public static final int PARKOUR = 38;//跑酷
        public static final int MOUNTAIN_CROSS_COUNTRY = 39;//山地越野
        public static final int PARAGLIDING = 40;//滑翔伞
        public static final int TRIATHLON = 41;//铁人三项
        public static final int TRAIL_RUNNING = 42;//越野跑
        public static final int ON_FOOT = 43;//徒步
        public static final int KABADDI = 44;//卡巴迪
        public static final int CLIMB_STAIRS = 45;//爬楼梯
        public static final int STEPPER = 46;//踏步机
        public static final int CORE_TRAINING = 47;//核心训练
        public static final int CALISTHENICS = 48;//柔软操
        public static final int PILATES = 49;//普拉提
        public static final int GYMNASTICS = 50;//体操
        public static final int STRETCH = 51;//拉伸
        public static final int STRENGTH_TRAINING = 52;//力量训练
        public static final int CROSS_TRAINING = 53;//交叉训练
        public static final int AEROBICS = 54;//健身操
        public static final int PHYSICAL_TRAINING = 55;//体能训练
        public static final int WALL_EXERCISE_BALL = 56;//墙壁健身球
        public static final int DUMBBEL = 57;//哑铃
        public static final int BARBELL = 58;//杠铃
        public static final int DEADLIFT = 59;//硬拉
        public static final int UPPER_BODY_TRAINING = 60;//上肢训练
        public static final int SIT_UPS = 61;//仰卧起坐
        public static final int FUNCTIONAL_TRAINING = 62;//功能性训练
        public static final int POPPY = 63;//波比
        public static final int BACK_EXERCISE = 64;//背部运动
        public static final int LOWER_LIMB_MOVEMENT = 65;//下肢运动
        public static final int WAIST_ABDOMINAL_TRAINING = 66;//腰腹训练
        public static final int HIT = 67;//HIT
        public static final int INDOOR_WALKING = 68;//室内步行
        public static final int INDOOR_RUNNING = 69;//室内跑步
        public static final int WEIGHTLIFTING = 70;//举重
        public static final int SQUARE_DANCE = 71;//广场舞
        public static final int BELLY_DANCE = 72;//肚皮舞
        public static final int BALLET = 73;//芭蕾舞
        public static final int ZUMBA = 74;//尊巴
        public static final int LATIN_DANCE = 75;//拉丁舞
        public static final int HIP_HOP = 76;//街舞
        public static final int FOLK_DANCE = 77;//民族舞
        public static final int JAZZ = 78;//爵士舞
        public static final int BOXING = 79;//拳击
        public static final int WRESTLING = 80;//角力
        public static final int MARTIAL_ARTS = 81;//武术
        public static final int TAI_CHI = 82;//太极
        public static final int MUAY_THAI = 83;//泰拳
        public static final int JUDO = 84;//柔道
        public static final int TAEKWONDO = 85;//跆拳道
        public static final int KARATE = 86;//空手道
        public static final int FREE_BOXING = 87;//自由拳击
        public static final int FENCING = 88;//击剑
        public static final int KENDO = 89;//剑道
        public static final int VOLLEYBALL = 90;//排球
        public static final int SOFTBALL = 91;//垒球
        public static final int HOCKEY = 92;//曲棍球
        public static final int PINGPONG = 93;//乒乓球
        public static final int CRICKET = 94;//板球
        public static final int HANDBALL = 95;//手球
        public static final int SQUASH = 96;//壁球
        public static final int BILLIARDS = 97;//台球
        public static final int SHUTTLECOCK = 98;//毽球
        public static final int BEACH_SOCCER = 99;//沙滩足球
        public static final int BEACH_VOLLEYBALL = 100;//沙滩排球
        public static final int SEPAK_TAKRAW = 101;//藤球
        public static final int BOWLING = 102;//保龄球
        public static final int SKATE = 103;//滑冰
        public static final int CURLING = 104;//冰壶
        public static final int OTHER_SNOW_SPORTS = 105;//其他雪上运动
        public static final int SNOWMOBILE = 106;//雪地摩托
        public static final int PUCK = 107;//冰球
        public static final int SNOWMOBILING = 108;//雪车
        public static final int SLED = 109;//雪橇
        public static final int SKI = 110;//滑雪
        public static final int ARCHERY = 111;//射箭
        public static final int DARTS = 112;//飞镖
        public static final int TUG_WAR = 113;//拔河
        public static final int HULA_HOOP = 114;//呼啦圈
        public static final int KITE = 115;//风筝
        public static final int HORSE_RIDING = 116;//骑马
        public static final int FRISBEE = 117;//飞盘
        public static final int FISHING = 118;//钓鱼
        public static final int EQUESTRIAN_SPORTS = 119;//马术运动
        public static final int TRACK_FIELD = 120;//田径
        public static final int RACING = 121;//赛车
    }
}
```


### 8.2 运动数据

```
rcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_sportMulti, new JToBleDataResult<JTo_DATA_TYPE_SPORTMULTI>() {
    @Override
    public boolean bleDataResult(JTo_DATA_TYPE_SPORTMULTI data) {
        data.getSportType();//运动类型
        data.getDataSources();//数据来源,0手表
        data.getSportDate();//运动日期
        data.getStartTime();//开始时间
        data.getEndTime();//结束时间
        data.getDuration();//运动时长
        data.getCalorie();//卡路里
        data.getSteps();//步数
        data.getDistance();//距离
        data.getAvgHeartRate();//平均心率
        data.getMaxHeartRate();// 最高心率
        data.getMinHeartRate();// 最低心率
        data.getAvgPacing();// 平均配速
        data.getMaxPacing();// 最高配速
        data.getMinPacing();// 最低配速
        data.getAvgCadence();// 平均步频
        data.getMaxCadence();// 最高步频
        data.getMinCadence();// 最低步频
        return false;
    }
});
```

## 9. 解绑成功指令

```
rcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_DATA_SYSCTRL, new JToBleDataResult<Integer>() {
    @Override
    public boolean bleDataResult(Integer control) {
        if (control >= 3) {
            //解绑成功
        }
        return false;
    }
});
```

## 10. 闹钟数据

```
rcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_alarm, new JToBleDataResult<JTo_DATA_TYPE_ALARM>() {
    @Override
    public boolean bleDataResult(JTo_DATA_TYPE_ALARM alarmData) {
        if (alarmData != null && alarmData.getSubCMD() == JToAction.SUB_CMD.ZERO) {//闹钟数据
            alarmData.getAlarmList();//闹钟列表
        }else if (alarmData != null && alarmData.getSubCMD() == JToAction.SUB_CMD.TWO) {//手表支持的最大闹钟个数
            alarmData.getMaxAlarm();
        }
        return false;
    }
});
```

## 11. 联系人数据

```
rcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_contacts, new JToBleDataResult<JTo_DATA_TYPE_CONTACTS>() {
    @Override
    public boolean bleDataResult(JTo_DATA_TYPE_CONTACTS data) {
        if (data.getSubCMD() == JToAction.SUB_CMD.FIVE) {//手表支持的最大联系人数
            data.getSupportMax();
        }else if (data.getSubCMD() == (JToAction.SUB_CMD.ZERO | 0x80)) { //手表下发联系人数据
            data.getOffset();//联系人条数偏移量
            data.getList();//联系人数据
        }else if (data.getSubCMD() == JToAction.SUB_CMD.THREE) { //手表告知联系人数据传输结果
            data.getResult();//0成功
        }else if (jToDataTypeContacts.getSubCMD() == (JToAction.SUB_CMD.FOUR | 0x80)) { //手表告知联系人总数
            data.getTotal();
        }
        return false;
    }
});
```

## 12. 查找手机

```
rcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_FIND_WATCH, new JToBleDataResult<JTo_DATA_TYPE_FIND>() {
    @Override
    public boolean bleDataResult(JTo_DATA_TYPE_FIND jTo_data_type_find) {
        if (jToDataTypeFind.getSubCMD() == JToAction.SUB_CMD.ZERO) {
            //响铃 或 停止响铃
            jToDataTypeFind.getControl();//1查找，0停止查找
        }
        return false;
    }
});
```

## 13. 文件传输

### 13.1 进度

```
rcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_DATA_FILE_PROGRESS, new JToBleDataResult<Integer>() {
    @Override
    public boolean bleDataResult(Integer progress) {
        
        return false;
    }
});
```
### 13.2  文件传输结果
```
jToDevRcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_file, new JToBleDataResult<JTo_DATA_TYPE_FILE>() {
            @Override
            public boolean bleDataResult(JTo_DATA_TYPE_FILE jToDataTypeFile) {
                if (JTo_DATA_TYPE_FILE.getSubCMD() == JToAction.SUB_CMD.TWO) {
                    if(jToDataTypeFile.getResult() == 0){
                        //成功
                    }
                }
                return false;
            }
        });
```
## 14. 手表版本号

```
rcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_version, new JToBleDataResult<String>() {
    @Override
    public boolean bleDataResult(String version) {
        //例：version = A9-J103F00001V0198FONTD669-PIC2100
        JtoBlueCpProxy.getInstance().getProjectNumber();//项目编号
        JtoBlueCpProxy.getInstance().getDevVersion();//固件版本
        JtoBlueCpProxy.getInstance().getFontVersion();//字库版本
        JtoBlueCpProxy.getInstance().getPicVersion();//UI库版本
        return false;
    }
});
```

## 15. 单位设置

```
rcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_setUnit, new JToBleDataResult<JTo_DATA_TYPE_SETUNIT>() {
    @Override
    public boolean bleDataResult(JTo_DATA_TYPE_SETUNIT data) {
        data.getUnitTemperature();//0摄氏度C，1华氏度F
        data.getUnitLength();//0国际（米，千米，公里==），1英制（英里，码==）
        data.getUnitTime();//0 24小时制，1 12小时制
        return false;
    }
});
```

## 16. 功能标志位

```
rcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_flagFunc, new JToBleDataResult<JTo_DATA_TYPE_FLAGFUNC>() {
    @Override
    public boolean bleDataResult(JTo_DATA_TYPE_SETUNIT jToDataTypeFlagFunc) {
        jToDataTypeFlagFunc.isFLAG_F_REAL_HEART();//实时心率功能
        jToDataTypeFlagFunc.isFLAG_F_HR_WARNING();//心率预警功能
        jToDataTypeFlagFunc.isFLAG_F_FEMALE_CYCLE();//女性生理周期功能
        jToDataTypeFlagFunc.isFLAG_F_DND();//勿扰功能
        jToDataTypeFlagFunc.isFLAG_F_SEDENTARY();//久坐功能
        jToDataTypeFlagFunc.isFLAG_F_HAND_RAISE();//抬腕功能
        jToDataTypeFlagFunc.isFLAG_F_ALARM();//闹钟功能
        jToDataTypeFlagFunc.isFLAG_F_HR();//心率功能
        jToDataTypeFlagFunc.isFLAG_F_SPO2();//血氧功能
        jToDataTypeFlagFunc.isFLAG_F_BP();//血压功能
        return false;
    }
});
```

## 17. 抬腕亮屏

```
rcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_setHandRaise, new JToBleDataResult<Integer>() {
    @Override
    public boolean bleDataResult(Integer isOpen) {
        //1打开，0关闭
        return false;
    }
});
```

## 18. 勿扰数据

```
rcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_setDND, new JToBleDataResult<JTo_DATA_TYPE_SETDND>() {
    @Override
    public boolean bleDataResult(JTo_DATA_TYPE_SETDND jToDataTypeSetDnd) {
        jToDataTypeSetDnd.getSwitchStatus();//1打开，0关闭
        jToDataTypeSetDnd.getList().get(0).getStartHour();//起始时分
        jToDataTypeSetDnd.getList().get(0).getStartMin();//起始分
        jToDataTypeSetDnd.getList().get(0).getEndHour();结束时
        jToDataTypeSetDnd.getList().get(0).getEndMin();结束分
        return false;
    }
});
```

## 19. 久坐数据

```
rcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_setSedentary, new JToBleDataResult<JTo_DATA_TYPE_SETSEDENTARY>() {
    @Override
    public boolean bleDataResult(JTo_DATA_TYPE_SETSEDENTARY jToDataTypeSetSedentary) {
        jToDataTypeSetSedentary.getSwitchStatus();//1打开，0关闭
        jToDataTypeSetSedentary.getTriggerDuration();//触发时长 分钟
        jToDataTypeSetSedentary.getList().get(0).getStartHour();//起始时分
        jToDataTypeSetSedentary.getList().get(0).getStartMin();//起始分
        jToDataTypeSetSedentary.getList().get(0).getEndHour();结束时
        jToDataTypeSetSedentary.getList().get(0).getEndMin();结束分
        return false;
    }
});
```

## 20. 心率预警设置数据

```
rcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_setHrWarning, new JToBleDataResult<JTo_DATA_TYPE_SETHRWARNING>() {
    @Override
    public boolean bleDataResult(JTo_DATA_TYPE_SETHRWARNING setHrWarning) {
        setHrWarning.getSwitchStatus();//1打开，0关闭
        setHrWarning.getUpperLimit();//心率预警上限
        setHrWarning.getLowerLimit();//心率预警下限
        return false;
    }
});
```

## 21. 生理周期数据

```
rcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_setFemaleCircle, new JToBleDataResult<JTo_DATA_TYPE_SETFEMALECIRCLE>() {
    @Override
    public boolean bleDataResult(JTo_DATA_TYPE_SETFEMALECIRCLE jToDataTypeSetFemaleCircle) {
        jToDataTypeSetFemaleCircle.getSwitchStatus();//1打开，0关闭
        jToDataTypeSetFemaleCircle.getLastMenstrualYear();//上次经期开始时间-年
        jToDataTypeSetFemaleCircle.getLastMenstrualMonth();//上次经期开始时间-月
        jToDataTypeSetFemaleCircle.getLastMenstrualDay();//上次经期开始时间-日
        jToDataTypeSetFemaleCircle.getCycleDay();//周期天数
        jToDataTypeSetFemaleCircle.getMenstrualDays();//经期天数
        return false;
    }
});
```

## 22. 表盘相关数据

```
rcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_dialInfo, new JToBleDataResult<JTo_DATA_TYPE_DIALINFO>() {
    @Override
    public boolean bleDataResult(JTo_DATA_TYPE_SETFEMALECIRCLE jToDataTypeSetFemaleCircle) {
        if (jToDataTypeDialInfo.getSubCMD() == JToAction.SUB_CMD.ZERO) {//手表推送的表盘信息
            jToDataTypeDialInfo.getOnlineDialNumbers().get(0);//在线表盘编号
            jToDataTypeDialInfo.getCurrentNumberStr();//当前表盘编号
            jToDataTypeDialInfo. getCurrentNumber();
            jToDataTypeDialInfo.getDefaultDialNumbers();//手表内置表盘编号列表
            jToDataTypeDialInfo.getEditDialNumber();//自定义表盘编号
            jToDataTypeDialInfo.getHasCustomBg();//是否有自定义背景图片 0没有，1有
            jToDataTypeDialInfo.getGuiType();//GUI类型
            jToDataTypeDialInfo.getShape();//形状 0圆形，1方形
            jToDataTypeDialInfo.getWidth();//手表屏幕宽
            jToDataTypeDialInfo.getHeight();//手表屏幕高
            jToDataTypeDialInfo.getPreviewWidth();//表盘预览图宽
            jToDataTypeDialInfo.getPreviewHeight();//表盘预览图高
            jToDataTypeDialInfo.getOnlineSize();//支持的最大在线表盘文件大小
            jToDataTypeDialInfo.getCustomSize();//支持的最大自定表盘文件大小
        }else if (jToDataTypeDialInfo.getSubCMD() == JToAction.SUB_CMD.ONE) {
            //当前表盘编号
            jToDataTypeDialInfo.getCurrentNumberStr();
        }
        return false;
    }
});
```
## 23. 电量数据

```
rcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_bat, new JToBleDataResult<Integer>() {
    @Override
    public boolean bleDataResult(Integer data) {
        
        return false;
    }
});
```
## 24. 蓝牙名

```
rcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_btName, new JToBleDataResult<String>() {
    @Override
    public boolean bleDataResult(String bleName) {
        
        return false;
    }
});
```
## 25. 蓝牙地址

```
rcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_mac, new JToBleDataResult<String>() {
    @Override
    public boolean bleDataResult(String bleMac) {
        
        return false;
    }
});
```
## 26. RSSI信号
```
rcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_DATA_RSSI, new JToBleDataResult<Integer>() {
    @Override
    public boolean bleDataResult(Integer rssi) {
        JToLog.i(TAG, "RSSI=" + rssi);
        homDataLiveData.postValue(rssi);
        return false;
    }
});
```
## 27. 目标数据
```
rcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_setTarget, new JToBleDataResult<JTo_DATA_TYPE_SETTARGET>() {
    @Override
    public boolean bleDataResult(JTo_DATA_TYPE_SETTARGET target) {
        target.getSwitchStatus();//达标提醒开关
        target.getStep();//步数
        target.getCalorie();//上路里
        target.getDistance();//距离
        return false;
    }
});
```

## 28.OTA

### 28.1 蓝讯平台

```java
//连接上蓝讯服务,开始OTA
jToDevRcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_LANXUN_SERVICE, new JToBleDataResult<Integer>() {
    @Override
    public boolean bleDataResult(Integer o) {
        //接收到蓝讯服务，可以在这里开始OTA
        return false;
    }
});
//蓝讯OTA进度
jToDevRcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_LANXUN_OTA_PROGRESS, new JToBleDataResult<OtaProgressBean>() {
    @Override
    public boolean bleDataResult(OtaProgressBean otaProgressBean) {
        //当前阶段
        otaProgressBean.getCurStage();
        //总阶段
        otaProgressBean.getTotalStage();
        //当前阶段进度
        otaProgressBean.getProgress();
        return false;
    }
});
```
### 28.2 杰理平台ota初始化结果
```
//杰理OTA库准备完成
        jToDevRcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_JLOTA_Ready_complete, new JToBleDataResult<Integer>() {
            @Override
            public boolean bleDataResult(Integer integer) {
                if(integer == 1){
                	//初始化完成
                }
                return false;
            }
        });
```
### 28.3 杰理OTA进度
```
jToDevRcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_JLotaProgress, new JToBleDataResult<OtaProgressBean>() {
            @Override
            public boolean bleDataResult(OtaProgressBean otaProgressBean) {
                if (otaProgressBean.getType() == JtoBleConstants.OTA_STATUS.OTA_NOT_READY) {
        //OTA未准备好
                   
                } else if (otaProgressBean.getType() == JtoBleConstants.OTA_STATUS.OTA_START) {
                   //升级准备开始
                } else if (otaProgressBean.getType() == JtoBleConstants.OTA_STATUS.OTA_LOADER) {
                   //下载固件
                } else if (otaProgressBean.getType() == JtoBleConstants.OTA_STATUS.OTA_UPGRADE) {
                   //升级固件
                } else if (otaProgressBean.getType() == JtoBleConstants.OTA_STATUS.OTA_COMPLETE) {
                   //升级完成
                } else if (otaProgressBean.getType() == JtoBleConstants.OTA_STATUS.OTA_ERROR ||
                        otaProgressBean.getType() == JtoBleConstants.OTA_STATUS.OTA_ERROR_RETRY) {
                        //出错
		 }
                return false;
            }
        });
```


## 29.电子烟

```
jToDevRcvDataManager.addBleDataResultListener(JToAction.RECEIVE.RECEIVE_CMD_M_CIGARETTE, new JToBleDataResult<JTo_DATA_TYPE_E_CIGARETTE>() {
    @Override
    public boolean bleDataResult(JTo_DATA_TYPE_E_CIGARETTE jtoDataECig) {
        if(jtoDataECig.getSubCMD() == JToAction.SUB_CMD.ZERO){//油量
            jtoDataECig.getPercentage();//百分比
        }else if(jtoDataECig.getSubCMD() == JToAction.SUB_CMD.ONE){//功率
        	List<String> powerList = jTo_data_type_e_cigarette.getPowerList();
        }else if(jtoDataECig.getSubCMD() == JToAction.SUB_CMD.THREE){//历史数据
            for (JTo_DATA_TYPE_E_CIGARETTE.ItemData itemData : jtoDataECig.getList()) {
                long time = itemData.getTime();//时间
                int duration = itemData.getDuration();//持续时间，需要除以10，保留1位小数
            }
        }
        return false;
    }
});
```