- (void)veepooSDKStartScanDeviceAndReceiveScanningDevice:(ReceiveScanningDevice)scanningDevice;

///Used when scanning and connecting devices by yourself, suitable for integrating multiple SDK scenarios, used in connection status：VPBleConnectStateChangeBlock
///Cannot be used with {@link veepooSDKConnectDevice:deviceConnectBlock:}
- (void)veepooSDKSelfScanConnectDevice:(CBPeripheral *)peripheral
                    deviceConnectBlock:(DeviceConnectBlock)connectBlock;

- (void)veepooSDKStopScanDevice;

- (void)veepooSDKConnectDevice:(VPPeripheralModel *)peripheralModel deviceConnectBlock:(DeviceConnectBlock)connectBlock;

typedef NS_ENUM(NSInteger, DeviceConnectState) {
		BlePoweredOff = 0, 						//Bluetooth is not turned on
		BleConnecting = 1, 						//Bluetooth is connecting
		BleConnectSuccess = 2, 				//Bluetooth connection is successful
		BleConnectFailed = 3, 				//Bluetooth connection failed
		BleVerifyPasswordSuccess = 4, //Password verification is successful
		BleVerifyPasswordFailure = 5, //Password verification failed
};

- (void)veepooSDKDisconnectDevice;

// Read the device's battery level
- (void)veepooSDKReadDeviceBatteryInfo:(void(^)(BOOL isPercent, BOOL percenTypeIsLowBat, NSUInteger battery))deviceBatteryInfoBlock;

// Interface with charging status
- (void)veepooSDKReadDeviceBatteryAndChargeInfo:(void(^)(BOOL isPercent, VPDeviceChargeState chargeState, BOOL percenTypeIsLowBat, NSUInteger battery))deviceBatteryInfoBlock

// Charging state of the device
typedef NS_ENUM(NSUInteger, VPDeviceChargeState) {
		VPDeviceChargeStateNormal = 0, 	// The device is in normal use, not charging
		VPDeviceChargeStateCharging, 		// Charging
		VPDeviceChargeStateLowPressure, // Low pressure state, has been abandoned
		VPDeviceChargeStateFull 				// Full state, unreliable
};

- (void)veepooSDKSynchronousPersonalInformation:(VPSyncPersonalInfo *)personalInfo result:(void(^)(NSUInteger settingResult))synchronousPersonalInformationBlock;

@interface VPSyncPersonalInfo : NSObject

//Height, unit cm
@property(nonatomic, assign) int status;

//Weight, unit kg
@property(nonatomic, assign) int weight;

//Age (current yeart - birth year) Current year - user's birth year
@property(nonatomic, assign) int age;

//Gender 0 represents female, 1 represents male
@property(nonatomic, assign) int sex;

//Target number of steps Unit step (step)
@property(nonatomic, assign) int targetStep;

//Target sleep duration Unit minute (minute) To confirm whether this function exists in the project, you can also set it if not
@property(nonatomic, assign) int targetSleepDuration;

@end

- (void)veepooSDKSettingLanguage:(UInt8)languageType result:(void(^)(BOOL success))settingLangueResult;

- (void)veepooSDKSettingBaseFunctionType:(VPSettingBaseFunctionSwitchType)baseFunctionType settingState:(VPSettingFunctionState)settingState completeBlock:(void(^)(VPSettingFunctionCompleteState completeState))settingCompleteBlock;

typedef NS_ENUM(NSInteger, VPSettingFunctionCompleteState) {//Set the state after a function is completed
		VPFunctionCompleteUnknown = 0,	 //The device does not have this function
		VPFunctionCompleteOpen = 1, 		 //(Metric)
		VPFunctionCompleteClose = 2, 		 //(Imperial)
		VPFunctionCompleteFailure = 3, 	 //Setting or reading failed
		VPFunctionCompleteComplete = 4,  //Setting completed, response to Data setting
};

- (void)veepooSDKSettingBaseFunctionType:(VPSettingBaseFunctionSwitchType)baseFunctionType settingState:(VPSettingFunctionState)settingState completeBlock:(void(^)(VPSettingFunctionCompleteState completeState))settingCompleteBlock;

typedef NS_ENUM(NSInteger, VPSettingFunctionCompleteState) {//Set the state after a function is completed
		VPFunctionCompleteUnknown = 0, 	//The device does not have this function
		VPFunctionCompleteOpen = 1, 		//(24 hours)
		VPFunctionCompleteClose = 2, 		//(12 hours)
		VPFunctionCompleteFailure = 3, 	//Setting or reading failed
		VPFunctionCompleteComplete = 4, //Setting completed, response to Data setting
};

/// Synchronize time, used in special cases, the default connection will automatically synchronize time
/// @param year year
/// @param month month 1-12
/// @param day day 1-31
/// @param hour hour 0-23
/// @param min minute 0-59
/// @param sec second 0-59
/// @param system 0 is not set 1 is 12 hours 2 is 24 hours If it is useless, you need to set it again through the standard in the switch setting
/// @param result failure/success result callback, the internal will be empty
- (void)veepooSDKSettingTimeWithYear:(int)year
                               month:(int)month
                                 day:(int)day
                                hour:(int)hour
                              minute:(int)min
                              second:(int)sec
                          timeSystem:(int)system
                              result:(void(^)(BOOL success))result;

/// Synchronize the current time of the phone to the device. The time parameters are obtained by the SDK from the current data of the phone.
/// This Interface cannot be used with {@link veepooSDKSettingTimeWithYear:month:day:hour:minute:second:timeSystem:result:}
/// The time format setting of this Interface is invalid. To set the time format, please call {@link veepooSDKSettingBaseFunctionType:settingState:completeBlock:}
/// @param result Failure/success result callback, which will be set to null internally
- (void)veepooSDKSettingTimeWithResult:(void(^)(BOOL success))result;

- (void)veepooSDKSettingBaseFunctionType:(VPSettingBaseFunctionSwitchType)baseFunctionType settingState:(VPSettingFunctionState)settingState completeBlock:(void(^)(VPSettingFunctionCompleteState completeState))settingCompleteBlock;

/// Callback for active reporting of device switch status changes
@property (nonatomic, copy) void(^deviceFunctionSwitchDidChangeBlock)(void);

typedef NS_ENUM(NSInteger, VPSettingFunctionState) {//Set to get a function to read
		VPReadFunctionState = 0, 			//Read the switch and existence of a function
		VPSettingFunctionOpen = 1, 		//Open a function
		VPSettingFunctionClose = 2, 	//Close a function
		VPSettingFunctionCancel = 3, 	//Only dynamic blood pressure calibration is valid now
		VPSettingFunction = 4, 				//Set a function
};

