From: luozheng <1732036298@qq.com> Date: Tue, 20 May 2025 08:23:29 +0000 (+0800) Subject: Merge branch 'sdk650pathc0423' of https://codeup.aliyun.com/64191456b9581d62e8f81ac0... X-Git-Tag: leiniao_debug_1.0.0_20250922_020716~298 X-Git-Url: http://git.snicker.com.cn/css/static/gitweb.css?a=commitdiff_plain;h=refs%2Fchanges%2F1769%2F1;p=mirrors%2FFD230.git Merge branch 'sdk650pathc0423' of https://codeup.aliyun.com/64191456b9581d62e8f81ac0/FD230 into sdk650pathc0423 --- 723b5620b4b6f83fe69c0f3dfa6f33238c44a99b diff --cc code/sdk/application/wearable/fd230/nativeapp/CMakeLists.txt index d13a673b9,d13a673b9..4c110e326 --- a/code/sdk/application/wearable/fd230/nativeapp/CMakeLists.txt +++ b/code/sdk/application/wearable/fd230/nativeapp/CMakeLists.txt @@@ -99,7 -99,7 +99,7 @@@ set(PRIVATE_HEADE ${ROOT_DIR}/application/wearable/service/dial_market ${ROOT_DIR}/open_source/openharmony/third_party/cJSON -- ++ ${ROOT_DIR}/zhihui/drivers/ ${ROOT_DIR}/zhihui/UI/CustomUIComponentTool/ ${ROOT_DIR}/zhihui/UI/producttest/include/ ${ROOT_DIR}/application/wearable/fd230/nativeabilityfwk/include diff --cc code/sdk/application/wearable/fd230/nativeapp/nativeui/alarmclocktimerconfig/src/AlarmClockTimerConfig.cpp index 8a13ed56d,135ebd78d..df491d944 --- a/code/sdk/application/wearable/fd230/nativeapp/nativeui/alarmclocktimerconfig/src/AlarmClockTimerConfig.cpp +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/alarmclocktimerconfig/src/AlarmClockTimerConfig.cpp @@@ -18,760 -18,178 +18,760 @@@ #include "AlarmClockTimerConfig.h" -#ifdef __cplusplus -extern "C" { +#include "ConfigModelC.h" +#include "ConfigModel.h" +#include "heartrate/include/HeartModel.h" +#include "sleep/include/SleepModel.h" +#include "sleepmode/include/SleepModeModel.h" +// #include "safemodemanager/include/SafeModeManagerModel.h" +#include "cat1_server_hal.h" +#include "custom_runtime.h" +#include "uiservice/include/ui_service.h" +#include "power_display_service.h" +#include +#include "AppViewIDs.h" +#include "player/include/PlayersView.h" +#include "record/include/RecordingPlayerView.h" +#include "custom_utils.h" +#include "alarm/include/AlarmClockModel.h" +#ifdef CYWEE_SPORT +#include "cywee_service.h" #endif - #ifdef PPG_HX3695 -static AlarmCtrl g_alarmCtrA; -static AlarmCtrl g_alarmCtrB; -namespace OHOS { -GraphicTimer* g_AlarmHandle = nullptr; -} ++#ifdef SUPPORT_PPG_SERVICE +#include "ppg_service.h" +#endif -void AlarmTimerEventPublish(uint16 topic, AlarmClockEventData data) +#ifdef __cplusplus +extern "C" { - int32 ret; - uint32 size = sizeof(AlarmClockEventData); - BroadcastApi *broadcastApi = nullptr; - IUnknown *api = nullptr; +#endif - WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "AlarmTimerEventPublish topic=%u!!", topic); + static AlarmCtrl g_alarmCtrA; + static AlarmCtrl g_alarmCtrB; + static osTimerId_t g_AlarmHandle = nullptr; - void *publishData = malloc(size); - if (publishData == nullptr) { - return; +#define SLEPPNOTIFY 20 + + static int sleep_time = 0; + static int wake_up_time = 0; + static int sleep_notify_time = 0; + static int sleep_time_hour = 0; + static int sleep_time_min = 0; + static int wake_time_hour = 0; + static int wake_time_min = 0; + static int sedentary_switch = 0; + static int sedentary_interval = 1; + static int sedentary_time = 0; + static int sedentary_start_hour = 0; + static int sedentary_start_min = 0; + static int sedentary_stop_hour = 0; + static int sedentary_stop_min = 0; + static int drinkreminder_switch = 0; /*喝水提醒开关:0 关闭 1开始 2间隔提醒*/ + static int drinkreminder_start_time = 0; /*喝水提醒开始时间*/ + static int drinkreminder_start_hour = 0; /*喝水提醒开始小时*/ + static int drinkreminder_start_min = 0; /*喝水提醒开始分钟*/ + static int drinkreminder_end_time = 0; /*喝水提醒结束时间*/ + static int drinkreminder_end_hour = 0; /*喝水提醒结束小时*/ + static int drinkreminder_end_min = 0; /*喝水提醒结束分钟*/ + static int drinkreminder_freq = 0; /*喝水提醒频率*/ + static int drinkreminder_goal = 0; /*喝水提醒目标ml*/ + static int drinkremind_expectedTime = 0; + static int sleep_notify_time_min = 0; + static int sleep_notify_time_hour = 0; + static int time_sync_flag = 0; + + // #define SEDENTARY_TIME_RANGE (((curTime.tm_hour > sedentary_start_hour) || (curTime.tm_hour == sedentary_start_hour && curTime.tm_min >= sedentary_start_min)) && \ +// ((curTime.tm_hour < sedentary_stop_hour) || (curTime.tm_hour == sedentary_stop_hour && curTime.tm_min < sedentary_stop_min))) + + // #define WAKE_TIME_RANGE (((wake_time_hour < sleep_time_hour) && \ +// ((curTime.tm_hour > wake_time_hour) || \ +// (curTime.tm_hour == wake_time_hour && curTime.tm_min >= wake_time_min)) && \ +// ((curTime.tm_hour < sleep_time_hour) || \ +// (curTime.tm_hour == sleep_time_hour && curTime.tm_min < sleep_time_min))) || \ +// ((wake_time_hour >= sleep_time_hour) && \ +// (((curTime.tm_hour > wake_time_hour) || \ +// (curTime.tm_hour == wake_time_hour && curTime.tm_min >= wake_time_min)) || \ +// ((curTime.tm_hour < sleep_time_hour) || \ +// (curTime.tm_hour == sleep_time_hour && curTime.tm_min < sleep_time_min))) || \ +// ((curTime.tm_hour > wake_time_hour) && (curTime.tm_hour < sleep_time_hour)))) + + // 设置目标睡眠时间 + void set_sleep_and_wake_time(void) + { + sleep_time = get_sleep_time_from_config_model(); + wake_up_time = get_wake_up_time_from_config_model(); + // 解析开始时间 + sleep_time_hour = (sleep_time & 0xFFFF0000) >> 16; + sleep_time_min = sleep_time & 0x0000FFFF; + wake_time_hour = (wake_up_time & 0xFFFF0000) >> 16; + wake_time_min = wake_up_time & 0x0000FFFF; + clean_sleep_monitoring_flag(); + // 解析结束时间 + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "sleep_time_hour:%d sleep_time_min:%d wake_time_hour:%d wake_time_min:%d", sleep_time_hour, sleep_time_min, wake_time_hour, wake_time_min); } - ret = memcpy_s(publishData, size, (const void *)&data, size); - if (ret != EOK) { - free(publishData); - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "AlarmTimerEventPublish memcpy_s fail! ret = %d", ret); - return; + + void set_sedentary_data(void) + { + sedentary_switch = get_sedentary_switch_from_config_model(); + sedentary_time = get_sedentary_time_from_config_model(); + sedentary_interval = get_sedentary_interval_from_config_model(); + #ifdef CYWEE_SPORT + do_cywee_service_check_msg(CYWEE_SERVICE_CMD_SET_SEDENTARY_INTERVAL, &sedentary_interval); // 设置久坐提醒间隔 + #endif + + // sedentary_start_hour = (sedentary_time & 0XFF000000) >> 24; + // sedentary_start_min = (sedentary_time & 0X00FF0000) >> 16; + // sedentary_stop_hour = (sedentary_time & 0X0000FF00) >> 8; + // sedentary_stop_min = sedentary_time & 0X000000FF; + sedentary_stop_min = (sedentary_time & 0XFF000000) >> 24; + sedentary_stop_hour = (sedentary_time & 0X00FF0000) >> 16; + sedentary_start_min = (sedentary_time & 0X0000FF00) >> 8; + sedentary_start_hour = sedentary_time & 0X000000FF; + clean_sedentary_flag(); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "set_sedentary_data:%d:%d~%d:%d", sedentary_start_hour, sedentary_start_min, sedentary_stop_hour, sedentary_stop_min); } - Request request = { - .msgId = topic, - .len = size, - .msgValue = 0, - .data = publishData, - }; + void set_drinkreminder_data(void) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "set_drinkreminder_data"); + drinkreminder_switch = OHOS::ConfigModel::GetInstance()->GetDrinkSwitch(); + drinkreminder_freq = OHOS::ConfigModel::GetInstance()->GetDrinkFreq(); + drinkreminder_goal = OHOS::ConfigModel::GetInstance()->GetDrinkGoal(); - /* public request */ - api = SAMGR_GetInstance()->GetFeatureApi(BROADCAST_SERVICE_NAME, BROADCAST_FEATURE_NAME); - if (api == nullptr) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GetFeatureApi failed"); - free(publishData); - return; + // 获取提醒时间段 + drinkreminder_start_time = OHOS::ConfigModel::GetInstance()->GetDrinkStart(); // 获取喝水提醒开始时间,int类型 前16位小时,后16位分钟 + drinkreminder_end_time = OHOS::ConfigModel::GetInstance()->GetDrinkEnd(); // 获取喝水提醒结束时间, int类型 前16位小时,后16位分钟 + + // 解析开始时间 + drinkreminder_start_hour = (drinkreminder_start_time & 0XFFFF0000) >> 16; // 前16位是小时 + drinkreminder_start_min = drinkreminder_start_time & 0X0000FFFF; // 后16位是分钟 + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "%d:%d", drinkreminder_start_hour, drinkreminder_start_min); + + // 解析结束时间 + drinkreminder_end_hour = (drinkreminder_end_time & 0XFFFF0000) >> 16; // 前16位是小时 + drinkreminder_end_min = drinkreminder_end_time & 0x0000FFFF; // 后16位是分钟 + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "%d:%d", drinkreminder_end_hour, drinkreminder_end_min); + + if (drinkreminder_switch == 2) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "%d:%d~%d:%d", drinkreminder_start_hour, drinkreminder_start_min, drinkreminder_end_hour, drinkreminder_end_min); + } } - ret = api->QueryInterface(api, DEFAULT_VERSION, (void **)&broadcastApi); - if (ret != 0 || broadcastApi == nullptr) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "QueryInterface failed"); - free(publishData); + + static bool is_time_range(const struct tm &curTime, int start_time_hour, int start_time_min, int end_time_hour, int end_time_min) + { + int start_min = start_time_hour * 60 + start_time_min; /* 开始时间的分钟数 */ + int end_min = end_time_hour * 60 + end_time_min; /* 结束时间的分钟数 */ + int cur_time_min = curTime.tm_hour * 60 + curTime.tm_min; /* 当前时间的分钟数 */ + + // 处理非跨天的情况 + if (end_min > start_min) + { + if (cur_time_min >= start_min && cur_time_min < end_min) + { + return true; + } + } + else // 处理跨天的情况 + { + if (cur_time_min >= start_min || cur_time_min < end_min) + { + return true; + } + } + return false; + } + + void clean_sleep_monitoring_flag(void) + { + uapi_dev_runtime_set_sleep_monitoring_status(0); + uapi_dev_runtime_set_nap_monitoring_status(0); + } + + void clean_sedentary_flag(void) + { + uapi_dev_runtime_set_sedentary_status(0); + } + + // 设置睡眠提醒时间 + void get_sleep_time_notify(void) + { + int goal_hour = (sleep_time & 0XFFFF0000) >> 16; + int goal_min = (sleep_time & 0X0000FFFF); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "goal_hour:%d goal_min:%d", goal_hour, goal_min); + + sleep_notify_time_min = (goal_min >= SLEPPNOTIFY) ? goal_min - SLEPPNOTIFY : ((goal_min + 60) - SLEPPNOTIFY); // 避免分钟数为负 + sleep_notify_time_hour = goal_hour; + if (goal_min < SLEPPNOTIFY) + { // 如果需要借位 + sleep_notify_time_hour -= 1; // 小时减1 + } + // 确保小时数正确 + sleep_notify_time_hour = (sleep_notify_time_hour < 0) ? 23 : sleep_notify_time_hour; // 处理从0点前20分钟的情况,变为前一天的23点40分 + + sleep_notify_time = (sleep_notify_time_hour << 16) | sleep_notify_time_min; + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "sleep_notify_time_hour:%d sleep_notify_time_min:%d sleep_notify_time:%d", sleep_notify_time_hour, sleep_notify_time_min, sleep_notify_time); + } + void AlarmEventPublish(uint16_t topic, uint8_t *data, uint32_t size) + { + int32 ret; + + BroadcastApi *broadcastApi = NULL; + IUnknown *api = NULL; + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "ChargerEventPublish topic=%u!!", topic); + + void *publishData = nullptr; + if (size > 0) + { + publishData = malloc(size); + if (publishData == nullptr) + { + return; + } + ret = memcpy_s(publishData, size, (const void *)data, size); + if (ret != EOK) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ChargerEventPublish memcpy_s rateDataTmp fail! ret = %d", ret); + free(publishData); + return; + } + } + + Request request = {.msgId = topic, .len = size, .msgValue = 0, .data = publishData}; + + /* public request */ + api = SAMGR_GetInstance()->GetFeatureApi(BROADCAST_SERVICE_NAME, BROADCAST_FEATURE_NAME); + if (api == NULL) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GetFeatureApi failed"); + free(publishData); + return; + } + ret = api->QueryInterface(api, DEFAULT_VERSION, (void **)&broadcastApi); + if (ret != 0 || broadcastApi == NULL) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "QueryInterface failed"); + free(publishData); + return; + } + broadcastApi->PublishTopic((IUnknown *)broadcastApi, &request); + broadcastApi->Release((IUnknown *)broadcastApi); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "ChargerEventPublish end!!"); + return; } - broadcastApi->PublishTopic((IUnknown *)broadcastApi, &request); - broadcastApi->Release((IUnknown *)broadcastApi); - WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "AlarmTimerEventPublish end!!"); + void AlarmTimerEventPublish(uint16 topic, AlarmClockEventData data) + { + int32 ret; + uint32 size = sizeof(AlarmClockEventData); + BroadcastApi *broadcastApi = nullptr; + IUnknown *api = nullptr; - return; -} + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "AlarmTimerEventPublish topic=%u!!", topic); -static void AlarmCallBackProcA(void) -{ - WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "AlarmCallBackProcA"); - AlarmClockEventData unuse; - AlarmTimerEventPublish(TOPIC_EVENT_ALARM_RING, unuse); -} + void *publishData = malloc(size); + if (publishData == nullptr) + { + return; + } + ret = memcpy_s(publishData, size, (const void *)&data, size); + if (ret != EOK) + { + free(publishData); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "AlarmTimerEventPublish memcpy_s fail! ret = %d", ret); + return; + } -static void AlarmCallBackProcB(void) -{ - AlarmClockEventData unuse; - WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "AlarmCallBackProcB"); - AlarmTimerEventPublish(TOPIC_EVENT_NEXTDAY_UPDATE, unuse); - SetZeroAlarm(); -} + Request request = { + .msgId = topic, + .len = size, + .msgValue = 0, + .data = publishData, + }; + + /* public request */ + api = SAMGR_GetInstance()->GetFeatureApi(BROADCAST_SERVICE_NAME, BROADCAST_FEATURE_NAME); + if (api == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GetFeatureApi failed"); + free(publishData); + return; + } + ret = api->QueryInterface(api, DEFAULT_VERSION, (void **)&broadcastApi); + if (ret != 0 || broadcastApi == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "QueryInterface failed"); + free(publishData); + return; + } + broadcastApi->PublishTopic((IUnknown *)broadcastApi, &request); + broadcastApi->Release((IUnknown *)broadcastApi); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "AlarmTimerEventPublish end!!"); -void AlarmScan(void *arg) -{ - struct tm curTime; - int32_t ret = AlarmGetCurrentTimeInfo(&curTime); - if (ret != ERRCODE_SUCC) { return; } + /*闹钟*/ + static void AlarmCallBackProcA(void) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "AlarmCallBackProcA"); + AlarmClockEventData unuse; + AlarmTimerEventPublish(TOPIC_EVENT_ALARM_RING, unuse); + } + + /*NextDay*/ + static void AlarmCallBackProcB(void) + { + AlarmClockEventData unuse; + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "AlarmCallBackProcB"); +#if 0 + // 记录当前时间 + time_t now = time(nullptr); + struct tm *localTime = localtime(&now); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Current time - Hour: %d, Minute: %d", localTime->tm_hour, localTime->tm_min); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "Posting next day update event"); + +#endif + + GraphicService::GetInstance()->PostGraphicEvent(std::bind(AlarmTimerEventPublish, TOPIC_EVENT_NEXTDAY_UPDATE, unuse)); + + // AlarmTimerEventPublish(TOPIC_EVENT_NEXTDAY_UPDATE, unuse); + + // 重置nextday闹钟 + SetZeroAlarm(); + } + + static void on_time_CallBackProc(void) + { + AlarmClockEventData unuse; + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "on_time_CallBackProc invoked"); + AlarmTimerEventPublish(TOPIC_EVENT_ON_TIME, unuse); + // GraphicService::GetInstance()->PostGraphicEvent( + // std::bind(AlarmTimerEventPublish, TOPIC_EVENT_ON_TIME, unuse)); + + // AlarmTimerEventPublish(TOPIC_EVENT_ON_TIME, unuse); + } + + void AlarmScan(void *arg) + { + struct tm curTime; + int32_t ret = AlarmGetCurrentTimeInfo(&curTime); + if (ret != ERRCODE_SUCC) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Failed to get current time info, error code: %d", ret); + return; + } + + if (curTime.tm_sec % 3 == 0) + { + do_custom_cmd_service_check_msg(CUSTOM_CMD_MSG_BLE_ADV_CHECK, nullptr, 0); // 3秒钟检查一次广播 + } + + if (curTime.tm_sec % 60 == 0) + { + #ifdef CYWEE_SPORT + do_cywee_service_check_msg(CYWEE_SERVICE_CMD_CHECK_ACC, NULL); // 一分钟检查一次gsensor是否停止 + #endif + } + + if (curTime.tm_min % 60 == 0 && curTime.tm_sec == 0) + { + do_custom_fileoperate_service_check_msg(CUSTOM_FILEOPERATE_MSG_TYPE_BATTERY_DATA_SAVE, nullptr, 0); // 十分钟存一次电池信息 + } + + if (g_alarmCtrA.state == ALARM_STATUS_RUNNING) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "Checking Alarm A"); + if ((g_alarmCtrA.callback != nullptr) && + (g_alarmCtrA.info.hour == curTime.tm_hour) && + (g_alarmCtrA.info.minute == curTime.tm_min)) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Alarm A triggered"); + OHOS::AlarmClockModel::GetInstance()->SetPopTimeData(g_alarmCtrA.info.hour, g_alarmCtrA.info.minute); + g_alarmCtrA.state = ALARM_STATUS_CREATED; + g_alarmCtrA.callback(); + } + } + + if (g_alarmCtrB.state == ALARM_STATUS_RUNNING) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "Checking Alarm B"); + if ((g_alarmCtrB.callback != NULL) && + // (g_alarmCtrB.info.week == curTime.tm_wday) && + (g_alarmCtrB.info.hour == curTime.tm_hour) && + (g_alarmCtrB.info.minute == curTime.tm_min) && + (g_alarmCtrB.info.second == curTime.tm_sec)) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Alarm B triggered"); + g_alarmCtrB.state = ALARM_STATUS_CREATED; + g_alarmCtrB.callback(); + } + } + + // 业务逻辑回调 + do_custom_cmd_service_check_msg(CUSTOM_CMD_MSG_TIMECALL_BACK, nullptr, 0); + } - if (g_alarmCtrA.state == ALARM_STATUS_RUNNING) { - if ((g_alarmCtrA.callback != nullptr) && - (g_alarmCtrA.info.hour == curTime.tm_hour) && - (g_alarmCtrA.info.minute == curTime.tm_min)) { - g_alarmCtrA.callback(); - g_alarmCtrA.state = ALARM_STATUS_CREATED; + // 每秒回调 + void custom_timer_callback() + { + struct tm curTime; + int32_t ret = AlarmGetCurrentTimeInfo(&curTime); + if (ret != ERRCODE_SUCC) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Failed to get current time info, error code: %d", ret); + return; } + + // 绑定判断 + if (HandleIsBind()) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HandleAlarmOnTime: not binded"); + return; + } + + HandleAlarmOnTime(&curTime); + HandleSleepReminder(&curTime); + HandleMusicUpdate(); + + // 以下弹窗被控制 + if (HandleCanShowDialog()) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HandleAlarmOnTime: not show dialog"); + return; + } + + HandleDrinkReminder(&curTime); + HandleHeartRateDetection(&curTime); } - if (g_alarmCtrB.state == ALARM_STATUS_RUNNING) { - if ((g_alarmCtrB.callback != nullptr) && - (g_alarmCtrB.info.week == curTime.tm_wday) && - (g_alarmCtrB.info.hour == curTime.tm_hour) && - (g_alarmCtrB.info.minute == curTime.tm_min)) { - g_alarmCtrB.callback(); - g_alarmCtrB.state = ALARM_STATUS_CREATED; + // 判断是否绑定 + bool HandleIsBind(void) + { + // 未绑定状态下,以下操作不进行 + if (OHOS::ConfigModel::GetInstance()->get_configData_bool( + OHOS::ConfigModel::CONFIGMODEL_ITEM_FIRSTTIMESTART)) + { + return true; } + return false; } -} -static int32_t AlarmCreate(AlarmCtrl *alarmCtrl, AlarmCallBack callback) -{ - if (alarmCtrl == nullptr) { - return ERRCODE_FAIL; + // 判断是否可以弹窗 + bool HandleCanShowDialog(void) + { + bool state = false; + + if (uapi_dev_runtime_get_saveele_status()) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "saveele!"); + state = true; + } + + if (uapi_dev_runtime_get_train_status()) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "training!"); + state = true; + } + + return state; } - if (alarmCtrl->state == ALARM_STATUS_UNUSED) { - alarmCtrl->state = ALARM_STATUS_CREATED; - alarmCtrl->callback = callback; + + // 整点回调 + void HandleAlarmOnTime(const struct tm *curTime) + { + if (curTime->tm_min == 0 && curTime->tm_sec == 0) + { + AlarmClockEventData unuse; + time_t timetemp = mktime((struct tm *)curTime); + unuse.value = timetemp - 60 * 60; + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "on_time_CallBackProc invoked"); + GraphicService::GetInstance()->PostGraphicEvent( + std::bind(AlarmTimerEventPublish, TOPIC_EVENT_ON_TIME, unuse)); + } } - return ERRCODE_SUCC; -} -int32_t AlarmTimerInit(void) -{ - int32_t ret; + // 睡眠提醒 + void HandleSleepReminder(const struct tm *curTime) + { + // 睡眠总开关 + if (OHOS::ConfigModel::GetInstance()->get_configData_int(OHOS::ConfigModel::CONFIGMODEL_ITEM_SLEEP)) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "CONFIGMODEL_ITEM_SLEEP is OK"); + // 睡眠提醒[前提开启睡眠提醒] + if (OHOS::ConfigModel::GetInstance()->get_configData_int(OHOS::ConfigModel::CONFIGMODEL_ITEM_SLEEP_REMIND)) + { + // 提醒一次 + if ((curTime->tm_hour == sleep_notify_time_hour) && (curTime->tm_min == sleep_notify_time_min) && (curTime->tm_sec == 0)) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "It's bedtime in 20 minutes"); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "20分钟后要睡觉啦!"); + // 设置状态为睡眠提醒 + OHOS::SleepModel::GetInstance().set_sleep_state(OHOS::SLEEPSTATE::SLEEPNOTIFY); + AlarmEventPublish(TOPIC_EVENT_SLEEPNOTE, NULL, 0); + } + } + if ((curTime->tm_hour == wake_time_hour && curTime->tm_min == wake_time_min && curTime->tm_sec == 0) || + (curTime->tm_hour == sleep_time_hour && curTime->tm_min == sleep_time_min && curTime->tm_sec == 0) && curTime->tm_min) + { + uapi_cywee_time_sync(); + } + else if (!time_sync_flag && curTime->tm_min) + { + time_sync_flag = 1; + uapi_cywee_time_sync(); + } + // 退出睡眠检测模式并进入小睡检测模式 + if (!is_time_range(*curTime, sleep_time_hour, sleep_time_min, wake_time_hour, wake_time_min) && (uapi_dev_runtime_get_nap_monitoring_status() == 0)) + { + if (curTime->tm_hour == wake_time_hour && curTime->tm_min == wake_time_min && curTime->tm_sec == 0) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "闹铃!"); + // 退出睡眠模式 + OHOS::SleepModeModel::GetInstance().SetSleepModeDisabled(); + OHOS::SleepModel::GetInstance().set_sleep_state(OHOS::SLEEPSTATE::WAKE); + } - g_alarmCtrA.state = ALARM_STATUS_UNUSED; - g_alarmCtrB.state = ALARM_STATUS_UNUSED; - OHOS::g_AlarmHandle = new OHOS::GraphicTimer(ALARM_INTERVAL_MS, AlarmScan, nullptr, true); - bool timerStatus = OHOS::g_AlarmHandle->Start(); - if (!timerStatus) { - return ERRCODE_FAIL; + // 判断是否还在睡眠 + if (uapi_dev_runtime_get_sleep_status() == 0) + { + // 设置状态为小睡 + uapi_dev_runtime_set_nap_status(0); // 清零小睡状态 + uapi_dev_runtime_set_absolute_static_status(0); // 清零绝对静止状态 - #ifdef PPG_HX3695 ++ #ifdef SUPPORT_PPG_SERVICE + set_keep_in_wear_det_mode(1); // 开启小睡佩戴监测 + #endif + #ifdef CYWEE_SPORT + do_cywee_service_check_msg(CYWEE_SERVICE_CMD_NAP_SEDENTARY_MODE, NULL); // 算法底层切换小睡监测模式 + #endif + time_sync_flag = 0; + } + } + // 进入睡眠检测模式并退出小睡检测模式 + else if (is_time_range(*curTime, sleep_time_hour, sleep_time_min, wake_time_hour, wake_time_min) && (uapi_dev_runtime_get_sleep_monitoring_status() == 0)) + { + int cmd = 1; + uapi_dev_runtime_set_sleep_status(0); // 清零睡眠状态 + uapi_dev_runtime_set_absolute_static_status(0); // 清零绝对静止状态 + // OHOS::clean_sleep_data(); // 清零睡眠文件存储数据 + // if(uapi_dev_runtime_get_nap_monitoring_status() == 1) + // uapi_clean_sleep_flag(); // 清除睡眠标志文件 + // OHOS::create_sleep_folder(); // 创建睡眠文件夹 - #ifdef PPG_HX3695 ++ #ifdef SUPPORT_PPG_SERVICE + set_keep_in_wear_det_mode(0); + #endif + #ifdef CYWEE_SPORT + do_cywee_service_check_msg(CYWEE_SERVICE_CMD_GET_SLEEP_DATA, &cmd); // 强制获取小睡数据,结束小睡 + #endif + + // 睡眠弹窗 + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "要睡觉啦!"); + // 设置状态为睡眠 + OHOS::SleepModel::GetInstance().clean_sleep_data(); // 清除历史数据 + OHOS::SleepModel::GetInstance().set_sleep_state(OHOS::SLEEPSTATE::SLEPP); + + if (curTime->tm_hour == sleep_time_hour && curTime->tm_min == sleep_time_min && curTime->tm_sec == 0) + { + // 进入睡眠模式 + OHOS::SleepModeModel::GetInstance().SetSleepModeEnabled(); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "要睡觉啦!!!! 开始"); + AlarmEventPublish(TOPIC_EVENT_SLEEPNOTE, NULL, 0); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "要睡觉啦!!!! 结束"); + } + + #ifdef CYWEE_SPORT + do_cywee_service_check_msg(CYWEE_SERVICE_CMD_SLEEPING_MODE, NULL); // 算法底层切换睡眠监测模式 + #endif + time_sync_flag = 0; + } + } } - ret = AlarmCreate(&g_alarmCtrA, AlarmCallBackProcA); - if (ret != ERRCODE_SUCC) { - return ERRCODE_FAIL; + + // 喝水提醒 + void HandleDrinkReminder(const struct tm *curTime) + { + if (drinkreminder_switch == 1) + { // 定时提醒 + if (curTime->tm_hour == drinkreminder_start_hour && + curTime->tm_min == drinkreminder_start_min && + curTime->tm_sec == 0) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "该喝水了!!该喝水了!!"); + AlarmEventPublish(TOPIC_EVENT_DRINKREMINDER, NULL, 0); + } + } + else if (drinkreminder_switch == 2) + { // 间隔提醒 + // 判断当前时间是否在提醒时间段内 + if (is_time_range(*curTime, drinkreminder_start_hour, drinkreminder_start_min, drinkreminder_end_hour, drinkreminder_end_min)) + { + double interval_time = (drinkreminder_freq == 0) ? 0.5 : drinkreminder_freq; + int interval_time_seconds = (int)(interval_time * 60) * 60; + int current_seconds = (curTime->tm_hour * 60 + curTime->tm_min) * 60; + int hour_24_seconds = 24 * 60 * 60; + // 进行间隔判断和提醒 + if (uapi_dev_runtime_get_drinkremind_status() == 0) + { + uapi_dev_runtime_set_drinkremind_status(1); + drinkremind_expectedTime = current_seconds + interval_time_seconds; + drinkremind_expectedTime %= hour_24_seconds; // 同时处理24小时循环 + } + else if (current_seconds == drinkremind_expectedTime && curTime->tm_sec == 0) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "该喝水了!!该喝水了!!"); + drinkremind_expectedTime += interval_time_seconds; + drinkremind_expectedTime %= hour_24_seconds; // 处理24小时循环 + AlarmEventPublish(TOPIC_EVENT_DRINKREMINDER, NULL, 0); + } + } + else if (!is_time_range(*curTime, drinkreminder_start_hour, drinkreminder_start_min, drinkreminder_end_hour, drinkreminder_end_min) && uapi_dev_runtime_get_drinkremind_status() == 1) + { + uapi_dev_runtime_set_drinkremind_status(0); + } + } } - ret = AlarmCreate(&g_alarmCtrB, AlarmCallBackProcB); - if (ret != ERRCODE_SUCC) { - return ERRCODE_FAIL; + + // 心率周期检测 + void HandleHeartRateDetection(const struct tm *curTime) + { + int heartRateDetectionInterval = 0; + + if (uapi_dev_runtime_get_sleep_monitoring_status()) + heartRateDetectionInterval = 20; // 晚上 20分钟检测一次 + else + heartRateDetectionInterval = OHOS::ConfigModel::GetInstance()->get_configData_int(OHOS::ConfigModel::CONFIGMODEL_ITEM_HEARTRATE_DETECTED); + + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "Heart rate detection cycle detection is enabled %d", heartRateDetectionInterval); + if (heartRateDetectionInterval) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "Heart rate detection cycle detection is enabled %d", curTime->tm_min % heartRateDetectionInterval); + if (curTime->tm_min % heartRateDetectionInterval == 0 && curTime->tm_sec == 0) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "Automatic heart rate detection starts"); + // 开启心率检测 + OHOS::HeartModel::GetInstance()->Heart_Control(OHOS::HeartState::Start, OHOS::HeartCheck::PASSIVITY); + } + } } - return ERRCODE_SUCC; -} -int32_t SetAlarm(AlarmType type, uint8_t week, uint8_t hour, uint8_t minute) -{ - WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "SetAlarm %d %d %d %d", type, week, hour, minute); - if (type == ALARM_A) { - g_alarmCtrA.state = ALARM_STATUS_RUNNING; - g_alarmCtrA.info.hour = hour; - g_alarmCtrA.info.minute = minute; - } else if (type == ALARM_B) { - g_alarmCtrB.state = ALARM_STATUS_RUNNING; - g_alarmCtrB.info.week = week; - g_alarmCtrB.info.hour = hour; - g_alarmCtrB.info.minute = minute; - } else { - return ERRCODE_FAIL; - } - return ERRCODE_SUCC; -} + // 音乐更新 + void HandleMusicUpdate() + { + int16_t curviewid = OHOS::NativeAbility::GetInstance().GetCurSliceId(); + if (curviewid != VIEW_MAIN && OHOS::PlayersView::GetInstance()) + { // 当前不在主界面且音乐界面不为空 + OHOS::UICheckBox::UICheckBoxState state = OHOS::PlayersView::GetInstance()->GetPlayerButtonState(); + if (state == OHOS::UICheckBox::UICheckBoxState::SELECTED) + { + SendMsgToUIService(UI_UPDATE_PLAYERPROCESS, 0, nullptr, 0); // 音乐进度条更新 + } + } + else if (OHOS::RecordingPlayerView::GetInstance()) + { + OHOS::UICheckBox::UICheckBoxState state = OHOS::RecordingPlayerView::GetInstance()->GetPlayerButtonState(); + if (state == OHOS::UICheckBox::UICheckBoxState::SELECTED) + { + SendMsgToUIService(UI_UPDATE_RECORDPROCESS, 0, nullptr, 0); // 录音进度条更新 + } + } + } -int32_t SetZeroAlarm(void) -{ - struct tm curTime; - int32_t ret = AlarmGetCurrentTimeInfo(&curTime); - if (ret != ERRCODE_SUCC) { - return ERRCODE_FAIL; + static int32_t AlarmCreate(AlarmCtrl *alarmCtrl, AlarmCallBack callback) + { + if (alarmCtrl == nullptr) + { + return ERRCODE_FAIL; + } + if (alarmCtrl->state == ALARM_STATUS_UNUSED) + { + alarmCtrl->state = ALARM_STATUS_CREATED; + alarmCtrl->callback = callback; + } + return ERRCODE_SUCC; } - int32_t weekday = (++curTime.tm_wday) % 7; - return SetAlarm(ALARM_B, weekday, 0, 0); -} -int32_t AlarmGetCurrentTimeInfo(struct tm *timeInfo) -{ - if (timeInfo == nullptr) { - return ERRCODE_FAIL; + int32_t AlarmTimerInit(void) + { + int32_t timerStatus; + int32_t ret; + + set_sleep_and_wake_time(); + set_sedentary_data(); + set_drinkreminder_data(); + get_sleep_time_notify(); + + g_alarmCtrA.state = ALARM_STATUS_UNUSED; + g_alarmCtrB.state = ALARM_STATUS_UNUSED; + g_AlarmHandle = osTimerNew(AlarmScan, osTimerPeriodic, nullptr, nullptr); + if (g_AlarmHandle == nullptr) + { + return ERRCODE_FAIL; + } + timerStatus = osTimerStart(g_AlarmHandle, ALARM_INTERVAL_MS); + if (timerStatus != osOK) + { + return ERRCODE_FAIL; + } + ret = AlarmCreate(&g_alarmCtrA, AlarmCallBackProcA); + if (ret != ERRCODE_SUCC) + { + return ERRCODE_FAIL; + } + ret = AlarmCreate(&g_alarmCtrB, AlarmCallBackProcB); + if (ret != ERRCODE_SUCC) + { + return ERRCODE_FAIL; + } + + return ERRCODE_SUCC; + } + + int32_t SetAlarm(AlarmType type, uint8_t week, uint8_t hour, uint8_t minute) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "SetAlarm %d %d %d %d", type, week, hour, minute); + if (type == ALARM_A) + { + g_alarmCtrA.state = ALARM_STATUS_RUNNING; + g_alarmCtrA.info.hour = hour; + g_alarmCtrA.info.minute = minute; + } + else if (type == ALARM_B) + { + g_alarmCtrB.state = ALARM_STATUS_RUNNING; + g_alarmCtrB.info.week = week; + g_alarmCtrB.info.hour = hour; + g_alarmCtrB.info.minute = minute; + g_alarmCtrB.info.second = 5; + } + else + { + return ERRCODE_FAIL; + } + return ERRCODE_SUCC; + } + + int32_t SetZeroAlarm(void) + { + struct tm curTime; + int32_t ret = AlarmGetCurrentTimeInfo(&curTime); + if (ret != ERRCODE_SUCC) + { + return ERRCODE_FAIL; + } + int32_t weekday = (++curTime.tm_wday) % 7; + return SetAlarm(ALARM_B, weekday, 0, 0); + } + + int32_t AlarmGetCurrentTimeInfo(struct tm *timeInfo) + { + if (timeInfo == nullptr) + { + return ERRCODE_FAIL; + } + time_t sec = time(nullptr); + localtime_r(&sec, timeInfo); + return ERRCODE_SUCC; } - time_t sec = time(nullptr); - localtime_r(&sec, timeInfo); - return ERRCODE_SUCC; -} #ifdef __cplusplus } diff --cc code/sdk/application/wearable/fd230/nativeapp/nativeui/compass/src/CompassModel.cpp index ee4c99b5a,182e04a0e..9d346eda5 --- a/code/sdk/application/wearable/fd230/nativeapp/nativeui/compass/src/CompassModel.cpp +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/compass/src/CompassModel.cpp @@@ -6,9 -14,14 +14,15 @@@ */ #include -#include "CompassModel.h" +#include "compass/include/CompassModel.h" #include + #ifdef SUPORT_MAG_SERVICE -#include "mag_hal.h" -#include "mag_service.h" ++#include "mag/hal/mag_hal.h" ++#include "mag/service/mag_service.h" ++#include "mag/mmc5603/mmc5603_hal.h" + #endif + #ifdef __cplusplus extern "C" { #endif @@@ -38,41 -44,24 +49,41 @@@ void CompassModel::SetCalibrationStatus calibrationStatus = status; } +/* + * @brief 获取校准状态 + * @param void + * @return 如果校准精度小于3,返回1,否则返回0 +*/ uint8_t CompassModel::GetCalibrationStatus(void) { - #ifdef MAG_MMC5603 -#ifdef SUPORT_MAG_SERVICE - if(mag_get_iAccuracy() < 3) ++ #ifdef SUPORT_MAG_SERVICE + if( mag_service_get_iAccuracy() < 3) return 1; else return 0; -#endif + #else return 0; + #endif } +/* + * @brief 设置显示的角度,通常表示为从地磁北方向到设备当前朝向的角度。 +*/ void CompassModel::SetDisplayAngle(uint16_t angle) { - #ifdef MAG_MMC5603 -#ifdef SUPORT_MAG_SERVICE - displayAngle = (int16_t)mag_get_fAzimuth(); -#endif ++ #ifdef SUPORT_MAG_SERVICE + displayAngle = (int16_t)mag_service_get_fAzimuth(); + #else + displayAngle += angle; + if (displayAngle > 359) { + displayAngle = 0; + } + #endif } +/* + * @brief 获取显示角度 +*/ uint16_t CompassModel::GetDisplayAngle(void) { return displayAngle; @@@ -95,29 -84,19 +106,29 @@@ time_t CompassModel::GetCurrentTime(voi return tv.tv_sec; } +/* + * @brief 打开指南针传感器 + * @param void + * @return 如果指南针传感器打开成功则返回true,否则返回false +*/ bool CompassModel::OpenCompassSensor(void) { - #ifdef MAG_MMC5603 -#ifdef SUPORT_MAG_SERVICE - mag_start(); -#endif ++ #ifdef SUPORT_MAG_SERVICE + do_mag_service_check_msg(MAG_SERVICE_CMD_START_CHECK); + #endif return true; } +/* + * @brief 关闭指南针传感器 + * @param void + * @return 如果指南针传感器关闭成功则返回true,否则返回false +*/ bool CompassModel::CloseCompassSensor(void) { - #ifdef MAG_MMC5603 -#ifdef SUPORT_MAG_SERVICE - mag_stop(); -#endif ++ #ifdef SUPORT_MAG_SERVICE + do_mag_service_check_msg(MAG_SERVICE_CMD_STOP_CHECK); + #endif return true; } }