typedef NS_ENUM(NSInteger, VPSettingFunctionCompleteState) {//Set the state after a function is completed
		VPFunctionCompleteUnknown = 0, 		//The device does not have this function
		VPFunctionCompleteOpen = 1, 			//This function is already turned on
		VPFunctionCompleteClose = 2, 			//This function is already closed
		VPFunctionCompleteFailure = 3, 		//Setting or reading failed
		VPFunctionCompleteComplete = 4, 	//Setting completed, response to Data setting
};

// 
+ (void)veepooSDKGetStepDataWithDate:(NSString *)queryDate andTableID:(NSString *)tableID changeUserStature:(NSUInteger)userStature result:(void(^)(NSDictionary *stepDict))resultBlock;

// If it is the data of the day, the device is always generating data, and the application layer needs to control the timing of reading. Data other than the day is idempotent, and each read will produce the same result. The application layer can persist it by itself, and the persisted data can avoid repeated acquisition.
// dayNumber represents which day 0 represents today, 1 represents yesterday, and 2 represents the day before yesterday. It cannot be greater than the value of the attribute saveDays in VPPeripheralModel
- (void)veepooSDK_readStepDataWithDayNumber:(NSInteger)dayNumber result:(void(^)(NSDictionary *stepDict))readStepBlock;

{
Step = 5000; //Total number of steps per day
Dis = 80.00; //Converted distance unit is km
Cal = 1600.0; //Converted calories unit is kcal (kilocalories)
}

- (void)veepooSdkStartReadDeviceAllDataWithReadStateChangeBlock:(void(^)(VPReadDeviceBaseDataState readState, NSUInteger totalDay, NSUInteger currentReadDayNumber, NSUInteger readCurrentDayProgress))readStateChangeBlock;

typedef NS_ENUM(NSInteger, VPReadDeviceBaseDataState) {//Changes in the state of reading basic device data
		VPReadDeviceBaseDataIdle = 0, 		// Status of not starting to read
		VPReadDeviceBaseDataStart = 1, 		// Start reading data
		VPReadDeviceBaseDataReading = 2,  // Reading
		VPReadDeviceBaseDataComplete, 		// Reading is complete
		VPReadDeviceBaseDataInvalid, 		  // Not available in SDK
};

@property (nonatomic, strong) NSData *deviceFuctionData;

- (void)veepooSDKTestHeartStart:(BOOL)start testResult:(void(^)(VPTestHeartState testHeartState, NSUInteger heartValue))testHeartResultBlock;

typedef NS_ENUM(NSInteger,VPTestHeartState) {//State changes during heart rate test
		VPTestHeartStateStart = 0,			//Starting to test heart rate, no result yet
		VPTestHeartStateTesting = 1,	  //Testing heart rate, heart rate value has been measured
		VPTestHeartStateNotWear = 2,    //Wearing test failed, test has ended
		VPTestHeartStateDeviceBusy = 3, //The device is busy and cannot be tested, test has ended
		VPTestHeartStateOver = 4,			  //Test ended normally, ended manually
};

+ (NSDictionary *)veepooSDKGetOriginalDataWithDate:(NSString *)queryDate andTableID:(NSString *)tableID;

{
	"10:40" = {
  diastolic = 0; // high pressure value
  systolic = 0; // low pressure value
  heartValue = 0; // heart rate value
  sportValue = 17; // amount of exercise
  stepValue = 0; // number of steps
  calValue = 0; // calories
  disValue = 0; // distance
  ppgs = [array]; // when using, if there is heartValue, use heartValue, if not, use ecgs first, if there is neither heartValue nor ecgs, use ppgs, ppgs and ecgs are the heart rate arrays of this time period
  ecgs = [array];
 };
	"10:45" = {
	diastolic = 0;
	systolic = 0;
  heartValue = 0;
  sportValue = 25;
  stepValue = 0;
  calValue = 0;
  disValue = 0;
  ppgs = [array];
  ecgs = [array];
 };
}

+ (NSDictionary *)veepooSDKGetOriginalChangeHalfHourDataWithDate:(NSString *)queryDate andTableID:(NSString *)tableID;

{
"10:30" = {
heartValue = 0; // half-hour heart rate average value
sportValue = 108; // half-hour exercise accumulation value
stepValue = 0; // half-hour step accumulation value
calValue = 0; // half-hour calorie accumulation value
disValue = 0; // half-hour distance accumulation value
};
"11:00" = {
heartValue = 0;
sportValue = 33;
stepValue = 0;
calValue = 0; // half-hour calorie accumulation value
disValue = 0; // half-hour distance accumulation value
};
}

- (void)veepooSDKSettingBaseFunctionType:(VPSettingBaseFunctionSwitchType)baseFunctionType settingState:(VPSettingFunctionState)settingState completeBlock:(void(^)(VPSettingFunctionCompleteState completeState))settingCompleteBlock;

- (void)veepooSDKSettingDeviceHeartAlarmWithHeartAlarmModel:(VPDeviceHeartAlarmModel *)heartAlarmModel settingMode:(NSUInteger)settingMode successResult:(void(^)(VPDeviceHeartAlarmModel *heartAlarmModel))settingHeartAlarmResultBlock failureResult:(void(^)(void))settingHeartAlarmFailureBlock;

@property (nonatomic, assign) NSUInteger temperatureType;

- (void)veepooSDK_temperatureTestStart:(BOOL)start result:(void (^)(VPTemperatureTestState state, BOOL enable, NSInteger progress, NSInteger tempValue, NSInteger originalTempValue))result;

//Body temperature manual test/automatic monitoring switch status
typedef NS_ENUM(NSUInteger, VPTemperatureTestState) {
		VPTemperatureTestStateUnsupported, //Body temperature monitoring function is not supported
		VPTemperatureTestStateOpen, //Body temperature monitoring is turned on
		VPTemperatureTestStateClose, //Body temperature monitoring is turned off
};

- (void)veepooSdkStartReadDeviceTemperatureData:(void(^)(VPReadDeviceBaseDataState readState, NSUInteger totalDay, NSUInteger currentReadDayNumber, NSUInteger readCurrentDayProgress))readStateChangeBlock{}

typedef NS_ENUM(NSInteger, VPReadDeviceBaseDataState) {//Changes in the state of reading basic device data
		VPReadDeviceBaseDataIdle = 0, 		// Status of not starting to read
		VPReadDeviceBaseDataStart = 1, 		// Start reading data
		VPReadDeviceBaseDataReading = 2,  // Reading
		VPReadDeviceBaseDataComplete, 		// Reading is complete
		VPReadDeviceBaseDataInvalid,		  // Not available in SDK
};

+ (NSArray *)veepooSDKGetDeviceTemperatureDataWithDate:(NSString *)queryDate andTableID:(NSString *)tableID;

/* Get the array of automatic temperature measurement data for one day. The array contains dictionaries every 5 minutes. The format is as follows
NSDictionary *dataDic = {
VPDeviceTemperatrueDataMonthKey: month, month
VPDeviceTemperatrueDataDayKey: day, day
VPDeviceTemperatrueDataHourKey: hour, hour
VPDeviceTemperatrueDataMinuteKey: minute, minute
VPDeviceTemperatrueDataValueKey: value, temperature value (Celsius)
VPDeviceTemperatrueDataOriginalValueKey: riginalValue, skin temperature value (Celsius)
}
*/

- (void)veepooSDKSettingBaseFunctionType:(VPSettingBaseFunctionSwitchType)baseFunctionType settingState:(VPSettingFunctionState)settingState completeBlock:(void(^)(VPSettingFunctionCompleteState completeState))settingCompleteBlock;

typedef NS_ENUM(NSInteger, VPSettingFunctionState) {//Set to get a function to read
		VPReadFunctionState = 0, 			//Read the switch and existence of a function
		VPSettingFunctionOpen = 1, 		//Open a function
		VPSettingFunctionClose = 2, 	//Close a function
		VPSettingFunctionCancel = 3, 	//Only dynamic blood pressure calibration is valid now
		VPSettingFunction = 4, 				//Set a function
};

typedef NS_ENUM(NSInteger, VPSettingFunctionCompleteState) {//Set the state after a function is completed
		VPFunctionCompleteUnknown = 0, 		//The device does not have this function
		VPFunctionCompleteOpen = 1, 		  //This function has been turned on
		VPFunctionCompleteClose = 2, 			//This function has been turned off
		VPFunctionCompleteFailure = 3, 		//Setting or reading failed
		VPFunctionCompleteComplete = 4, 	//Setting completed, reply to Data setting
};

- (void)veepooSDKSettingBaseFunctionType:(VPSettingBaseFunctionSwitchType)baseFunctionType settingState:(VPSettingFunctionState)settingState completeBlock:(void(^)(VPSettingFunctionCompleteState completeState))settingCompleteBlock;

typedef NS_ENUM(NSInteger, VPSettingFunctionState) {//Set to get a function to read
		VPReadFunctionState = 0, 			//Read the switch and existence of a function
		VPSettingFunctionOpen = 1, 		//Open a function
		VPSettingFunctionClose = 2, 	//Close a function
		VPSettingFunctionCancel = 3, 	//Only dynamic blood pressure calibration is valid now
		VPSettingFunction = 4, 				//Set a function
};

typedef NS_ENUM(NSInteger, VPSettingFunctionCompleteState) {//Set the state after a function is completed
		VPFunctionCompleteUnknown = 0, 		//The device does not have this function
		VPFunctionCompleteOpen = 1, 			//This function has been turned on
		VPFunctionCompleteClose = 2, 			//This function has been turned off
		VPFunctionCompleteFailure = 3, 		//Setting or reading failed
		VPFunctionCompleteComplete = 4, 	//Setting completed, reply to Data setting
};

@property (nonatomic, assign) NSInteger ecgType;

- (void)veepooSDKAddPTTStateListener:(void(^)(NSInteger pttState))pttListener;

- (void)veepooSDKPTTTest:(BOOL)start valueBlock:(void(^)(VPPttValueModel *valueModel))valueBlock signalBlock:(void(^)(NSArray <NSNumber *>*signals))signalBlock;

- (void)veepooSDKTestECGStart:(BOOL)start testResult:(void(^)(VPTestECGState testECGState, NSUInteger testProgress, VPECGTestDataModel *testModel))testECGResultBlock;

typedef NS_ENUM(NSInteger,VPTestECGState) {//State changes during ECG test
		VPTestECGStateStart = 0,			//Start testing ECG, no results yet
		VPTestECGStateTesting = 1,		//Testing ECG, heart rate value has been measured
		VPTestECGStateNotLead = 2,		//Lead off
		VPTestECGStateDeviceBusy = 3,	//The device is busy and cannot be tested, the test has ended
		VPTestECGStateOver = 4,				//Test ended normally, ended manually
		VPTestECGStateFailure,				//Test failed
		VPTestECGStateComplete,				//Test completed
		VPTestECGStateNoFunction,			//The device does not have this function
};

/// Get ECG data stored offline on all devices on a certain day
/// @param queryDate The date format to be queried is 2021-06-07
/// @param tableID The mac address of the device, which device's data is to be obtained
+ (NSArray<VPECGTestDataModel *> *)veepooSDKGetDeviceOffStoreECGWithDate:(NSString *)queryDate andTableID:(NSString *)tableID;

/// The device side measures the offline storage ECG function and completes the callback
@property (nonatomic, copy) void(^deviceTestOffStoreECGDidFinishBlock)(void);

@property (nonatomic, assign) NSInteger hrvType;

+ (NSArray *)veepooSDKGetDeviceHrvDataWithDate:(NSString *)queryDate andTableID:(NSString *)tableID;

// Get an array of hrv data for one day. The array contains a dictionary for each minute in the following format
NSDictionary *riginalDic = @{
	VPHRVTimeKey:hrvTime, time
	VPHRVValueKey:hrvValue, hrv value
	VPHRVTempKey:hrvTemp1, reserved parameters
	VPHRVHeartsKey:@[This is a string array representing all rr interval values within one minute. Each number multiplied by 10 represents a rr interval value. The Lorenz scatter plot is drawn based on this. All the rr interval values of the minutes should be combined together]
};

@property (nonatomic, assign) NSInteger sleepType;

+ (NSArray *)veepooSDKGetSleepDataWithDate:(NSString *)queryDate andTableID:(NSString *)tableID;

(
{
"DEEP_HOUR" = "2.833"; //Deep sleep time, unit hours
HeartBasic = 1; //Temporarily unused
"LIGHT_HOUR" = "3.667"; //Light sleep time, unit hours
"SLEEP_LEVEL" = 3; //Sleep level interval 1-5 levels: poor, average, good, very good, perfect, you can also customize the language
"SLEEP_TIME" = "2017/02/09 01:15"; //Sleep start time
"SLE_HOUR" = 6; //Total sleep hours, unit hours
"SLE_MINUTE" = 30; //Total sleep minutes, unit minutes SLE_HOUR + SLE_MINUTE or DEEP_HOUR + LIGHT_HOUR is the total sleep time or use WAKE_TIME - SLEEP_TIME to choose which one to use to calculate the total sleep time
"SLE_LINE" = 010000011111111011111111000001110020000001100200000000000001111111111100001100; //Deep and shallow sleep curve, 0 represents light sleep, 1 represents deep sleep, 2 represents waking up at night. Each value represents 5 minutes of sleep time. For example, the first 0 is the first 5 minutes of sleep, the second 1 is the first 5-10 minutes of sleep, the third 0 is 10-15 minutes of sleep, and so on. Customize the deep and shallow sleep curve or graph based on this string
"WAKE_TIME" = "2017/02/09 03:45"; //Sleep end time
WakeUpTime = 0; //Number of wake-ups in each sleep period
}
{
"DEEP_HOUR" = "2.833";
HeartBasic = 1;
"LIGHT_HOUR" = "3.667"; "SLEEP_LEVEL" = 3; "SLEEP_TIME" = "2017/02/09 04:15"; "SLE_HOUR" = 6; "SLE_MINUTE" = 30; "SLE_LINE" = 000000011111110111111110000011100 00000001100000000000000001111111111100001100; "WAKE_TIME" = "2017/02/09 07:45"; WakeUpTime = 0; } )

@interface VPAccurateSleepModel : NSObject
//Type of sleep, upload A7 command sleep flag (sleep type, upload A7 command sleep flag)
@property (nonatomic, strong) NSString *sleepType;
//Sleep time sleep time
@property (nonatomic, strong) NSString *sleepTime;
//Wake up time wake up time
@property (nonatomic, strong) NSString *wakeTime;
//Sleep sign sleep sign
@property (nonatomic, strong) NSString *sleepTag;
//get up score wake up score
@property (nonatomic, strong) NSString *getUpScore;
//Deep sleep score deep sleep score
@property (nonatomic, strong) NSString *deepScore;
//Sleep efficiency score, efficiency score from night to deep sleep Sleeping efficiency score, efficiency score from getting up at night to deep sleep
@property (nonatomic, strong) NSString *sleepEfficiencyScore;
//Sleeping efficiency score, from the start of sleep to the first time into the deep sleep Sleeping efficiency score, from the start of sleep to the first time into the deep sleep efficiency
@property (nonatomic, strong) NSString *fallAsleepScore;

//Sleep duration score
@property (nonatomic, strong) NSString *sleepTimeScore;
//Exit sleep mode
@property (nonatomic, strong) NSString *exitSleepMode;
//Sleep quality 0 to 4, representing 1 to 5 stars respectively
@property (nonatomic, strong) NSString *sleepQuality;
//Number of getting up at night
@property (nonatomic, strong) NSString *getUpTimes;
//Deep and light sleep mode
@property (nonatomic, strong) NSString *deepAndLightMode;
//Total sleep time, in minutes
@property (nonatomic, strong) NSString *sleepDuration;
//Deep sleep time, in minutes
@property (nonatomic, strong) NSString *deepDuration;
//Light sleep time, in minutes
@property (nonatomic, strong) NSString *lightDuration;
//Time to wake up at night, in minutes, wake-up time
@property (nonatomic, strong) NSString *getUpDuration;
//Other sleep time, in minutes, REM period
@property (nonatomic, strong) NSString *otherDuration;
//Time to enter deep sleep for the first time, sleep efficiency
@property (nonatomic, strong) NSString *firstDeepDuration;
//Average value of time from waking up at night to deep sleep, sleep efficiency
@property (nonatomic, strong) NSString *getUpToDeepAve;
//Time represented by a point on the curve, in seconds, now 60s
@property (nonatomic, strong) NSString *onePointDuration;
//Accurate sleep type, 1 is accurate sleep, 0 is normal sleep
@property (nonatomic, strong) NSString *accurateType;
//Insomnia flag
@property (nonatomic, strong) NSString *insomniaTag;
//Insomnia score
@property (nonatomic, strong) NSString *insomniaScore;
//Number of insomnias
@property (nonatomic, strong) NSString *insomniaTimes;
//beginTime start time, how many minutes to start sleeping, endTime end time, how many minutes to start sleeping
@property (nonatomic, strong) NSArray *insomniaRecord;
//Sleep curve, hexadecimal string, converted into data stream when parsed by the client, each two bytes represent a point (one minute), the high bit is in front, the low bit is in the back, the high 3 bits represent the state of sleep, deep sleep (0), light sleep (1), rapid eye movement (2), insomnia (3), awake (4) For example, for the number 0x1000, take the high 3 bits 0x1000>>13, the value obtained depends on which one is between 0 and 4.
@property (nonatomic, strong) NSString *sleepLine;

//Insomnia duration converted according to the curve
@property (nonatomic, strong) NSString *insomniaDuration;

//These two fields, if lastType == 1, it means to be spliced with the previous sleep segment, if nextType==1, it means to be spliced with the next sleep segment, after splicing, except for falling asleep and waking up, which need to be modified, and the curve needs to be spliced, the rest use the last segment
@property (nonatomic, strong) NSString *lastType;
@property (nonatomic, strong) NSString *nextType;
@property (nonatomic, strong) NSString *mac;
@end

/*
sleepLine sleep curve analysis method, processed into a dictionary object, the data structure is
@{
		@"index": 0, //NSNumber type index, corresponding to the number of minutes of data
		@"type": 0 //NSNumber type current index of sleep state, deep sleep (0), light sleep (1), rapid eye movement (2), insomnia (3), awake (4)
}
Note: KH series does not have [rapid eye movement (2), insomnia (3)] two states
*/
- (NSArray<NSDictionary *> *)parseSleepLine;

//Number of normal dials
@property (nonatomic, assign) NSUInteger dialCount;

//Number of market dials
@property (nonatomic, assign) NSUInteger marketDialCount;

//Number of photo dials
@property (nonatomic, assign) NSUInteger photoDialCount;

- (void)veepooSDK_dialChannelWithChannelModel:(VPDialChannelModel)model
                                     dialType:(VPDeviceDialType)dialType
                               photoDialModel:(VPPhotoDialModel *)photoDialModel
                                       result:(void (^)(VPPhotoDialModel *photoDialModel, VPDeviceMarketDialModel *deviceMarketDialModel, NSError *error))result
                            transformProgress:(void (^)(double progress))transformProgress;

typedef NS_ENUM(NSUInteger, VPDialChannelModel) {
		VPDialChannelModelSetup = 1,			  // Setting mode for internal use
		VPDialChannelModelRead, 						// Reading mode
		VPDialChannelModelSetupPhotoDial,   // Photo dial setting element mode
};

typedef NS_ENUM(NSUInteger, VPDeviceDialType) {
		VPDeviceDialTypeDefault = 0, // Default burn-in dial
		VPDeviceDialTypeMarket,      // Market dial
		VPDeviceDialTypePhoto,       // Photo dial
};

- (void)getVeepooServerAllMarketDialsWithDeviceInfo:(VPDeviceMarketDialModel *)model
                                            success:(void(^)(NSArray<VPServerMarketDialModel *> * _Nullable response))success
                                            failure:(void(^)(NSError * _Nullable error, NSInteger errorcode))fairlure

- (void)downloadMarketDialBinFileWithModel:(VPServerMarketDialModel *)model
                     deviceMarketDialModel:(VPDeviceMarketDialModel *)deviceMarketDialModel
                                   success:(void(^)(NSURL * _Nullable filePath))success
                                   failure:(void(^)(NSError * _Nullable error, NSInteger errorcode))fairlure;

- (void)startTransferWithFilePath:(NSURL *)filePath transformProgress:(void(^)(double progress))transformProgress failure:(void(^)(NSError * _Nullable error))fairlure;

- (void)openJLDialFileSystemWithAction:(void(^)(BOOL success))action;

- (void)getJLWatchNamesWithAction:(void(^)(NSArray<NSString *> * _Nullable array))action

- (void)getJLCurrentPhotoAndMarketWatchNameWithArray:(NSArray<NSString *> *)array
                                              result:(void(^)(NSString *_Nullable photoWatchName, NSString * _Nullable marketWatchName))result;

// Address book type， 1 means yes 0 means no
@property (nonatomic, assign) NSUInteger contactType;

- (void)veepooSDKSettingDeviceContactsWithOpCode:(VPDeviceContactsOpCode)opCode
                                         opModel:(VPDeviceContactsModel *)opModel
                                            toID:(int)toID
                                     resultBlock:(void(^)(VPDeviceContactsOpState state, NSArray<VPDeviceContactsModel *> *contactModels))resultBlock;

// Device address book operation type
typedef NS_ENUM(NSUInteger, VPDeviceContactsOpCode) {
		VPDeviceContactsOpCodeRead = 0,   // Read
		VPDeviceContactsOpCodeAdd,        // Add
		VPDeviceContactsOpCodeDelete,     // Delete
		VPDeviceContactsOpCodeMove        // Move
};

// Contacts operation status
typedef NS_ENUM(NSUInteger, VPDeviceContactsOpState) {
		VPDeviceContactsOpStateNoFunction = 0,   // This function is not supported
		VPDeviceContactsOpStateReading,          // Reading
		VPDeviceContactsOpStateComplete,         // Operation successful
		VPDeviceContactsOpStateFailure           // Operation failed
};

/// Number of SOS calls made in the address book
/// @param opCode Operation type Read/Set
/// @param times Number, please limit it to [timesMin, timesMax] returned by resultBlock, only valid when setting
/// @param resultBlock result callback, when setting operation, timesMin and timesMax returned are 0
- (void)veepooSDKSettingDeviceContactsSOSInfoWithOpCode:(VPSOSOperationType)opCode
                                                  times:(int)times
                                            resultBlock:(void(^)(VPDeviceContactsOpState state, int times, int timesMin, int timesMax))resultBlock;

// SOS operation type
typedef NS_ENUM(NSUInteger, VPSOSOperationType) {
    VPSOSOperationTypeSetting,     // Set up
    VPSOSOperationTypeRead         // Read
};

//Receive the callback of the bracelet searching for the phone. You can set this property to monitor. The device will call back every 4 seconds during the process of searching for the phone. The user can play a 3-second audio after receiving the callback.
@property (nonatomic, copy) void(^ReceiveDeviceSearchIphoneCommand)(void);

@property (nonatomic, assign) NSUInteger searchDeviceFunction;

- (void)veepooSDK_searchDeviceFuntionWithState:(BOOL)open result:(void (^)(BOOL open, VPSearchDeviceFunctionState state))result;

//Mobile phone searches for bracelet status
typedef NS_ENUM(NSUInteger, VPSearchDeviceFunctionState) {
		VPSearchDeviceFunctionStateUnsupported,   //Function not supported
		VPSearchDeviceFunctionStateEnter, 		    //Device enters search state
		VPSearchDeviceFunctionStateExit,			    //Device exits search state
		VPSearchDeviceFunctionStateTimeout,       //Device search timeout
};

- (void)veepooSDKSettingMessageType:(VPSettingMessageSwitchType)messageType settingState:(VPSettingFunctionState)settingState completeBlock:(void(^)(VPSettingFunctionCompleteState completeState))settingCompleteBlock;

/// Message push (information reminder) batch processing interface, the push types that the device does not support will be automatically ignored
/// @param models array of push types to be processed
/// @param settingCompleteBlock setting status Block will be empty inside
- (void)veepooSDKBatchSettingWithMessageTypeModels:(NSArray<VPDeviceMessageTypeModel *> *)models
                                     completeBlock:(void(^)(VPSettingFunctionCompleteState completeState))settingCompleteBlock;

typedef NS_ENUM(NSInteger, VPSettingMessageSwitchType) {//About the type of call reminder
    VPSettingUnkonw = 1, //Unknown Type
    VPSettingCall = 2, //Incoming call settings
    VPSettingSMS,//SMS settings
    VPSettingWechat,
    VPSettingQQ,
    VPSettingSina,
    VPSettingFaceBook,
    VPSettingTwitter,
    VPSettingFlickr,
    VPSettingLinkedln,
    VPSettingwhatsapp,
    VPSettingLine,
    VPSettingInstagram,
    VPSettingSnapchat,
    VPSettingSkype,
    VPSettingGMail,
    VPSettingDingTalk,
    VPSettingWeChatWork,
    VPSettingOtherPlatform = 19,
    // Second Package
    VPSettingOtherTikTok = 20,
    VPSettingOtherTelegram = 21,
    VPSettingOtherConnected2 = 22,
    VPSettingKakaoTalk = 23,
    VPSettingJingYou = 24, // JingYou APP
    VPSettingMessenger = 25,
    VPSettingAll = 100,//Set all, read usage cannot use this
}

typedef NS_ENUM(NSInteger, VPSettingFunctionState) {//Set to get a function to read
		VPReadFunctionState = 0, //Read the switch and existence of a function
		VPSettingFunctionOpen = 1, //Open a function
		VPSettingFunctionClose = 2, //Close a function
		VPSettingFunctionCancel = 3, //Only dynamic blood pressure calibration is valid now
		VPSettingFunction = 4, //Set a function
};

typedef NS_ENUM(NSInteger, VPSettingFunctionCompleteState) {//Set the state after a function is completed
		VPFunctionCompleteUnknown = 0, //The device does not have this function
		VPFunctionCompleteOpen = 1, //This function has been turned on
		VPFunctionCompleteClose = 2, //This function has been turned off
		VPFunctionCompleteFailure = 3, //Setting or reading failed
		VPFunctionCompleteComplete = 4, //Setting completed, reply to Data setting
};

@property (nonatomic, assign) NSUInteger CPUType;

- (void)veepooSDK_openDeviceBTSwitch;

@property (nonatomic, copy) void(^VPBTConnectStateChangeBlock)(VPDeviceBTState btState, BOOL btSwitchOpen, BOOL mediaSwitchOpen);

typedef NS_ENUM(NSInteger, VPDeviceBTState) {
		VPDeviceBTStateDisConnect = 0, 	//Disconnected
		VPDeviceBTStateConnected,       //Connected
		VPDeviceBTStateAdvertising,     //Advertising
};

//The device's display version tells the user what the current version is
@property (nonatomic, strong, readonly) NSString *deviceVersion;

//Device network upgrade version. When the user receives a new firmware version, the user will be informed of the upgraded version.
@property (nonatomic, strong, readonly) NSString *deviceNetVersion;

//Device upgrade update version description, multiple descriptions are separated by the $ symbol, and multiple descriptions can be split by $
@property (nonatomic, strong) NSString *deviceNetVersionDes;

/// Check whether the current device has a new firmware version. Please use this interface in production environment. For testing, you can use {@link checkDeviceOTAInfoWithDebug:downloadProgress:completionHandler:}
/// @param downloadProgressBlock firmware download progress
/// @param completionHandler request completion handler. If newVersion is not empty, it means there is a new firmware.
- (void)checkDeviceOTAInfoWithDownloadProgress:(void (^)(NSProgress *downloadProgress))downloadProgressBlock
                             completionHandler:(void (^)(NSString *newVersion, NSString *des, NSError *error))completionHandler;

/// Check if the current device has a new firmware version
/// @param debug is the test environment, ⚠️ note that the production environment cannot use yes
/// @param downloadProgressBlock firmware download progress
/// @param completionHandler request completion handler, newVersion is not empty to indicate new firmware
- (void)checkDeviceOTAInfoWithDebug:(BOOL)debug
                   downloadProgress:(void (^)(NSProgress *downloadProgress))downloadProgressBlock
                  completionHandler:(void (^)(NSString *newVersion, NSString *des, NSError *error))completionHandler;

/**
Interface for upgrading. SDK can automatically obtain firmware from our server and upgrade directly.

@param dfuBlock returns the status and progress of the block
 */
- (void)veepooSDKStartDfu:(DeviceDFUBlock)dfuBlock;

typedef void(^DeviceDFUBlock)(double progress, DeviceDFUState deviceDFUState);

typedef NS_ENUM(NSInteger, DeviceDFUState) {
		DeviceDFUFileNotExist = 0, //Upgrade file does not exist
		DeviceDFUStart, 					 //Start upgrading
		DeviceDFUUpdating, 				 //Upgrading
		DeviceDFUSuccess,				   //Upgrade successful
		DeviceDFUFailure, 				 //Upgrade failed
		DeviceDFUPrepared, 				 //Data verification of K series devices completed
		DeviceDFUReboot 				   //K series device restart
};

/// Developers pass in the upgrade file path to upgrade
/// @param dfuBlock upgrade callback, if the file path does not exist or the file format is incorrect, the file path does not exist will be returned
- (void)veepooSDKStartDfuWithFilePath:(NSString *)filePath result:(DeviceDFUBlock)dfuBlock;

- (void)veepooSDKSettingDeviceLongSeatWithLongSeatModel:(VPDeviceLongSeatModel *)longSeatModel
                                            settingMode:(NSUInteger)settingMode
                                          successResult:(void(^)(VPDeviceLongSeatModel *longSeatModel))settingLongSeatResultBlock
                                          failureResult:(void(^)(void))settingLongSeatFailureBlock;

- (void)veepooSDKSettingDeviceTextAlarmWithTextAlarmModel:(VPDeviceTextAlarmModel *)alarmModel
                                              settingMode:(VPDeviceTextAlarmSettingModel)settingMode
                                            successResult:(void(^)(NSArray *alarmArray))settingTextAlarmResultBlock
                                            failureResult:(void(^)(void))settingTextAlarmFailureBlock;

// Text alarm setting mode
typedef NS_ENUM(NSUInteger, VPDeviceTextAlarmSettingModel) {
    VPDeviceTextAlarmSettingModelDelete = 1,
    VPDeviceTextAlarmSettingModelAddOrChange,
    VPDeviceTextAlarmSettingModelRead
};

- (void)veepooSDKSettingDeviceNewAlarmWithNewAlarmModel:(VPDeviceNewAlarmModel *)alarmModel
                                            settingMode:(NSUInteger)settingMode
                                          successResult:(void(^)(NSArray *alarmArray))settingNewAlarmResultBlock
                                          failureResult:(void(^)(void))settingNewAlarmFailureBlock;

- (void)veepooSDKSettingDeviceFemaleWithFemaleModel:(VPDeviceFemaleModel *)femaleModel
                                        settingMode:(NSUInteger)settingMode
                                      successResult:(void(^)(VPDeviceFemaleModel *deviceFemaleModel))settingFemaleResultBlock
                                      failureResult:(void(^)(void))settingFemaleFailureBlock;

typedef NS_ENUM(NSInteger,VPDeviceFemaleState) {//Which physiological period does the female project belong to
		VPDeviceFemaleStateNone = 0,		  //No physiological period is set
		VPDeviceFemaleStateMenstrual,     //Menstrual period
		VPDeviceFemaleStatePregnancy,     //Pregnancy period
		VPDeviceFemaleStateGestation,     //Pregnancy period
		VPDeviceFemaleStateBaoma,	        //Hot mom period
};

- (void)veepooSDKSettingCameraType:(VPCameraType)settingType settingAndMonitorResult:(void(^)(VPCameraType cameraType))cameraBlock;

typedef NS_ENUM(NSInteger,VPCameraType) {
  	VPCameraTypeExit = 0,  //Exit photo taking
		VPCameraTypeEnter = 1, //Enter photo taking
		VPCameraTypePhoto = 2  //Start photo taking
};

// First call this Interface to synchronize data from the device to the SDK
- (void)veepooSDKStartReadDeviceRunningData:(void(^)(VPReadDeviceBaseDataState readState, NSUInteger totalTimes, NSUInteger currentReadTimes, NSUInteger readCurrentTimesProgress))readDeviceRunningBlock;
// Read data from the SDK database
+ (NSArray *)veepooSDKGetDeviceRunningDataWithDate:(NSString *)queryDate andTableID:(NSString *)tableID;

[{
    aerobTime = 1260;
    averHeart = 81;
    averPace = 0;
    beginTime = "2023-05-17 20:16:25";
    crcValue = 47136;
    endTime = "2023-05-17 20:37:33";
    isHide = 0;
    oneMinuteData =     (
                {
            calValue = 0;
            disValue = 0;
            heartValue = 86;
            isPause = 0;
            packageCount = 00001;
            sportValue = 5;
            stepValue = 0;
        }
    );
    pauseCount = 0;
    pauseTotalTime = 0;
    recordCount = 5376;
    totalCal = 0;
    totalDis = 0;
    totalSport = 124;
    totalStep = 0;
    totalTime = 1268;
    type = 1;
}]

// Get a single day's Running Data from the database
let arr = VPDataBaseOperation.veepooSDKGetDeviceRunningData(withDate: 0.getOneDayDateString(), andTableID: VPBleCentralManage.sharedBleManager().peripheralModel.deviceAddress)

- (void)veepooSDKSettingDeviceRunning:(int)settingType
                              runMode:(VPDeviceRuningMode)runningMode
                               result:(void(^)(int runningType, BOOL settingSuccess))runningResultBlock;

/// Callback when the device ends a set of motion and generates valid data
@property (nonatomic, copy) void(^deviceSportDidFinishBlock)(BOOL success);

typedef NS_ENUM(NSInteger,VPDeviceRuningMode) {//Sport mode type
    VPDeviceRuningModeCommon = 0, //Normal single sports mode
    VPDeviceRuningModeOutdoorRun, //Outdoor running
    VPDeviceRuningModeOutdoorWalk, //Outdoor walking
    VPDeviceRuningModeIutdoorRun, //Indoor running
    VPDeviceRuningModeIutdoorWalk, //Indoor walking
    VPDeviceRuningModeHiking, //Hiking
    VPDeviceRuningModeStairStepper, //Stepper
    VPDeviceRuningModeOutdoorCycle, //Outdoor cycling
    VPDeviceRuningModeStationaryBike, //Indoor cycling
    VPDeviceRuningModeElliptical, //Elliptical machine
    VPDeviceRuningModeRowingMachine, //Rowing machine
    VPDeviceRuningModeMountaineering, //Mountaineering
    VPDeviceRuningModeSwim, //Swimming
    VPDeviceRuningModeSitUps, //Sit-ups
    VPDeviceRuningModeSki, //Skiing
    VPDeviceRuningModeJumpRope, //Rope skipping
    VPDeviceRuningModeYoga, //Yoga
    VPDeviceRuningModePingpong, //Table tennis
    VPDeviceRuningModeBasketball, //Basketball
    VPDeviceRuningModeVolleyball, //Volleyball
    VPDeviceRuningModeFootball, //Football
    VPDeviceRuningModeBadminton, //Badminton
    VPDeviceRuningModeTennis, //Tennis
    VPDeviceRuningModeClimbStairs, //Climbing stairs
    VPDeviceRuningModeFitness, //Fitness
    VPDeviceRuningModeWeightlifting, //Weightlifting
    VPDeviceRuningModeDiving, //Diving
    VPDeviceRuningModeBoxing, //Boxing
    VPDeviceRuningModeGymBall, //Fitness ball
    VPDeviceRuningModeSquatTraining, //Squat training
    VPDeviceRuningModeTriathlon, //Triathlon
    VPDeviceRuningModeDance, //Dance
    VPDeviceRuningModeHIIT, //HIIT
    VPDeviceRuningModeRockClimbing, //Rock climbing
    VPDeviceRuningModeSports, //Athletics
    VPDeviceRuningModeBalls, //Ball games
    VPDeviceRuningModeFitnessGame, //Fitness games
    VPDeviceRuningModeFreeTime, //Free time
    VPDeviceRuningModeAerobics, //Aerobics
    VPDeviceRuningModeGymnastics, //Gymnastics
    VPDeviceRuningModeFloorExercise, //Floor exercises
    VPDeviceRuningModeHorizontalBar, //Horizontal bar
    VPDeviceRuningModeParallelBars, //Parallel bars
    VPDeviceRuningModeTrampoline, //Trampoline
    VPDeviceRuningModeTrackAndField, //Athletics
    VPDeviceRuningModeMarathon, //Marathon
    VPDeviceRuningModePushUps, //Pushups
    VPDeviceRuningModeDumbbel, //Dumbbell
    VPDeviceRuningModeRugbyFootball, //Rugby
    VPDeviceRuningModeHandball, //Handball
    VPDeviceRuningModeBaseballSoftball, //Baseball
    VPDeviceRuningModeBaseball, //Baseball
    VPDeviceRuningModeHockey, //Hockey
    VPDeviceRuningModeGolf, //Golf
    VPDeviceRuningModeBowling, //Bowling
    VPDeviceRuningModeBilliards, //Billiards
    VPDeviceRuningModeRowing, //Rowing
    VPDeviceRuningModeSailboat, //Sailing
    VPDeviceRuningModeSkate, //Ice skating
    VPDeviceRuningModeCurling, //Curling
    VPDeviceRuningModePuck, //Ice hockey
    VPDeviceRuningModeSled, //Sled
    VPDeviceRuningModeStrongWalk, //Strong walking
    VPDeviceRuningModeTreadmill, //Treadmill
    VPDeviceRuningModeTrailRunning, //Cross-country running
    VPDeviceRuningModeRaceWalking, //Race walking
    VPDeviceRuningModeMountainBiking, //Mountain biking
    VPDeviceRuningModeBmx, //BMX
    VPDeviceRuningModeOrienteering, //Orienteering
    VPDeviceRuningModeFishing, //Fishing
    VPDeviceRuningModeHunt, //hunting
    VPDeviceRuningModeSkateboard, //skateboard
    VPDeviceRuningModeRollerSkating, //roller skating
    VPDeviceRuningModeParkour, //parkour
    VPDeviceRuningModeAtv, //beach buggy
    VPDeviceRuningModeMotocross, //off-road motorcycle
    VPDeviceRuningModeClimbingMachine, //stair climbing machine
    VPDeviceRuningModeSpinningBike, //spinning bike
    VPDeviceRuningModeIndoorFitness, //indoor fitness
    VPDeviceRuningModeMixedAerobic, //mixed aerobic
    VPDeviceRuningModeCrossTraining, //cross training
    VPDeviceRuningModeBodybuildingExercise, //fitness exercise
    VPDeviceRuningModeGroupGymnastics, //group exercise
    VPDeviceRuningModeKickboxing, //kickboxing exercise
    VPDeviceRuningModeStrengthTraining, //Strength training
    VPDeviceRuningModeSteppingTraining, //Stepping training
    VPDeviceRuningModeCoreTraining, //Core training
    VPDeviceRuningModeFlexibilityTraining, //Flexibility training
    VPDeviceRuningModeFreeTraining, //Free training
    VPDeviceRuningModePilates, //Pilates
    VPDeviceRuningModeBattleRope, //Battle rope
    VPDeviceRuningModeStretch, //Stretching
    VPDeviceRuningModeSquareDance, //Square dance
    VPDeviceRuningModeBallroomDancing, //Ballroom dance
    VPDeviceRuningModeBellyDance, //Belly dance
    VPDeviceRuningModeBallet, //Ballet
    VPDeviceRuningModeHipHop, //Street dance
    VPDeviceRuningModeZumba, //Zumba
    VPDeviceRuningModeLatinDance, //Latin dance
    VPDeviceRuningModeJazz, //Jazz dance
    VPDeviceRuningModeHipHopDance, //Hip-hop dance
    VPDeviceRuningModePoleDancing, //Pole dance
    VPDeviceRuningModeBreakDance, //Break dance
    VPDeviceRuningModeNationalDance, //National dance
    VPDeviceRuningModeModernDance, //Modern dance
    VPDeviceRuningModeDisco, //Disco
    VPDeviceRuningModeTapDance, //Tap dance
    VPDeviceRuningModeWrestling, //Wrestling
    VPDeviceRuningModeMartialArts, //Martial Arts
    VPDeviceRuningModeTaiChi, //Taichi
    VPDeviceRuningModeMuayThai, //Muay Thai
    VPDeviceRuningModeJudo, //Judo
    VPDeviceRuningModeTaekwondo, //Taekwondo
    VPDeviceRuningModeKarate, //Karate
    VPDeviceRuningModeFreeSparring, //Free Sparring
    VPDeviceRuningModeSwordsmanship, //Swordsmanship
    VPDeviceRuningModeJujitsu, //Jujitsu
    VPDeviceRuningModeFencing, //Fencing
    VPDeviceRuningModeBeachSoccer, //Beach Soccer
    VPDeviceRuningModeBeachVolleyball, //Beach Volleyball
    VPDeviceRuningModeSoftball, //Softball
    VPDeviceRuningModeSquash, //Squash
    VPDeviceRuningModeCroquet, //Croquet
    VPDeviceRuningModeCricket, //Cricket
    VPDeviceRuningModePolo, //Polo
    VPDeviceRuningModeWallball, //Wallball
    VPDeviceRuningModeTakrawBall, //Sepakraw
    VPDeviceRuningModeDodgeball, //Dodgeball
    VPDeviceRuningModeWaterPolo, //Water Polo
    VPDeviceRuningModeShuttlecock, //Shuttlecock
    VPDeviceRuningModeIndoorSoccer, //Indoor Soccer
    VPDeviceRuningModeSandbagBall, //Sandbag
    VPDeviceRuningModeBocceBall, //Bocce
    VPDeviceRuningModeJaileyball, //Plait
    VPDeviceRuningModeFloorball, //Floorball
    VPDeviceRuningModeOutdoorBoating, //Outdoor Boating
    VPDeviceRuningModeKayak, //Kayaking
    VPDeviceRuningModeDragonBoat, //Dragon Boat
    VPDeviceRuningModePaddleBoard, //Paddle board surfing
    VPDeviceRuningModeIndoorFillingWaves, //Indoor filling waves
    VPDeviceRuningModeDrifting, //Rafting
    VPDeviceRuningModeWaterSkiing, //Water skiing
    VPDeviceRuningModeSnowboarding, //Snowboarding
    VPDeviceRuningModeSnowboard, //Snowboarding
    VPDeviceRuningModeAlpineSkiing, //Alpine skiing
    VPDeviceRuningModeCrossCountrySkiing, //Cross-country skiing
    VPDeviceRuningModeOrienteeringSki, //Orienteering skiing
    VPDeviceRuningModeBathlon, //Biathlon
    VPDeviceRuningModeOutdoorSkating, //Outdoor skating
    VPDeviceRuningModeIndoorSkating, //Indoor skating
    VPDeviceRuningModeSnowCar, //Snowmobile
    VPDeviceRuningModeSnowmobile, //Snowmobile
    VPDeviceRuningModeSnowshoeing, //Snowshoeing
    VPDeviceRuningModeHulaHoop, //Hula Hoop
    VPDeviceRuningModeFrisbee, //Frisbee
    VPDeviceRuningModeDart, //Darts
    VPDeviceRuningModeFlyAKite, //Kite Flying
    VPDeviceRuningModeTugOfWar, //Tug of War
    VPDeviceRuningModeShuttlecockKicking, //Shuttlecock Kicking
    VPDeviceRuningModeESports, //Esports
    VPDeviceRuningModeWanderingMachine, //Wandering Machine
    VPDeviceRuningModeSwing, //Swing
    VPDeviceRuningModeShuffleboard, //Shuffleboard
    VPDeviceRuningModeTableSoccer, //Table Football
    VPDeviceRuningModeSomatosensoryGame, //Sensory Game
    VPDeviceRuningModeInternationalChess, //International Chess
    VPDeviceRuningModeDraughts, //Draughts
    VPDeviceRuningModeGo, //Go
    VPDeviceRuningModeBridge, //Bridge
    VPDeviceRuningModeBoardGame, //Board Games
    VPDeviceRuningModeArchery, //Archery
    VPDeviceRuningModeEquestrianSports, //Equestrian Sports
    VPDeviceRuningModeClimbingTheStairs, //Stairs Climbing
    VPDeviceRuningModeDrive, //Driving
    VPDeviceRuningModeSeatedPush, //Seated Press
    VPDeviceRuningModeSeatedChestPress, //Seated Chest Press
    VPDeviceRuningModeBarbell, //Barbell
    VPDeviceRuningModeLongDistanceRunning, //Long Distance Running
    VPDeviceRuningModeFullSpeedRun, //Full Speed Running
    VPDeviceRuningModeVariableSpeedRun, //Variable Speed Running
    VPDeviceRunningModeRaceRiding, //Cycling on the track
    VPDeviceRuningModeMilitaryChess, //Military chess
    VPDeviceRuningModeMahjong, //Mahjong
    VPDeviceRuningModePoker, //Poker
    VPDeviceRuningModeGobang, //Gobang
    VPDeviceRuningModeChineseChess, //Chinese chess
    VPDeviceRuningModeHighJump, //High jump
    VPDeviceRuningModeLongJump, //Long jump
    VPDeviceRuningModeSpinningTop, //Spinning top
};