From: luozheng <1732036298@qq.com> Date: Thu, 24 Jul 2025 07:37:43 +0000 (+0800) Subject: fd230文件夹下service文件夹合并提交 X-Git-Tag: leiniao_debug_1.0.0_20250922_020716~215 X-Git-Url: http://git.snicker.com.cn/css/static/gitweb.css?a=commitdiff_plain;h=022c7b6ae864cff2ae396aee5c556d91cf823992;p=mirrors%2FFD230.git fd230文件夹下service文件夹合并提交 --- diff --git a/code/sdk/application/wearable/fd230/service/CMakeLists.txt b/code/sdk/application/wearable/fd230/service/CMakeLists.txt index 7b1691bee..1137e9b93 100644 --- a/code/sdk/application/wearable/fd230/service/CMakeLists.txt +++ b/code/sdk/application/wearable/fd230/service/CMakeLists.txt @@ -8,6 +8,8 @@ add_subdirectory_if_exist(xiaodu_navi) add_subdirectory_if_exist(xiaodu_voice) add_subdirectory_if_exist(xiaodu_navi_vector) add_subdirectory_if_exist(hc_demo_msg) +add_subdirectory_if_exist(device_msg) +add_subdirectory_if_exist(remote_msg) add_subdirectory_if_exist(auto_ota_msg) add_subdirectory_if_exist(alipay_msg) add_subdirectory_if_exist(app_store) diff --git a/code/sdk/application/wearable/fd230/service/app_store/CMakeLists.txt b/code/sdk/application/wearable/fd230/service/app_store/CMakeLists.txt index e679c5341..5cfeb9a55 100644 --- a/code/sdk/application/wearable/fd230/service/app_store/CMakeLists.txt +++ b/code/sdk/application/wearable/fd230/service/app_store/CMakeLists.txt @@ -8,7 +8,6 @@ set(PRIVATE_HEADER ${ROOT_DIR}/middleware/services/gui/uikit/utils/interfaces/innerkits ${ROOT_DIR}/middleware/services/gui/uikit/utils/interfaces/kits ${ROOT_DIR}/middleware/services/gui/uikit/utils/interfaces/kits/gfx_utils - ${ROOT_DIR}/application/wearable/nativeapp/nativeui/uiservice/include ) set(SOURCES diff --git a/code/sdk/application/wearable/fd230/service/app_store/app_store.cpp b/code/sdk/application/wearable/fd230/service/app_store/app_store.cpp index ff050dcae..c7cef194c 100644 --- a/code/sdk/application/wearable/fd230/service/app_store/app_store.cpp +++ b/code/sdk/application/wearable/fd230/service/app_store/app_store.cpp @@ -113,7 +113,13 @@ errcode_t AppStoreGetPkgList(uint8_t cmd_id, uint8_t type, void *usr_data, uint1 for (int32_t i = 0; i < count; i++) { (void)strncpy_s((char*)unitInfo[i].pkgName, PKG_NAME_MAX_LENGTH, bundleInfos[i].bundleName, strlen(bundleInfos[i].bundleName)); - WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "AppStoreGetPkgList pkgName[%d] = %s", i, unitInfo[i].pkgName); + (void)strncpy_s((char*)unitInfo[i].versionName, VERSION_NAME_MAX_LENGTH, + bundleInfos[i].versionName, strlen(bundleInfos[i].versionName)); + (void)strncpy_s((char*)unitInfo[i].labelName, LABEL_NAME_MAX_LENGTH, + bundleInfos[i].label, strlen(bundleInfos[i].label)); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "AppStoreGetPkgList pkgName[%d] = %s, versionName[%d] = %s,\ + labeName[%d] = %s", i, unitInfo[i].pkgName, i, unitInfo[i].versionName, i, + unitInfo[i].labelName); unitInfo[i].versionCode = bundleInfos[i].versionCode; } ret = msg_center_send_data(MSGCENTER_CMD_APP_STORE, type, infoList, len); @@ -128,6 +134,43 @@ errcode_t AppStoreGetPkgList(uint8_t cmd_id, uint8_t type, void *usr_data, uint1 } return ret; } + +errcode_t AppStoreGetBundleInfo(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + BundleInfo bundleInfo; + int32_t ret = ERRCODE_FAIL; + + uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data); + uint16_t payload_len = usr_len - tl_len; + uint8_t *tlv_payload = (uint8_t *)msg_center_get_tlv_payload(usr_data); + char *bundleName = (char *)malloc(payload_len + 1); + (void)memcpy_s(bundleName, payload_len, tlv_payload, payload_len); + bundleName[payload_len] = '\0'; + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "bundleName = %s", bundleName); + + uint8_t bundleRet = OHOS::BundleMsClient::GetInstance().GetBundleInfo(bundleName, 0, &bundleInfo); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "get bundleInfo, ret = %d", bundleRet); + + int32_t len = sizeof(PkgUnitInfo); + PkgUnitInfo *info = (PkgUnitInfo *)malloc(len); + if (info != nullptr) { + memset_s(info, len, 0, len); + (void)strncpy_s((char*)info->pkgName, PKG_NAME_MAX_LENGTH, bundleInfo.bundleName, + strlen(bundleInfo.bundleName)); + (void)strncpy_s((char*)info->versionName, VERSION_NAME_MAX_LENGTH, bundleInfo.versionName, + strlen(bundleInfo.versionName)); + (void)strncpy_s((char*)info->labelName, LABEL_NAME_MAX_LENGTH, bundleInfo.label, strlen(bundleInfo.label)); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "AppStoreGetBundleInfo pkgName = %s, versionName = %s, labeName = %s", + info->pkgName, info->versionName, info->labelName); + info->versionCode = bundleInfo.versionCode; + ret = msg_center_send_data(cmd_id, type, info, len); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_MSG_CENTER, "AppStoreGetBundleInfo send data ret = 0x%x", ret); + free(info); + free(bundleName); + } + + return ret; +} /////////////////////////////////////////////////////////////////////////////////// diff --git a/code/sdk/application/wearable/fd230/service/app_store/app_store.h b/code/sdk/application/wearable/fd230/service/app_store/app_store.h index 47064738d..811695b97 100644 --- a/code/sdk/application/wearable/fd230/service/app_store/app_store.h +++ b/code/sdk/application/wearable/fd230/service/app_store/app_store.h @@ -18,6 +18,8 @@ extern "C" { #endif #define PKG_NAME_MAX_LENGTH 128 +#define VERSION_NAME_MAX_LENGTH 128 +#define LABEL_NAME_MAX_LENGTH 256 #define FS_DIR_APP_STORE "/user/app_store/" typedef enum { @@ -29,6 +31,7 @@ typedef enum { APP_STORE_OPERATION = 0x01, APP_STORE_NOTIFY_PROGRESS = 0x02, APP_STORE_GET_PKG_LIST = 0x03, + APP_STORE_GET_BUNDLEINFO = 0x04, } AppStoreType; typedef enum { @@ -60,10 +63,13 @@ typedef struct { typedef struct { uint8_t pkgName[PKG_NAME_MAX_LENGTH]; int32_t versionCode; + uint8_t versionName[VERSION_NAME_MAX_LENGTH]; + uint8_t labelName[LABEL_NAME_MAX_LENGTH]; } PkgUnitInfo; errcode_t AppStorePkgOperation(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len); errcode_t AppStoreGetPkgList(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len); +errcode_t AppStoreGetBundleInfo(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len); #ifdef BLE_INSTRUCT void ble_app_store_init(void); diff --git a/code/sdk/application/wearable/fd230/service/app_store/app_store_msg.cpp b/code/sdk/application/wearable/fd230/service/app_store/app_store_msg.cpp index f34d838d8..d2f1f1a08 100644 --- a/code/sdk/application/wearable/fd230/service/app_store/app_store_msg.cpp +++ b/code/sdk/application/wearable/fd230/service/app_store/app_store_msg.cpp @@ -10,6 +10,7 @@ extern "C" { static const msg_center_cmd_map_t g_appStoreTbl[] = { { MSGCENTER_CMD_APP_STORE, APP_STORE_OPERATION, AppStorePkgOperation }, { MSGCENTER_CMD_APP_STORE, APP_STORE_GET_PKG_LIST, AppStoreGetPkgList }, + { MSGCENTER_CMD_APP_STORE, APP_STORE_GET_BUNDLEINFO, AppStoreGetBundleInfo }, }; errcode_t AppStoreTypeDispatch(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) diff --git a/code/sdk/application/wearable/fd230/service/broadcast/include/broadcast_feature.h b/code/sdk/application/wearable/fd230/service/broadcast/include/broadcast_feature.h index 80216b20c..92b12f95b 100644 --- a/code/sdk/application/wearable/fd230/service/broadcast/include/broadcast_feature.h +++ b/code/sdk/application/wearable/fd230/service/broadcast/include/broadcast_feature.h @@ -47,6 +47,9 @@ typedef enum { TOPIC_EVENT_HFP_FINISHED, TOPIC_EVENT_HFP_PHONE_TO_WATCH, TOPIC_EVENT_HFP_WATCH_TO_PHONE, + TOPIC_EVENT_BLOODOXYGEN_UPDATA, + TOPIC_EVENT_SPORT_DISTANCE, + TOPIC_EVENT_LOCATION, TOPIC_EVENT_HFP_HINT, // #ifdef SUPPORT_CYWEE_SERVICE TOPIC_EVENT_ACTIVITY_UPDATE, diff --git a/code/sdk/application/wearable/fd230/service/broadcast/src/broadcast_implement.c b/code/sdk/application/wearable/fd230/service/broadcast/src/broadcast_implement.c index 47e293e05..d38325c3c 100644 --- a/code/sdk/application/wearable/fd230/service/broadcast/src/broadcast_implement.c +++ b/code/sdk/application/wearable/fd230/service/broadcast/src/broadcast_implement.c @@ -32,6 +32,9 @@ static const TopicToCore topicToCoreArray[] = { {TOPIC_EVENT_HFP_FINISHED, A_CORE_MASK, 1}, {TOPIC_EVENT_HFP_PHONE_TO_WATCH, A_CORE_MASK, 1}, {TOPIC_EVENT_HFP_WATCH_TO_PHONE, A_CORE_MASK, 1}, + {TOPIC_EVENT_BLOODOXYGEN_UPDATA, A_CORE_MASK, 1}, + {TOPIC_EVENT_SPORT_DISTANCE, A_CORE_MASK, 1}, + {TOPIC_EVENT_LOCATION, A_CORE_MASK, 1}, {TOPIC_EVENT_DEVICE_BIND, A_CORE_MASK, 1}, {TOPIC_EVENT_BLE_TRANSMIT, A_CORE_MASK, 1}, {TOPIC_EVENT_CHARGE_PLUG, A_CORE_MASK, 1}, diff --git a/code/sdk/application/wearable/fd230/service/device_msg/CMakeLists.txt b/code/sdk/application/wearable/fd230/service/device_msg/CMakeLists.txt new file mode 100644 index 000000000..9ea557d33 --- /dev/null +++ b/code/sdk/application/wearable/fd230/service/device_msg/CMakeLists.txt @@ -0,0 +1,51 @@ +set(COMPONENT_NAME "device_msg") + +set(PUBLIC_HEADER +) + +set(PRIVATE_HEADER + ${ROOT_DIR}/middleware/services/gui/uikit/utils/interfaces/innerkits + ${ROOT_DIR}/middleware/services/gui/uikit/utils/interfaces/kits + ${ROOT_DIR}/middleware/services/gui/uikit/proprietary/include + ${ROOT_DIR}/middleware/services/gui/uikit/proprietary/src/ui/innerkits + ${ROOT_DIR}/middleware/services/gui/uikit/ui/interfaces/innerkits + ${ROOT_DIR}/middleware/services/media/foundation/audiomanager/interfaces/kits/audiomanager + ${ROOT_DIR}/middleware/services/gui/uikit/ui/frameworks + ${ROOT_DIR}/middleware/services/gui/uikit/surface/interfaces/kits + ${ROOT_DIR}/middleware/chips/brandy/nv/include + ${ROOT_DIR}/middleware/chips/brandy/nv/nv_config + ${ROOT_DIR}/open_source/openharmony/drivers/peripheral/display/interfaces/include + ${ROOT_DIR}/open_source/openharmony/base/sensors/location/interfaces/kits/include + ${ROOT_DIR}/middleware/utils/dfx/diag/ +) + +set(SOURCES + ${CMAKE_CURRENT_SOURCE_DIR}/device_msg.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/device_proxy.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/msg_center_device.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/device_location.cpp +) + +set(COMPONENT_PUBLIC_CCFLAGS +) + +set(COMPONENT_CCFLAGS + -std=c++11 + -Wno-missing-field-initializers +) + +set(WHOLE_LINK + true +) + +set(PUBLIC_DEFINES +) + +set(PRIVATE_DEFINES + APP_PLATFORM_WATCHGT + CONFIG_ACELITE_ENABLE +) + +build_component() + + diff --git a/code/sdk/application/wearable/fd230/service/device_msg/device_location.cpp b/code/sdk/application/wearable/fd230/service/device_msg/device_location.cpp new file mode 100644 index 000000000..d24a14f75 --- /dev/null +++ b/code/sdk/application/wearable/fd230/service/device_msg/device_location.cpp @@ -0,0 +1,174 @@ +/* + * Copyright (c) Huawei Technologies Co., Ltd. 2025-2025. All rights reserved. + */ +#include "device_location.h" +#include "wearable_log.h" +#include "locator.h" + +using namespace OHOS::Location; + +LocationInfo_t g_locationInfo = {0}; + +class GnssStatusCallback : public IGnssStatusCallback { +public: + GnssStatusCallback() {} + ~GnssStatusCallback() {} + + void OnStatusChange(const std::shared_ptr &statusInfo) override + { + WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "OnStatusChange, num:%d\n", statusInfo->GetSatellitesNumber()); + for (int32_t satIdx = 0; satIdx < statusInfo->GetSatellitesNumber(); satIdx++) { + WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "sat index:%d svid:%d ele:%.3f az:%.3f cnr:%.3f \n", satIdx, + statusInfo->GetSatelliteIds()[satIdx], statusInfo->GetAltitudes()[satIdx], + statusInfo->GetAzimuths()[satIdx], statusInfo->GetCarrierToNoiseDensitys()[satIdx]); + } + } + +private: +}; + +class NmeaMessageCallback : public INmeaMessageCallback { +public: + NmeaMessageCallback() {} + ~NmeaMessageCallback() {} + + void OnMessageChange(int64_t timestamp, const std::string msg) override + { + WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "OnMessageChange timestamp :%lld msg:%s\n", timestamp, msg.c_str()); + } + +private: +}; + +class LocatorCallback : public ILocatorCallback { +public: + LocatorCallback() {} + + ~LocatorCallback() {} + + void OnLocationReport(const std::shared_ptr &location) override + { + WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "OnLocationReport Lat:%.3f Long:%.3f Alt:%.3f Speed:%.3f dir:%.3f\n", + location->GetLatitude(), location->GetLongitude(), location->GetAltitude(), location->GetSpeed(), + location->GetDirection()); + } + + void OnErrorReport(const int errorCode) override + { + WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "error code:%d\n", errorCode); + } + + void OnLocatingStatusChange(const int status) override + { + WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "OnLocatingStatusChange status:%d\n", status); + } + +private: +}; + +typedef struct { + Locator *locator; + bool isStarted; + LocatorCallback locatorCallback; + GnssStatusCallback gnssStatusCallback; + NmeaMessageCallback nmeaMessageCallback; +} LocationSampleContext; + +static LocationSampleContext g_locationContext = { + .locator = nullptr, + .isStarted = false, +}; + +int32_t deviceLocationStartLocating() +{ + WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "LocationStartLocating\n"); + if (g_locationContext.locator == nullptr) { + g_locationContext.locator = &Locator::GetInstance(); + } + if (g_locationContext.locator == nullptr) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "locator is nullptr\n"); + return ERRCODE_FAILURE; + } + + bool isEnabled = false; + LocationErrCode errCode = g_locationContext.locator->IsLocationEnabled(isEnabled); + if (errCode != ERRCODE_SUCCESS) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "locator IsLocationEnabled failed:%d\n", errCode); + return errCode; + } + + if (!isEnabled) { + errCode = g_locationContext.locator->EnableAbility(true); + if (errCode != ERRCODE_SUCCESS) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "locator EnableAbility failed:%d\n", errCode); + return errCode; + } + } + WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "RegisterGnssStatusCallback\n"); + errCode = g_locationContext.locator->RegisterGnssStatusCallback(&g_locationContext.gnssStatusCallback); + if (errCode != ERRCODE_SUCCESS) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "locator RegisterGnssStatusCallback failed:%d\n", errCode); + return errCode; + } + WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "RegisterNmeaMessageCallback\n"); + errCode = g_locationContext.locator->RegisterNmeaMessageCallback(&g_locationContext.nmeaMessageCallback); + if (errCode != ERRCODE_SUCCESS) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "locator RegisterNmeaMessageCallback failed:%d\n", errCode); + return errCode; + } + WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "StartLocating\n"); + RequestConfig requestConfig; + requestConfig.SetPriority(PRIORITY_ACCURACY); + errCode = g_locationContext.locator->StartLocating(&requestConfig, &g_locationContext.locatorCallback); + if (errCode != ERRCODE_SUCCESS) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "locator StartLocating failed:%d\n", errCode); + return errCode; + } + g_locationContext.isStarted = true; + WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "StartLocating end\n"); + return ERRCODE_SUCCESS; +} + +int32_t deviceLocationStopLocating() +{ + if (!g_locationContext.isStarted) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "locator is not started\n"); + return ERRCODE_FAILURE; + } + LocationErrCode errCode = + g_locationContext.locator->UnregisterNmeaMessageCallback(&g_locationContext.nmeaMessageCallback); + if (errCode != ERRCODE_SUCCESS) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "locator UnregisterNmeaMessageCallback failed:%d\n", errCode); + return errCode; + } + errCode = g_locationContext.locator->UnregisterGnssStatusCallback(&g_locationContext.gnssStatusCallback); + if (errCode != ERRCODE_SUCCESS) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "locator RegisterGnssStatusCallback failed:%d\n", errCode); + return errCode; + } + errCode = g_locationContext.locator->StopLocating(&g_locationContext.locatorCallback); + if (errCode != ERRCODE_SUCCESS) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "locator StopLocating failed:%d\n", errCode); + return errCode; + } + g_locationContext.isStarted = false; + + bool isEnabled = false; + errCode = g_locationContext.locator->IsLocationEnabled(isEnabled); + if (errCode != ERRCODE_SUCCESS) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "locator IsLocationEnabled failed:%d\n", errCode); + return errCode; + } + if (!isEnabled) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "locator Is not Enabled\n"); + return ERRCODE_FAILURE; + } + WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "EnableAbility false\n"); + errCode = g_locationContext.locator->EnableAbility(false); + if (errCode != ERRCODE_SUCCESS) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "locator EnableAbility failed:%d\n", errCode); + return errCode; + } + WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "Disable end\n"); + return ERRCODE_SUCCESS; +} \ No newline at end of file diff --git a/code/sdk/application/wearable/fd230/service/device_msg/device_location.h b/code/sdk/application/wearable/fd230/service/device_msg/device_location.h new file mode 100644 index 000000000..3305d698c --- /dev/null +++ b/code/sdk/application/wearable/fd230/service/device_msg/device_location.h @@ -0,0 +1,20 @@ +/* + * Copyright (c) Huawei Technologies Co., Ltd. 2025-2025. All rights reserved. + */ +#ifndef DEVICE_LOCATION_H +#define DEVICE_LOCATION_H +#include + +typedef struct LocationInfo { + int32_t latitude_; + int32_t longitude_; + uint16_t altitude_; + uint16_t accuracy_; + uint16_t speed_; + uint16_t direction_; + int64_t timeStamp_; +} LocationInfo_t; + +int32_t deviceLocationStartLocating(); +int32_t deviceLocationStopLocating(); +#endif \ No newline at end of file diff --git a/code/sdk/application/wearable/fd230/service/device_msg/device_msg.cpp b/code/sdk/application/wearable/fd230/service/device_msg/device_msg.cpp new file mode 100644 index 000000000..3f54b45ab --- /dev/null +++ b/code/sdk/application/wearable/fd230/service/device_msg/device_msg.cpp @@ -0,0 +1,191 @@ +/* + * Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved. + * Description: Breath Ease + * Author: wangle + * Create: 2025-4-23 + */ +#include "msg_center_protocol.h" +#include "msg_center_cmd.h" +#include "ohos_init.h" +#include "msg_center_device.h" +#ifdef PUBLISH_TEST_DATA +#include +#include +#include "graphic_timer.h" +#include "broadcast_feature.h" +#include "ohos_timer.h" +#include "heartrate/HeartModel.h" +#include "device_location.h" +#endif +namespace OHOS { + +#ifdef __cplusplus +extern "C" { +#endif +#ifdef PUBLISH_TEST_DATA +#define BLOODOXYGEN_LOWER 90 +#define BLOODOXYGEN_RANGE 10 +#define STEP_RANGE 5 +#define DISTANCE_RANGE 10 +#define HEARTRATE_LOWER 60 +#define HEARTRATE_RANGE 60 +static uint8_t g_rotation_publish = 0; +static GraphicTimer *g_publishTestDataHandle = nullptr; +enum publishDataType { + PUBLISH_SETP = 0, + PUBLISH_DISTANCE, + PUBLISH_HEARTRATE, + PUBLISH_BLOODOXYGEN, + PUBLISH_TYPE_MAX +}; + +static void PublishTopicTestDataEvent(uint16_t topic, const void *data, size_t len) +{ + int32_t ret; + uint16_t size = len; + BroadcastApi *broadcastApi = nullptr; + IUnknown *api = nullptr; + + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "PublishTopicTestDataEvent topic=%u!!", topic); + + void *publishData = malloc(size); + if (publishData == nullptr) { + return; + } + ret = memcpy_s(publishData, size, data, size); + if (ret != EOK) { + free(publishData); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PublishTopicTestDataEvent memcpy_s fail! ret = %d", ret); + 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 == 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, "PublishTopicTestDataEvent end!!"); + + return; +} + +static void PublishTestDataCallback(void *) +{ + switch (g_rotation_publish++ % PUBLISH_TYPE_MAX) { + case PUBLISH_BLOODOXYGEN: { + uint8_t blood_oxygen = BLOODOXYGEN_LOWER + rand() % BLOODOXYGEN_RANGE; + PublishTopicTestDataEvent(TOPIC_EVENT_BLOODOXYGEN_UPDATA, &blood_oxygen, sizeof(uint8_t)); + break; + } + case PUBLISH_SETP: { + uint32_t step = rand() % STEP_RANGE; + PublishTopicTestDataEvent(TOPIC_EVENT_STEPDATA_UPDATE, &step, sizeof(uint32_t)); + break; + } + case PUBLISH_HEARTRATE: { + HeartDatas heart_data = {0}; + heart_data.perSec = HEARTRATE_LOWER + rand() % HEARTRATE_RANGE; + PublishTopicTestDataEvent(TOPIC_EVENT_HEARTRATE_UPDATA, &heart_data, sizeof(HeartDatas)); + break; + } + case PUBLISH_DISTANCE: { + uint32_t distance = rand() % DISTANCE_RANGE; + PublishTopicTestDataEvent(TOPIC_EVENT_SPORT_DISTANCE, &distance, sizeof(uint32_t)); + break; + } + default: + break; + } +} + +void PublishTestData() +{ + uint32 tick = GetOSTick(5000); // 5秒发布一次测试数据 + if (g_publishTestDataHandle == nullptr) { + g_publishTestDataHandle = new GraphicTimer(tick, PublishTestDataCallback, nullptr, true); + } + if (g_publishTestDataHandle == nullptr) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PublishTestData new GraphicTimer failed!!"); + return; + } + bool retTimer = g_publishTestDataHandle->Start(); + if (!retTimer) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PublishTestData Start failed!!"); + if (g_publishTestDataHandle != nullptr) { + delete g_publishTestDataHandle; + g_publishTestDataHandle = nullptr; + } + return; + } +} +#endif +static const msg_center_cmd_map_t g_msg_center_device_tbl[] = { + {MSGCENTER_CMD_DEVICE, MSGCENTER_TYPE_ID_GET_BATTERY_LEVEL, msg_center_get_battery_level}, + {MSGCENTER_CMD_DEVICE, MSGCENTER_TYPE_ID_GET_STORAGE_INFO, msg_center_get_storage_info}, + {MSGCENTER_CMD_DEVICE, MSGCENTER_TYPE_ID_GET_PRODUCT_INFO, msg_center_get_product_info}, + {MSGCENTER_CMD_DEVICE, MSGCENTER_TYPE_ID_GET_LANGUAGE_ID, msg_center_get_language_id}, + {MSGCENTER_CMD_DEVICE, MSGCENTER_TYPE_ID_GET_VOLUME_INFO, msg_center_get_volume_info}, + {MSGCENTER_CMD_DEVICE, MSGCENTER_TYPE_ID_SET_LANGUAGE_ID, msg_center_set_language_id}, + {MSGCENTER_CMD_DEVICE, MSGCENTER_TYPE_ID_SET_VOLUME_INFO, msg_center_set_volume_info}, + {MSGCENTER_CMD_DEVICE, MSGCENTER_TYPE_ID_DEVICE_HEARTRATE, msg_center_device_heartrate}, + {MSGCENTER_CMD_DEVICE, MSGCENTER_TYPE_ID_DEVICE_STEPDATA, msg_center_device_stepdata}, + {MSGCENTER_CMD_DEVICE, MSGCENTER_TYPE_ID_DEVICE_BLOODOXYGEN, msg_center_device_bloodoxygen}, + {MSGCENTER_CMD_DEVICE, MSGCENTER_TYPE_ID_OFFLINE_LOG_SWITCH, msg_center_offline_log_switch}, + {MSGCENTER_CMD_DEVICE, MSGCENTER_TYPE_ID_LOCATION_GET_INFO, msg_center_location_get_info}, + {MSGCENTER_CMD_DEVICE, MSGCENTER_TYPE_ID_LOCATION_START, msg_center_location_start}, + {MSGCENTER_CMD_DEVICE, MSGCENTER_TYPE_ID_LOCATION_STOP, msg_center_location_stop}, + {MSGCENTER_CMD_DEVICE, MSGCENTER_TYPE_ID_SPORT_ACTION, msg_center_sport_action}, + {MSGCENTER_CMD_DEVICE, MSGCENTER_TYPE_ID_SPORT_GET_DATA, msg_center_sport_get_data}, + {MSGCENTER_CMD_DEVICE, MSGCENTER_TYPE_ID_SPORT_REPORT_DATA, msg_center_sport_report_data}, +#if (CONFIG_ONLINE_LOG == 1) + {MSGCENTER_CMD_DEVICE, MSGCENTER_TYPE_ID_SET_ONLINELOG_CHANNEL, msg_center_set_online_log_channel}, + {MSGCENTER_CMD_DEVICE, MSGCENTER_TYPE_ID_SET_ONLINELOG_LEVEL, msg_center_set_online_log_level}, +#endif + {MSGCENTER_CMD_DEVICE, MSGCENTER_TYPE_ID_OTA_INIT, msg_center_ota_init}, + {MSGCENTER_CMD_DEVICE, MSGCENTER_TYPE_ID_OTA_UPDATE, msg_center_ota_update}, + {MSGCENTER_CMD_DEVICE, MSGCENTER_TYPE_ID_OFF_FIND_PHONE, msg_center_device_findphone}, + {MSGCENTER_CMD_DEVICE, MSGCENTER_TYPE_ID_CAMERA_WATCH_EXIT, msg_center_camera_exit}, + {MSGCENTER_CMD_DEVICE, MSGCENTER_TYPE_ID_CAMERA_CONNECT_PHONE_SUCCESS, msg_center_camera_online}, +}; + +errcode_t msg_center_device_type_dispatch(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + uint8_t tbl_size = sizeof(g_msg_center_device_tbl) / sizeof(g_msg_center_device_tbl[0]); + uint8_t i; + for (i = 0; i < tbl_size; i++) { + msg_center_cmd_map_t *item = (msg_center_cmd_map_t *)&g_msg_center_device_tbl[i]; + if ((item->type == type) && (item->handler != NULL)) { + item->handler(cmd_id, type, usr_data, usr_len); + return ERRCODE_SUCC; + } + } + return ERRCODE_NOT_SUPPORT; +} + +void device_init(void) +{ + msg_center_register_cmd(MSGCENTER_CMD_DEVICE, msg_center_device_type_dispatch); +} + +APP_FEATURE_INIT_PRI(device_init, LAYER_INIT_LEVEL_4); +#ifdef __cplusplus +} +#endif +} // namespace OHOS \ No newline at end of file diff --git a/code/sdk/application/wearable/fd230/service/device_msg/device_proxy.cpp b/code/sdk/application/wearable/fd230/service/device_msg/device_proxy.cpp new file mode 100644 index 000000000..336cfd7ed --- /dev/null +++ b/code/sdk/application/wearable/fd230/service/device_msg/device_proxy.cpp @@ -0,0 +1,476 @@ +/* + * Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved. + * Description: Breath Ease + * Author: wangle + * Create: 2025-4-23 + */ +#include +#include "device_proxy.h" +#include "wearable_log.h" +#include "common_def.h" +#include "cpp/audio_manager.h" +#include "uiservice/ui_service.h" +#include "ui_resource_string.h" +#include +#include +#include "key_id.h" +#include "common.h" +#include "nv.h" +#include "upg.h" +#include "upg_porting.h" + +namespace OHOS { +static constexpr const char *MOUNT_POINT[] = {"/system", "/user", "/update", "/music"}; +static constexpr const uint16_t language_protocol[] = {(uint8_t)(0x0u << 8) | LANGUAGE_ID_ZH, + (uint8_t)(0x1u << 8) | LANGUAGE_ID_ZH, + (uint8_t)(0x2u << 8) | LANGUAGE_ID_EN}; +static constexpr const uint8_t language_mask_bits = 8; +static constexpr const uint16_t language_key_mask = 0xFF00; +static constexpr const uint16_t language_val_mask = 0x00FF; + +static constexpr const uint8_t percentage_scale = 100; // 百分比换算基数 +static constexpr const uint8_t percentage_max = 100; +static constexpr const uint8_t percentage_min = 0; + +static constexpr const uint32_t adc_reference_ratio_numerator = 450U; // 18 * 1000 +static constexpr const uint32_t adc_reference_ratio_denominator = 1024U / 2U; // 40960 / (1000/18)/2U +static constexpr const uint32_t millivolt_per_volt = 1000U; + +static constexpr const uint32_t def_samples_to_keep = 10; +static constexpr const uint32_t def_samples_to_discard = 5; +static constexpr const uint32_t def_adc_max_range_mv = 380; +static constexpr const uint32_t def_adc_min_range_mv = 0; + +template +T clamp(const T &value, const T &min_val, const T &max_val) +{ + return (value < min_val) ? (min_val) : (value > max_val ? max_val : value); +} + +void device_proxy::get_storage_info(storage_info &info) +{ + memset_s(&info, sizeof(storage_info), 0, sizeof(storage_info)); + for (size_t i = 0; i < sizeof(MOUNT_POINT) / sizeof(MOUNT_POINT[0]); i++) { + struct statfs tmpStat = {0}; + if (statfs(MOUNT_POINT[i], &tmpStat) != 0) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "无法获取%s的挂载点信息,%s", MOUNT_POINT[i], strerror(errno)); + continue; + } + + uint32_t total = static_cast(tmpStat.f_blocks * tmpStat.f_bsize); + uint32_t used = static_cast((tmpStat.f_blocks - tmpStat.f_bfree) * tmpStat.f_bsize); + uint32_t free = static_cast(tmpStat.f_bfree * tmpStat.f_bsize); + + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "挂载点%s信息, 总:%d(byte), 用:%d(byte), 剩:%d(byte)", + MOUNT_POINT[i], total, used, free); + info.total_size += total; + info.used_size += used; + info.free_size += free; + } +} +void device_proxy::get_language_id(uint8_t &id) +{ + sys_language_id_t lang_id = {0}; + uint16_t nvsize = 0; + + errcode_t ret = uapi_nv_read(NV_ID_SYS_LANGUAGE_ID, sizeof(sys_language_id_t), &nvsize, (uint8_t *)&lang_id); + if (ret != ERRCODE_SUCC) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "nv get language id error, ret=%u", ret); + return; + } + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "language nvsize=%u id = %u", nvsize, lang_id.language_id); + + for (auto key : language_protocol) { + if (lang_id.language_id == (uint8_t)(key & language_val_mask)) { + id = (uint8_t)((key & language_key_mask) >> language_mask_bits); + return; + } + } + id = LANGUAGE_ID_ZH; +} +void device_proxy::set_language_id(uint8_t id) +{ + sys_language_id_t lang_id = {.language_id = LANGUAGE_ID_ZH}; + + for (auto key : language_protocol) { + if (id == (uint8_t)((key & language_key_mask) >> language_mask_bits)) { + lang_id.language_id = (uint8_t)(key & 0xFF); + } + } + + errcode_t ret = uapi_nv_write(NV_ID_SYS_LANGUAGE_ID, (uint8_t *)&lang_id, sizeof(sys_language_id_t)); + if (ret != ERRCODE_SUCC) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "nv set language id error, ret=%u", ret); + return; + } + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "set language id = %u", lang_id.language_id); + // 发送更新消息到uiservice + SendMsgToUIService(UI_UPDATE_LANGUAGE, 0, nullptr, 0); +} +void device_proxy::get_product_info(std::string &info_string) +{ + sys_product_info_t info = {0}; + uint16_t nvsize = 0; + info_string.clear(); + + errcode_t ret = uapi_nv_read(NV_ID_SYS_PRODUCT_INFO, sizeof(sys_product_info_t), &nvsize, (uint8_t *)&info); + if (ret != ERRCODE_SUCC) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "nv get product info error, ret=%u", ret); + return; + } + + if (nvsize < sizeof(sys_product_info_t) || info.size == 0) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "invalid product info size: nvsize=%u, info.size=%u", nvsize, info.size); + return; + } + + info_string.assign((const char *)info.name, info.size); + + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "product info: nvsize=%u, strlen=%zu, data=%.*s", nvsize, info_string.size(), + static_cast(info_string.size()), info_string.c_str()); +} +void device_proxy::get_volume_info(uint8_t vol_type, std::vector &vol_info) +{ + std::vector audio_types; + + if (vol_type == vol_type_all_idx || vol_type > vol_type_max_idx) { + for (uint8_t i = 0; i < vol_type_max_idx; i++) { + uint8_t max_perc = 0; + trans_type_to_audio_stream_type(i, audio_types); + for (auto types : audio_types) { // 每个类型也由多个音频类型组成, 取声音最大的 + int32_t vol = Audio::AudioManager::GetInstance().GetVolume(types); + int32_t max_vol = Audio::AudioManager::GetInstance().GetMaxVolume(types); + int32_t min_vol = Audio::AudioManager::GetInstance().GetMinVolume(types); + uint8_t perc = calc_vol_percentage(min_vol, max_vol, vol); + max_perc = max_perc > perc ? max_perc : perc; + } + volume_info info; + info.type = i; + info.perc = max_perc; + + vol_info.push_back(info); + } + } else { + uint8_t max_perc = 0; + trans_type_to_audio_stream_type(vol_type, audio_types); + for (auto types : audio_types) { // 每个类型也由多个音频类型组成, 取声音最大的 + int32_t vol = Audio::AudioManager::GetInstance().GetVolume(types); + int32_t max_vol = Audio::AudioManager::GetInstance().GetMaxVolume(types); + int32_t min_vol = Audio::AudioManager::GetInstance().GetMinVolume(types); + uint8_t perc = calc_vol_percentage(min_vol, max_vol, vol); + max_perc = max_perc > perc ? max_perc : perc; + } + volume_info info; + info.type = vol_type; + info.perc = max_perc; + + vol_info.push_back(info); + } +} +void device_proxy::set_volume_info(volume_info &vol_info) +{ + std::vector audio_types; + trans_type_to_audio_stream_type(vol_info.type, audio_types); + for (auto types : audio_types) { + int32_t max_vol = Audio::AudioManager::GetInstance().GetMaxVolume(types); + int32_t min_vol = Audio::AudioManager::GetInstance().GetMinVolume(types); + + int32_t vol = calc_vol_volume(min_vol, max_vol, vol_info.perc); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "SetVolume %08X, %d", types, vol); + Audio::AudioManager::GetInstance().SetVolume(types, vol); + } +} +OTA_ERR device_proxy::ota_init(ota_info &info) +{ + // 检查OTA的当前状态 + upg_status status = uapi_upg_get_status(); + if (status == UPG_STATUS_UPDATING) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "OTAInit:The update module is being upgraded."); + return OTA_ERR::OTA_ERR_STATUS_UPDATING; + } + // 清理并检查升级区空间大小 + delete_file_with_cleanup(upg_get_pkg_file_dir(), upg_get_pkg_file_path()); + uint32_t total_size = uapi_upg_get_storage_size(); + if (total_size == 0) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "OTAInit:OTA check storage size error, total_size is 0"); + return OTA_ERR::OTA_ERR_INVAILD_STORAGE; + } + if (info.package_size >= total_size) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "OTAInit:check size error, total size:%u, need size:%u", total_size, + info.package_size); + return OTA_ERR::OTA_ERR_INSUFFICIENT_STORAGE_SPACE; + } + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "OTAInit:check succ"); + return OTA_ERR::OTA_SUCC; +} +OTA_ERR device_proxy::ota_update(ota_info &info) +{ + uint32_t total_size = 0; + do { + FILE *fp = fopen(upg_get_pkg_file_path(), "rb"); + if (fp == nullptr) { + break; + } + fseek(fp, 0L, SEEK_END); + total_size = ftell(fp); + fclose(fp); + } while (false); + if (total_size == 0) { + return OTA_ERR::OTA_ERR_INVAILD_STORAGE; + } + if (total_size != info.package_size) { + return OTA_ERR::OTA_ERR_PACKAGE_SIZE_ERROR; + } + return OTA_ERR::OTA_SUCC; +} + +void device_proxy::call_ui_ota_update() +{ + // 发送升级请求到uiservice + SendMsgToUIService(UI_OTA_UPDATE, 0, nullptr, 0); +} + +int device_proxy::delete_file_with_cleanup(const char *ppath, const char *path) +{ + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "path:%s, ppath:%s", path, ppath); + // 1. 删除文件 + if (unlink(path) == -1) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "unlink failed:%d", errno); + return 1; + } + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "unlink succ"); + // 2. 打开父目录文件描述符 + int dir_fd = open(ppath, O_RDONLY); + if (dir_fd == -1) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "open parent dir failed:%d", errno); + return 1; + } + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "open parent dir succ"); + // 3. 同步父目录元数据到磁盘 + if (fsync(dir_fd) == -1) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "fsync dir failed:%d", errno); + close(dir_fd); + return 1; + } + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "fsync dir succ"); + close(dir_fd); + return 0; +} + +uint8_t device_proxy::calc_vol_percentage(int32_t min, int32_t max, int32_t curr) +{ + if (min >= max) { + return 0; + } + const int32_t clamped_curr = clamp(curr, min, max); + const int64_t range = static_cast(max) - min; + + const int64_t scaled_value = (static_cast(clamped_curr - min) * percentage_scale); + return static_cast(scaled_value / range); +} +int32_t device_proxy::calc_vol_volume(int32_t min, int32_t max, uint8_t percentage) +{ + if (min >= max) { + return min; + } + uint8_t clamped_percentage = clamp(percentage, percentage_min, percentage_max); + + double range = static_cast(max - min); + double percentage_ratio = static_cast(clamped_percentage) / 100.0; + int32_t curr = static_cast(min + range * percentage_ratio); + + return static_cast(clamp(curr, min, max)); +} +void device_proxy::trans_type_to_audio_stream_type(uint8_t type, std::vector &audio_types) +{ + audio_types.clear(); + switch (type) { + case vol_type_alarm: + audio_types.push_back(AUDIO_STREAM_ALARM); // 通用报警音 + audio_types.push_back(AUDIO_STREAM_ALARM_SYSTEM); // 设备报警 + audio_types.push_back(AUDIO_STREAM_ALARM_CLOCK); // 闹钟报警 + break; + case vol_type_ring: + audio_types.push_back(AUDIO_STREAM_RING); // 来电铃声 + break; + case vol_type_call: + audio_types.push_back(AUDIO_STREAM_VOICE_CALL); // 普通语音通话 + audio_types.push_back(AUDIO_STREAM_VOICE_CALL_VOIP); // 网络语音通话(如微信通话) + audio_types.push_back(AUDIO_STREAM_VOICE_CALL_BT_SCO); // 蓝牙语音通话 + audio_types.push_back(AUDIO_STREAM_VOICE_CALL_VOLTE); // 4G VOLTE 高清语音通话 + break; + case vol_type_assistant: + audio_types.push_back(AUDIO_STREAM_VOICE_ASSISTANT); // 语音助手(如 Siri、Google Assistant) + audio_types.push_back(AUDIO_STREAM_TTS); // 语音合成(如文本转语音) + break; + case vol_type_notification: + audio_types.push_back(AUDIO_STREAM_NOTIFICATION); // 通用提示音 + audio_types.push_back(AUDIO_STREAM_NOTIFICATION_SYSTEM); // 设备提示音(如蓝牙连接/断开、低电量提示) + audio_types.push_back(AUDIO_STREAM_NOTIFICATION_PROMPT); // 运动健康提示音(如运动完成提醒) + break; + case vol_type_music: + audio_types.push_back(AUDIO_STREAM_MUSIC); // 本地音乐播放。 + audio_types.push_back(AUDIO_STREAM_A2DP_MUSIC); // 蓝牙传输的媒体音(如从手机传输到蓝牙耳机的音乐)。 + break; + case vol_type_video: + audio_types.push_back(AUDIO_STREAM_FITNESS_VIDEO); // 健身视频的指导音频。 + break; + } +} + +uint8_t battery_power::get_battery_percentage() +{ + battery_power *inst = get_instance(); + if (inst == nullptr) { + return 0; + } + uint32_t voltage = 0; + // 从adc获取电压值 + if (inst->adc_context_startup()) { + voltage = inst->calc_voltage(); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "calc_voltage:%u", voltage); + } + inst->adc_context_shutdown(); + // 根据电压值计算电量百分比 + return inst->calc_percentage(voltage); +} + +battery_power *battery_power::get_instance() +{ + static battery_power *instance = nullptr; + if (instance == nullptr) { + battery_power *temp = new battery_power(); + if (!temp->adc_context_init()) { + delete temp; + return nullptr; + } + instance = temp; + } + return instance; +} + +battery_power::battery_power() +{ + // 数据由海思提供 + channel = ADC_CHANNEL_3; + analog_pin = S_AGPIO_L27; + mode = PIN_MODE_0; + samples_to_keep = def_samples_to_keep; + samples_to_discard = def_samples_to_discard; + // 由测试检测而来, 测试中得到的数据应该是0.3744V(没有标注单位,猜测得到,未必准确) + // 因为要算百分比, 换算成毫伏更容易计算 + adc_max_range_mv = def_adc_max_range_mv; + adc_min_range_mv = def_adc_min_range_mv; +} + +battery_power::~battery_power() +{ + adc_context_shutdown(); +} + +bool battery_power::adc_context_init() +{ + // 初始化pin模块 + uapi_pin_init(); + // 初始化高精度计数器 + errcode_t err = uapi_tcxo_init(); + if (err != ERRCODE_SUCC) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "uapi_tcxo_init error %u", err); + return false; + } + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "uapi_tcxo_init succ"); + // 设置pin脚模式 + err = uapi_pin_set_mode(analog_pin, mode); + if (err != ERRCODE_SUCC) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "uapi_pin_set_mode error %u", err); + return false; + } + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "uapi_pin_set_mode succ"); + return true; +} + +bool battery_power::adc_context_startup() +{ + errcode_t err = uapi_adc_init(ADC_CLOCK_500KHZ); // 初始化adc + if (err != ERRCODE_SUCC) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "uapi_adc_init error %u", err); + return false; + } + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "uapi_adc_init succ"); + uapi_adc_power_en(AFE_SCAN_MODE_MAX_NUM, true); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "uapi_adc_power_en true"); + err = uapi_adc_open_channel(channel); + if (err != ERRCODE_SUCC) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "uapi_adc_open_channel error %u", err); + return false; + } + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "uapi_adc_open_channel succ"); + return true; +} +void battery_power::adc_context_shutdown() +{ + errcode_t err = uapi_adc_close_channel(channel); + if (err != ERRCODE_SUCC) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "uapi_adc_close_channel error %u", err); + } + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "uapi_adc_close_channel succ"); + uapi_adc_power_en(AFE_SCAN_MODE_MAX_NUM, false); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "uapi_adc_power_en false"); + uapi_adc_deinit(); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "uapi_adc_deinit"); +} + +uint8_t battery_power::calc_percentage(uint32_t voltage) +{ + if (voltage >= adc_max_range_mv) { + return percentage_max; + } + if (voltage <= adc_min_range_mv) { + return percentage_min; + } + + uint32_t voltage_range = adc_max_range_mv - adc_min_range_mv; + uint32_t rounding_term = voltage_range / 2; + uint32_t voltage_offset = voltage - adc_min_range_mv; + return static_cast((voltage_offset * percentage_scale + rounding_term) / voltage_range); +} + +uint32_t battery_power::calc_voltage() +{ + // 丢弃初始帧数据 + for (uint32_t i = 0; i < samples_to_discard; i++) { + uapi_adc_manual_sample(ADC_CHANNEL_NONE); + uapi_tcxo_delay_ms((uint64_t)3); // 延迟3ms + } + + uint32_t stick = 0; + uint32_t stick_count = 0; + // 采集样本数 + for (uint32_t i = 0; i < samples_to_keep; i++) { + uint32_t irq_sts = osal_irq_lock(); + uint32_t sample_result = + (uint32_t)uapi_adc_manual_sample(ADC_CHANNEL_NONE); // 每次读取CHANNEL_NONE? testsuit中是这样写的 + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "sample result = %u", sample_result); + if (sample_result != 0) { + stick += sample_result; + stick_count++; + } + osal_irq_restore(irq_sts); + } + + if (stick_count == 0) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "error, no result"); + return 0; + } + + uint32_t voltage = adc_trans_sytick_to_voltages(stick / stick_count); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "adc trans voltages:%u", voltage); + return voltage; +} + +uint32_t battery_power::adc_trans_sytick_to_voltages(uint32_t sytick) +{ + // 整数运算公式:(sytick * numerator + denominator/2) / denominator + return (sytick * adc_reference_ratio_numerator + adc_reference_ratio_denominator) / adc_reference_ratio_denominator; +} +} // namespace OHOS \ No newline at end of file diff --git a/code/sdk/application/wearable/fd230/service/device_msg/device_proxy.h b/code/sdk/application/wearable/fd230/service/device_msg/device_proxy.h new file mode 100644 index 000000000..7cedf8061 --- /dev/null +++ b/code/sdk/application/wearable/fd230/service/device_msg/device_proxy.h @@ -0,0 +1,104 @@ +/* + * Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved. + * Description: Breath Ease + * Author: wangle + * Create: 2025-4-23 + */ +#ifndef WATCH_SETTING_PROXY_H +#define WATCH_SETTING_PROXY_H + +#include +#include +#include "msg_center_protocol.h" +#include "cpp/audio_manager.h" +#include "adc.h" +#include "tcxo.h" +#include "pinctrl.h" +#include "hal_adc.h" + +namespace OHOS { + +typedef struct storage_info { + uint32_t total_size; // 总大小 + uint32_t used_size; // 已使用 + uint32_t free_size; // 未使用 +} storage_info_t; + +typedef struct volume_info { + uint8_t type; // 类型 + uint8_t perc; // 百分比 +} volume_info_t; + +typedef struct ota_info { + uint32_t package_size; +} ota_info_t; + +enum class OTA_ERR : uint32_t { + OTA_SUCC = 0x00000000u, //"成功" + OTA_ERR_INVALID_PARAM = 0x00000001u, //"参数错误" + OTA_ERR_INITIALIZE_ERR = 0x00000002u, //"OTA初始化错误" + OTA_ERR_STATUS_UPDATING = 0x00000003u, //"OTA正在升级中" + OTA_ERR_INVAILD_STORAGE = 0x00000004u, //"获取升级区信息错误" + OTA_ERR_INSUFFICIENT_STORAGE_SPACE = 0x00000005u, //"升级区没有足够的空间" + OTA_ERR_PACKAGE_SIZE_ERROR = 0x00000006u, //"升级包大小不匹配" +}; + +static constexpr const uint8_t vol_type_all_idx = 0; +static constexpr const uint8_t vol_type_max_idx = 7; +static constexpr const uint8_t vol_type_alarm = 1; // 报警类 +static constexpr const uint8_t vol_type_ring = 2; // 来电铃声 +static constexpr const uint8_t vol_type_call = 3; // 语音通话 +static constexpr const uint8_t vol_type_assistant = 4; // 语音助手 +static constexpr const uint8_t vol_type_notification = 5; // 通用提示音 +static constexpr const uint8_t vol_type_music = 6; // 音乐 +static constexpr const uint8_t vol_type_video = 7; // 视频 + + +class device_proxy { +public: + static void get_storage_info(storage_info &info); + static void get_language_id(uint8_t &lang_id); + static void set_language_id(uint8_t lang_id); + static void get_product_info(std::string &info_string); + static void get_volume_info(uint8_t vol_type, std::vector &vol_info); + static void set_volume_info(volume_info &vol_info); + static OTA_ERR ota_init(ota_info &info); + static OTA_ERR ota_update(ota_info &info); + static void call_ui_ota_update(); +public: + static uint32_t calc_stat_size(uint64_t size); + static uint8_t calc_vol_percentage(int32_t min, int32_t max, int32_t curr); + static int32_t calc_vol_volume(int32_t min, int32_t max, uint8_t percentage); + static void trans_type_to_audio_stream_type(uint8_t type, std::vector &audio_types); + static int delete_file_with_cleanup(const char *ppath, const char *path); +}; + +class battery_power { +public: + static uint8_t get_battery_percentage(); + +protected: + static battery_power *get_instance(); + +private: + battery_power(); + ~battery_power(); + bool adc_context_init(); + bool adc_context_startup(); + void adc_context_shutdown(); + uint8_t calc_percentage(uint32_t voltage); + uint32_t calc_voltage(); + uint32_t adc_trans_sytick_to_voltages(uint32_t sytick); + +private: + adc_channel_t channel; // ADC信道 + pin_t analog_pin; // ADC输入引脚 + pin_mode_t mode; // ADC管脚工作模式 + uint32_t samples_to_keep; // 总采样次数 + uint32_t samples_to_discard; // 丢弃的初始样本数 + uint32_t adc_max_range_mv; // ADC原始值上限(单位:毫伏) + uint32_t adc_min_range_mv; // ADC原始值下限(单位:毫伏) +}; + +} // namespace OHOS +#endif \ No newline at end of file diff --git a/code/sdk/application/wearable/fd230/service/device_msg/msg_center_device.cpp b/code/sdk/application/wearable/fd230/service/device_msg/msg_center_device.cpp new file mode 100644 index 000000000..56f89c1a8 --- /dev/null +++ b/code/sdk/application/wearable/fd230/service/device_msg/msg_center_device.cpp @@ -0,0 +1,520 @@ +/* + * Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved. + * Description: Breath Ease + * Author: wangle + * Create: 2025-4-23 + */ +#include "msg_center_protocol.h" +#include "msg_center_device.h" +#include "device_proxy.h" +#include "wearable_log.h" +#include "device_location.h" +#include "AppViewIDs.h" +#include "NativeAbility.h" +#include "sports/SportsModel.h" +#include "findphone/FindPhoneMainPage.h" +#include "camera/CameraMainPage.h" + +#ifdef __cplusplus +extern "C" { +#endif +#include "diag_msg.h" +#include "diag_ind_src.h" + +uint8_t g_bloodoxygen = 0; +uint16_t g_heartrate = 0; +uint32_t g_stepdata = 0; +uint32_t g_distance = 0; +extern LocationInfo_t g_locationInfo; +// 获取电量 +errcode_t msg_center_get_battery_level(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "get_battery_level"); + uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data); + void *v_data = msg_center_get_tlv_payload(usr_data); + uint8_t v_len = usr_len - tl_len; + + uint8_t battery_level = OHOS::battery_power::get_battery_percentage(); + + errcode_t ret = msg_center_send_data(cmd_id, type, &battery_level, sizeof(battery_level)); + if (ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "send get_battery_level_ack fail, ret = %d", ret); + return ERRCODE_FAIL; + } + return ERRCODE_SUCC; +} +// 获取存储空间 +errcode_t msg_center_get_storage_info(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "get_storage_info"); + uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data); + void *v_data = msg_center_get_tlv_payload(usr_data); + uint8_t v_len = usr_len - tl_len; + uint8_t battery_level = 0; + + OHOS::storage_info info; + OHOS::device_proxy::get_storage_info(info); + + errcode_t ret = msg_center_send_data(cmd_id, type, &info, sizeof(OHOS::storage_info)); + if (ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "send get_storage_info_ack fail, ret = %d", ret); + return ERRCODE_FAIL; + } + return ERRCODE_SUCC; +} +// 获取手表类型 +errcode_t msg_center_get_product_info(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "get_product_info"); + uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data); + void *v_data = msg_center_get_tlv_payload(usr_data); + uint8_t v_len = usr_len - tl_len; + uint8_t battery_level = 0; + + std::string product_info; + OHOS::device_proxy::get_product_info(product_info); + + errcode_t ret = msg_center_send_data(cmd_id, type, (void *)product_info.c_str(), product_info.length()); + if (ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "send get_product_info_ack fail, ret = %d", ret); + return ERRCODE_FAIL; + } + return ERRCODE_SUCC; +} +// 获取语言 +errcode_t msg_center_get_language_id(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "get_language_id"); + uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data); + void *v_data = msg_center_get_tlv_payload(usr_data); + uint8_t v_len = usr_len - tl_len; + uint8_t battery_level = 0; + + uint8_t language_id = 0; + OHOS::device_proxy::get_language_id(language_id); + + errcode_t ret = msg_center_send_data(cmd_id, type, &language_id, sizeof(uint8_t)); + if (ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "send get_language_id_ack fail, ret = %d", ret); + return ERRCODE_FAIL; + } + return ERRCODE_SUCC; +} +// 获取音量 +errcode_t msg_center_get_volume_info(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "get_volume_info"); + uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data); + void *v_data = msg_center_get_tlv_payload(usr_data); + uint8_t v_len = usr_len - tl_len; + + uint8_t vol_type = 0; + if (v_len == sizeof(uint8_t)) { + vol_type = *(uint8_t *)v_data; + } + + std::vector vol_info; + OHOS::device_proxy::get_volume_info(vol_type, vol_info); + + errcode_t ret = msg_center_send_data(cmd_id, type, &vol_info[0], vol_info.size() * sizeof(OHOS::volume_info)); + if (ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "send get_volume_info_ack fail, ret = %d", ret); + return ERRCODE_FAIL; + } + return ERRCODE_SUCC; +} +// 设置语言 +errcode_t msg_center_set_language_id(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "set_language_id"); + uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data); + void *v_data = msg_center_get_tlv_payload(usr_data); + uint8_t v_len = usr_len - tl_len; + + uint8_t language_id = 0; + if (v_len != sizeof(uint8_t)) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "v_len check error, v_len=%u, need=%u", v_len, sizeof(uint8_t)); + return ERRCODE_FAIL; + } + + language_id = *(uint8_t *)v_data; + OHOS::device_proxy::set_language_id(language_id); + + errcode_t ret = msg_center_send_data(cmd_id, type, &language_id, sizeof(uint8_t)); + if (ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "send set_language_id_ack fail, ret = %d", ret); + return ERRCODE_FAIL; + } + return ERRCODE_SUCC; +} +// 设置音量 +errcode_t msg_center_set_volume_info(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "set_volume_info"); + uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data); + void *v_data = msg_center_get_tlv_payload(usr_data); + uint8_t v_len = usr_len - tl_len; + + OHOS::volume_info info; + if (v_len != sizeof(OHOS::volume_info)) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "v_len check error, v_len=%u, need=%u", v_len, sizeof(uint8_t)); + return ERRCODE_FAIL; + } + + memcpy_s(&info, sizeof(OHOS::volume_info), v_data, v_len); + OHOS::device_proxy::set_volume_info(info); + + errcode_t ret = msg_center_send_data(cmd_id, type, &info, sizeof(OHOS::volume_info)); + if (ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "send set_volume_info_ack fail, ret = %d", ret); + return ERRCODE_FAIL; + } + return ERRCODE_SUCC; +} +// ota初始化 +errcode_t msg_center_ota_init(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "ota_init"); + uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data); + void *v_data = msg_center_get_tlv_payload(usr_data); + uint8_t v_len = usr_len - tl_len; + + OHOS::ota_info info; + if (v_len != sizeof(OHOS::ota_info)) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "v_len check error, v_len=%u, need=%u", v_len, sizeof(uint8_t)); + return ERRCODE_FAIL; + } + + memcpy_s(&info, sizeof(OHOS::ota_info), v_data, v_len); + OHOS::OTA_ERR err = OHOS::device_proxy::ota_init(info); + + errcode_t ret = msg_center_send_data(cmd_id, type, &err, sizeof(OHOS::OTA_ERR)); + if (ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "send set_volume_info_ack fail, ret = %d", ret); + return ERRCODE_FAIL; + } + return ERRCODE_SUCC; +} +// ota检测和本地升级 +errcode_t msg_center_ota_update(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "ota_update"); + uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data); + void *v_data = msg_center_get_tlv_payload(usr_data); + uint8_t v_len = usr_len - tl_len; + + OHOS::ota_info info; + if (v_len != sizeof(OHOS::ota_info)) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "v_len check error, v_len=%u, need=%u", v_len, sizeof(uint8_t)); + return ERRCODE_FAIL; + } + + memcpy_s(&info, sizeof(OHOS::ota_info), v_data, v_len); + OHOS::OTA_ERR err = OHOS::device_proxy::ota_update(info); + + errcode_t ret = msg_center_send_data(cmd_id, type, &err, sizeof(OHOS::OTA_ERR)); + if (ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "send set_volume_info_ack fail, ret = %d", ret); + return ERRCODE_FAIL; + } + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "send ret = %d", ret); + OHOS::device_proxy::call_ui_ota_update(); + + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "send ui over"); + return ERRCODE_SUCC; +} + +errcode_t msg_center_device_heartrate(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data); + uint16_t payload_len = usr_len - tl_len; + uint8_t *tlv_payload = (uint8_t *)msg_center_get_tlv_payload(usr_data); + errcode_t ret = ERRCODE_SUCC; + + ret = msg_center_send_data(cmd_id, type, &g_heartrate, sizeof(g_heartrate)); + if (ret != ERRCODE_SUCC) { + return ERRCODE_FAIL; + } + WEARABLE_LOGD(WEARABLE_LOG_MODULE_MSG_CENTER, "msg_center_device_heartrate:%d\r\n", g_heartrate); + /* notify UI or call UI load */ + + return ERRCODE_SUCC; +} + +errcode_t msg_center_device_stepdata(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data); + uint16_t payload_len = usr_len - tl_len; + uint8_t *tlv_payload = (uint8_t *)msg_center_get_tlv_payload(usr_data); + errcode_t ret = ERRCODE_SUCC; + + ret = msg_center_send_data(cmd_id, type, &g_stepdata, sizeof(g_stepdata)); + if (ret != ERRCODE_SUCC) { + return ERRCODE_FAIL; + } + WEARABLE_LOGD(WEARABLE_LOG_MODULE_MSG_CENTER, "msg_center_device_stepdata:%d\r\n", g_stepdata); + /* notify UI or call UI load */ + + return ERRCODE_SUCC; +} + +errcode_t msg_center_device_bloodoxygen(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data); + uint16_t payload_len = usr_len - tl_len; + uint8_t *tlv_payload = (uint8_t *)msg_center_get_tlv_payload(usr_data); + errcode_t ret = ERRCODE_SUCC; + + ret = msg_center_send_data(cmd_id, type, &g_bloodoxygen, sizeof(g_bloodoxygen)); + if (ret != ERRCODE_SUCC) { + return ERRCODE_FAIL; + } + WEARABLE_LOGD(WEARABLE_LOG_MODULE_MSG_CENTER, "msg_center_device_bloodoxygen:%d\r\n", g_bloodoxygen); + /* notify UI or call UI load */ + + return ERRCODE_SUCC; +} + +/* LOCATION */ +errcode_t msg_center_location_get_info(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data); + uint16_t payload_len = usr_len - tl_len; + uint8_t *tlv_payload = (uint8_t *)msg_center_get_tlv_payload(usr_data); + errcode_t ret = ERRCODE_SUCC; + + ret = msg_center_send_data(cmd_id, type, &g_locationInfo, sizeof(g_locationInfo)); + if (ret != ERRCODE_SUCC) { + return ERRCODE_FAIL; + } + WEARABLE_LOGD(WEARABLE_LOG_MODULE_MSG_CENTER, "msg_center_location_get_info latitude_:%d,longitude_:%d\n", + g_locationInfo.latitude_, g_locationInfo.longitude_); + /* notify UI or call UI load */ + + return ERRCODE_SUCC; +} + +errcode_t msg_center_location_start(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data); + uint16_t payload_len = usr_len - tl_len; + uint8_t *tlv_payload = (uint8_t *)msg_center_get_tlv_payload(usr_data); + errcode_t ret = ERRCODE_SUCC; + uint8_t ack = 1; + + WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "msg_center_location_start finish\r\n"); + ret = deviceLocationStartLocating(); + if (ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "msg_center_location_start fail\r\n"); + ret = msg_center_send_data(cmd_id, type, &ack, sizeof(ack)); + if (ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "msg_center_location_start send msg fail\r\n"); + return ERRCODE_FAIL; + } + } else { + ret = msg_center_send_data(cmd_id, type, &ack, sizeof(ack)); + if (ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "msg_center_location_start send msg fail\r\n"); + return ERRCODE_FAIL; + } + } + + WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "msg_center_location_start finish\r\n"); + /* notify UI or call UI load */ + + return ERRCODE_SUCC; +} + +errcode_t msg_center_location_stop(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data); + uint16_t payload_len = usr_len - tl_len; + uint8_t *tlv_payload = (uint8_t *)msg_center_get_tlv_payload(usr_data); + errcode_t ret = ERRCODE_SUCC; + uint8_t ack = 1; + + WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "msg_center_location_stop\r\n"); + ret = deviceLocationStopLocating(); + ret = msg_center_send_data(cmd_id, type, &ack, sizeof(ack)); + if (ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "msg_center_location_stop fail\r\n"); + ret = msg_center_send_data(cmd_id, type, &ack, sizeof(ack)); + if (ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "msg_center_location_stop send msg fail\r\n"); + return ERRCODE_FAIL; + } + } else { + ret = msg_center_send_data(cmd_id, type, &ack, sizeof(ack)); + if (ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "msg_center_location_stop send msg fail\r\n"); + return ERRCODE_FAIL; + } + } + + WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "msg_center_location_stop\r\n"); + /* notify UI or call UI load */ + + return ERRCODE_SUCC; +} + +/* SPORT */ +errcode_t msg_center_sport_action(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data); + uint16_t payload_len = usr_len - tl_len; + uint8_t *tlv_payload = (uint8_t *)msg_center_get_tlv_payload(usr_data); + errcode_t ret = ERRCODE_SUCC; + uint8_t ack = 1; + sport_action_t action = (sport_action_t)*tlv_payload; + + WEARABLE_LOGD(WEARABLE_LOG_MODULE_MSG_CENTER, "msg_center_sport_action : %d\r\n", action); + + switch (action) { + case SPORT_ACTION_START: + OHOS::NativeAbility::GetInstance().ChangeSlice(VIEW_SPORTS); + OHOS::SportsModel::GetInstance()->ResetSportsData(); + if (!OHOS::SportsModel::GetInstance()->StartSportsTimer()) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "msg_center_sport_start StartSportsTimer failed\r\n"); + ret = ERRCODE_FAIL; + } + break; + case SPORT_ACTION_PAUSE: + OHOS::SportsModel::GetInstance()->StopSportsTimer(false); + break; + case SPORT_ACTION_RESUME: + if (!OHOS::SportsModel::GetInstance()->StartSportsTimer()) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "msg_center_sport_resume StartSportsTimer failed\r\n"); + ret = ERRCODE_FAIL; + } + break; + case SPORT_ACTION_STOP: + OHOS::SportsModel::GetInstance()->StopSportsTimer(false); + OHOS::NativeAbility::GetInstance().ChangeSlice(VIEW_MAIN_SAMPLE); + break; + default: + ret = ERRCODE_FAIL; + break; + } + + ret = msg_center_send_data(cmd_id, type, &ack, sizeof(ack)); + if (ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "msg_center_sport_resume send data failed\r\n"); + return ERRCODE_FAIL; + } + return ERRCODE_SUCC; +} + +errcode_t msg_center_sport_get_data(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data); + uint16_t payload_len = usr_len - tl_len; + uint8_t *tlv_payload = (uint8_t *)msg_center_get_tlv_payload(usr_data); + errcode_t ret = ERRCODE_SUCC; + + WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "msg_center_sport_get_data\r\n"); + OHOS::sport_data_t *sportData = OHOS::SportsModel::GetInstance()->GetSportsData(); + ret = msg_center_send_data(cmd_id, type, sportData, sizeof(OHOS::sport_data_t)); + if (ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "msg_center_sport_get_data end data failed\r\n"); + return ERRCODE_FAIL; + } + return ERRCODE_SUCC; +} + +errcode_t msg_center_sport_report_data(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + return ERRCODE_SUCC; +} + +errcode_t msg_center_camera_exit(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + WEARABLE_LOGD(WEARABLE_LOG_MODULE_MSG_CENTER, "recv exit camera from phone"); + OHOS::NativeAbility::GetInstance().ChangeSlice(VIEW_APPLIST); + return ERRCODE_SUCC; +} + +errcode_t msg_center_camera_online(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + WEARABLE_LOGD(WEARABLE_LOG_MODULE_MSG_CENTER, "recv connect success from phone"); + if (OHOS::CameraMainPage::GetInstance() != nullptr) { + OHOS::CameraMainPage::GetInstance()->Refresh_page(); + return ERRCODE_SUCC; + } else { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_MSG_CENTER, "CameraMainPage not exist\r\n"); + return ERRCODE_FAIL; + } +} + +errcode_t msg_center_offline_log_switch(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data); + uint16_t payload_len = usr_len - tl_len; + uint8_t *tlv_payload = (uint8_t *)msg_center_get_tlv_payload(usr_data); + uint8_t data = *tlv_payload; + errcode_t ret = ERRCODE_SUCC; + WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "msg_center_offline_log_switch, data = %d\r\n", data); + if (data) { + uapi_zdiag_set_offline_log_enable(true); /*open offline log*/ + } else { + uapi_zdiag_set_offline_log_enable(false); /*close offline log*/ + } + ret = msg_center_send_data(cmd_id, type, &data, sizeof(data)); + if (ret != ERRCODE_SUCC) { + return ERRCODE_FAIL; + } + return ERRCODE_SUCC; +} + +#if (CONFIG_ONLINE_LOG == 1) +errcode_t msg_center_set_online_log_channel(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data); + uint16_t payload_len = usr_len - tl_len; + uint8_t *tlv_payload = (uint8_t *)msg_center_get_tlv_payload(usr_data); + uint8_t data = *tlv_payload; + errcode_t ret = ERRCODE_SUCC; + WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "msg_center_set_online_log_channel, data = %d\r\n", data); + change_log_diag_channel(data); + ret = msg_center_send_data(cmd_id, type, &data, sizeof(data)); + if (ret != ERRCODE_SUCC) { + return ERRCODE_FAIL; + } + return ERRCODE_SUCC; +} + +errcode_t msg_center_set_online_log_level(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data); + uint16_t payload_len = usr_len - tl_len; + uint8_t *tlv_payload = (uint8_t *)msg_center_get_tlv_payload(usr_data); + uint8_t data = *tlv_payload; + errcode_t ret = ERRCODE_SUCC; + WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "msg_center_set_online_log_level, data = %d\r\n", data); + set_online_log_level(data); + ret = msg_center_send_data(cmd_id, type, &data, sizeof(data)); + if (ret != ERRCODE_SUCC) { + return ERRCODE_FAIL; + } + return ERRCODE_SUCC; +} +#endif + +errcode_t msg_center_device_findphone(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data); + uint16_t payload_len = usr_len - tl_len; + uint8_t *tlv_payload = (uint8_t *)msg_center_get_tlv_payload(usr_data); + bool ret = true; + if ( OHOS::FindPhoneMainPage::GetInstance() != nullptr) { + ret = OHOS::FindPhoneMainPage::GetInstance()->StopFindPhone(); + } else { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_MSG_CENTER, "FindphonePage not exist\r\n"); + } + if (!ret) { + return ERRCODE_FAIL; + } + return ERRCODE_SUCC; +} +#ifdef __cplusplus +} +#endif \ No newline at end of file diff --git a/code/sdk/application/wearable/fd230/service/device_msg/msg_center_device.h b/code/sdk/application/wearable/fd230/service/device_msg/msg_center_device.h new file mode 100644 index 000000000..02f3c2583 --- /dev/null +++ b/code/sdk/application/wearable/fd230/service/device_msg/msg_center_device.h @@ -0,0 +1,114 @@ +/* + * Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved. + * Description: Breath Ease + * Author: wangle + * Create: 2025-4-23 + */ +#ifndef MSG_CENTER_DEVICE_H +#define MSG_CENTER_DEVICE_H + +#include "msg_center_protocol.h" +#include "wearable_log.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum sport_action { + SPORT_ACTION_START = 1, + SPORT_ACTION_PAUSE = 2, + SPORT_ACTION_RESUME = 3, + SPORT_ACTION_STOP = 4, +} sport_action_t; + +typedef enum msg_center_device_type_id { + MSGCENTER_TYPE_ID_GET_BATTERY_LEVEL = 0x1, + MSGCENTER_TYPE_ID_GET_STORAGE_INFO = 0x2, + MSGCENTER_TYPE_ID_GET_PRODUCT_INFO = 0x3, + MSGCENTER_TYPE_ID_GET_LANGUAGE_ID = 0x4, + MSGCENTER_TYPE_ID_GET_VOLUME_INFO = 0x5, + MSGCENTER_TYPE_ID_SET_LANGUAGE_ID = 0x6, + MSGCENTER_TYPE_ID_SET_VOLUME_INFO = 0x7, + MSGCENTER_TYPE_ID_DEVICE_HEARTRATE = 0x8, + MSGCENTER_TYPE_ID_DEVICE_STEPDATA = 0x9, + MSGCENTER_TYPE_ID_DEVICE_BLOODOXYGEN = 0xa, + MSGCENTER_TYPE_ID_OFFLINE_LOG_SWITCH = 0xb, + MSGCENTER_TYPE_ID_LOCATION_GET_INFO = 0x20, + MSGCENTER_TYPE_ID_LOCATION_START = 0x21, + MSGCENTER_TYPE_ID_LOCATION_STOP = 0x22, + MSGCENTER_TYPE_ID_LOCATION_REPORT = 0x23, + MSGCENTER_TYPE_ID_SPORT_ACTION = 0x27, + MSGCENTER_TYPE_ID_SPORT_GET_DATA = 0x28, + MSGCENTER_TYPE_ID_SPORT_REPORT_DATA = 0x29, + MSGCENTER_TYPE_ID_SET_ONLINELOG_CHANNEL = 0x30, + MSGCENTER_TYPE_ID_SET_ONLINELOG_LEVEL = 0x31, + MSGCENTER_TYPE_ID_ONLINELOG_REPORT = 0x33, + MSGCENTER_TYPE_ID_OTA_INIT = 0x34, + MSGCENTER_TYPE_ID_OTA_UPDATE = 0x35, + MSGCENTER_TYPE_ID_ON_FIND_PHONE = 0x36, + MSGCENTER_TYPE_ID_OFF_FIND_PHONE = 0x37, + MSGCENTER_TYPE_ID_SLEEP_DATA = 0x38, + MSGCENTER_TYPE_ID_ON_CAMERA = 0x39, + MSGCENTER_TYPE_ID_CAMERA_WATCH_EXIT = 0x40, + MSGCENTER_TYPE_ID_CAMERA_PHONE_EXIT = 0x41, + MSGCENTER_TYPE_ID_CAMERA_CONNECT_PHONE = 0x42, + MSGCENTER_TYPE_ID_CAMERA_CONNECT_PHONE_SUCCESS = 0x43, +} msg_center_device_type_id_t; + +// 获取电量 +errcode_t msg_center_get_battery_level(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len); +// 获取存储空间 +errcode_t msg_center_get_storage_info(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len); +// 获取手表类型 +errcode_t msg_center_get_product_info(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len); +// 获取语言 +errcode_t msg_center_get_language_id(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len); +// 获取音量 +errcode_t msg_center_get_volume_info(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len); +// 设置语言 +errcode_t msg_center_set_language_id(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len); +// 设置音量 +errcode_t msg_center_set_volume_info(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len); +// ota初始化 +errcode_t msg_center_ota_init(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len); +// ota检测和本地升级 +errcode_t msg_center_ota_update(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len); + +errcode_t msg_center_device_heartrate(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len); +errcode_t msg_center_device_stepdata(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len); +errcode_t msg_center_device_bloodoxygen(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len); + +/* LOCATION */ +errcode_t msg_center_location_get_info(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len); +errcode_t msg_center_location_start(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len); +errcode_t msg_center_location_stop(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len); + +/* SPORT */ +errcode_t msg_center_sport_action(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len); +errcode_t msg_center_sport_get_data(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len); +errcode_t msg_center_sport_report_data(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len); + +/* 离线日志开关 */ +errcode_t msg_center_offline_log_switch(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len); + +/* 查找手机 */ +errcode_t msg_center_device_findphone(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len); + +/* CAMERA */ +errcode_t msg_center_camera_exit(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len); +errcode_t msg_center_camera_online(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len); + +#if (CONFIG_ONLINE_LOG == 1) +/* 在线日志通道 */ +errcode_t msg_center_set_online_log_channel(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len); +/* 在线日志级数 */ +errcode_t msg_center_set_online_log_level(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len); +#endif + +#ifdef PUBLISH_TEST_DATA +void PublishTestData(); +#endif +#ifdef __cplusplus +} +#endif +#endif /* MSG_CENTER_DEVICE_H */ diff --git a/code/sdk/application/wearable/fd230/service/dial_market/CMakeLists.txt b/code/sdk/application/wearable/fd230/service/dial_market/CMakeLists.txt index 058f8dc76..8c61862ab 100644 --- a/code/sdk/application/wearable/fd230/service/dial_market/CMakeLists.txt +++ b/code/sdk/application/wearable/fd230/service/dial_market/CMakeLists.txt @@ -11,7 +11,6 @@ set(PRIVATE_HEADER ${ROOT_DIR}/middleware/services/gui/uikit/utils/interfaces/kits/gfx_utils ${ROOT_DIR}/open_source/openharmony/base/startup/syspara_lite/include ${ROOT_DIR}/open_source/openharmony/drivers/peripheral/format/interfaces/include - ${ROOT_DIR}/application/wearable/nativeapp/nativeui/main/include/dial ) set(SOURCES diff --git a/code/sdk/application/wearable/fd230/service/dial_market/dial_market.cpp b/code/sdk/application/wearable/fd230/service/dial_market/dial_market.cpp new file mode 100644 index 000000000..5d6de8491 --- /dev/null +++ b/code/sdk/application/wearable/fd230/service/dial_market/dial_market.cpp @@ -0,0 +1,244 @@ +/* + * Copyright (c) CompanyNameMagicTag 2023-2023. All rights reserved. + * Description: ota upgrade handle. + * This file should be changed only infrequently and with great care. + */ +#include +#include "securec.h" +#include "msg_center.h" +#include "msg_center_protocol.h" +#include "msg_center_cmd.h" +#include "wearable_log.h" +#include "common_def.h" +#include "dial_market.h" +#include "parameter.h" +#include "main/dial/WatchInterface.h" + +#ifdef __cplusplus +extern "C" { +#endif + +errcode_t msg_center_dial_market_get_sys_info(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + errcode_t ret = ERRCODE_SUCC; + watch_sys_info sys; + bool op_ret = false; + + /* 组装信息 */ + strcpy_s(sys.chip_platform, MAX_CHIP_PLAT_LEN, "hisi"); + strcpy_s(sys.chip_model, MAX_CHIP_MODEL_LEN, "3321"); + char *os_version = GetOsName(); + if (os_version == NULL) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "os_version is NULL\r\n"); + return ERRCODE_FAIL; + } + strcpy_s(sys.os_version, MAX_OS_LEN, os_version); // "OpenHarmony-5.0.1.115" + + char *api_level = GetSdkApiLevel(); + if (api_level == NULL) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "api_level is NULL\r\n"); + free(os_version); + return ERRCODE_FAIL; + } + strcpy_s(sys.api_level, MAX_API_LEVEL_LEN, api_level); // "13" + + op_ret = GetWatchSystemInfo(&sys); + if (op_ret == false) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "GetWatchSystemInfo fail\r\n"); + free(os_version); + free(api_level); + return ERRCODE_FAIL; + } + + ret = msg_center_send_data(cmd_id, type, &sys, sizeof(watch_sys_info)); + if (ret != ERRCODE_SUCC) { + free(os_version); + free(api_level); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "send data fail, ret = %d\r\n", ret); + return ERRCODE_FAIL; + } + + free(os_version); + free(api_level); + return ERRCODE_SUCC; +} + +errcode_t msg_center_dial_market_get_dev_cap(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + errcode_t ret = ERRCODE_SUCC; + watch_dev_cap_info cap; + bool op_ret = false; + + op_ret = GetWatchCapability(&cap); + if (op_ret == false) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "GetWatchCapability fail\r\n"); + return ERRCODE_FAIL; + } + + ret = msg_center_send_data(cmd_id, type, &cap, sizeof(watch_dev_cap_info)); + if (ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "send data fail, ret = %d\r\n", ret); + return ERRCODE_FAIL; + } + + return ERRCODE_SUCC; +} + +errcode_t msg_center_dial_market_get_one_watch_info(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + errcode_t ret = ERRCODE_SUCC; + uint8_t *tlv_payload = (uint8_t *)msg_center_get_tlv_payload(usr_data); + uint32_t uuid = *(uint32_t *)tlv_payload; + bool op_ret = false; + watch_dial_info info; + + WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "uuid = %d\r\n", uuid); + op_ret = GetWatchFaceInfo(uuid, &info); + if (op_ret == false) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "GetWatchFaceInfo fail\r\n"); + (void)memset_s(&info, sizeof(watch_dial_info), 0, sizeof(watch_dial_info)); + info.uuid = uuid; + (void)msg_center_send_data(cmd_id, type, &info, sizeof(watch_dial_info)); + return ERRCODE_FAIL; + } + + ret = msg_center_send_data(cmd_id, type, &info, sizeof(watch_dial_info)); + if (ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "send data fail, ret = %d\r\n", ret); + return ERRCODE_FAIL; + } + + return ERRCODE_SUCC; +} + +errcode_t msg_center_dial_market_install_watch(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + errcode_t ret = ERRCODE_SUCC; + uint32_t uuid = 0; + bool op_ret = false; + uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data); + uint16_t payload_len = usr_len - tl_len; + uint8_t *tlv_payload = (uint8_t *)msg_center_get_tlv_payload(usr_data); + + char *path = (char *)malloc(payload_len + 1); + if (path == nullptr) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "malloc failed.\r\n"); + return ERRCODE_FAIL; + } + + (void)memcpy_s(path, payload_len, tlv_payload, payload_len); + path[payload_len] = '\0'; + WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "path = %s\r\n", path); + + op_ret = GetUuidByPath(path, &uuid); + if (op_ret == false) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "install fail.\r\n"); + free(path); + return ERRCODE_FAIL; + } + + ret = msg_center_send_data(cmd_id, type, &uuid, sizeof(uint32_t)); + if (ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "send data fail, ret = %d\r\n", ret); + free(path); + return ERRCODE_FAIL; + } + + free(path); + return ERRCODE_SUCC; +} + +errcode_t msg_center_dial_market_uninstall_watch(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + errcode_t ret = ERRCODE_SUCC; + bool op_ret = false; + uint8_t *tlv_payload = (uint8_t *)msg_center_get_tlv_payload(usr_data); + uint32_t uuid = *(uint32_t *)tlv_payload; + + WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "uuid = %d\r\n", uuid); + op_ret = UninstallWatch(uuid); + WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "uninstall ret : %d\r\n", op_ret); + + ret = msg_center_send_data(cmd_id, type, &op_ret, sizeof(uint8_t)); + if (ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "send data fail, ret = %d\r\n", ret); + return ERRCODE_FAIL; + } + + return ERRCODE_SUCC; +} + +errcode_t msg_center_dial_market_set_watch(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + errcode_t ret = ERRCODE_SUCC; + bool op_ret = false; + uint8_t *tlv_payload = (uint8_t *)msg_center_get_tlv_payload(usr_data); + uint32_t uuid = *(uint32_t *)tlv_payload; + + WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "uuid = %d\r\n", uuid); + op_ret = SetCurrentWatchFace(uuid); + WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "set_current_watch_face ret : %d\r\n", op_ret); + + ret = msg_center_send_data(cmd_id, type, &op_ret, sizeof(uint8_t)); + if (ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "send data fail, ret = %d\r\n", ret); + return ERRCODE_FAIL; + } + + return ERRCODE_SUCC; +} + +errcode_t msg_center_dial_market_get_all_watch_info(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + errcode_t ret = ERRCODE_SUCC; + watch_dial_info *info = nullptr; + uint8_t watch_num = 0; + bool op_ret = false; + + WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "get_all_watch_info\r\n"); + op_ret = GetAllWatchFaceInfo(&info, &watch_num); + if (op_ret == false) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "GetAllWatchFaceInfo fail\r\n"); + watch_num = 0; + (void)msg_center_send_data(cmd_id, type, info, sizeof(watch_dial_info) * watch_num); + return ERRCODE_FAIL; + } + + ret = msg_center_send_data(cmd_id, type, info, sizeof(watch_dial_info) * watch_num); + if (ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "send data fail, ret = %d\r\n", ret); + free(info); + return ERRCODE_FAIL; + } + + free(info); + return ERRCODE_SUCC; +} + +errcode_t msg_center_dial_market_get_cur_watch_info(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + errcode_t ret = ERRCODE_SUCC; + bool op_ret = false; + watch_dial_info info; + + WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "get_cur_watch_info\r\n"); + op_ret = GetCurrentWatchFaceInfo(&info); + if (op_ret == false) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "GetCurrentWatchFaceInfo fail\r\n"); + (void)memset_s(&info, sizeof(watch_dial_info), 0, sizeof(watch_dial_info)); + info.uuid = 0xFFFFFFFF; // 异常时用全F的uuid表示 + (void)msg_center_send_data(cmd_id, type, &info, sizeof(watch_dial_info)); + return ERRCODE_FAIL; + } + + ret = msg_center_send_data(cmd_id, type, &info, sizeof(watch_dial_info)); + if (ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "send data fail, ret = %d\r\n", ret); + return ERRCODE_FAIL; + } + + return ERRCODE_SUCC; +} +#ifdef __cplusplus +} +#endif \ No newline at end of file diff --git a/code/sdk/application/wearable/fd230/service/dial_market/dial_market_msg.cpp b/code/sdk/application/wearable/fd230/service/dial_market/dial_market_msg.cpp new file mode 100644 index 000000000..b30812e0b --- /dev/null +++ b/code/sdk/application/wearable/fd230/service/dial_market/dial_market_msg.cpp @@ -0,0 +1,47 @@ + +#include "msg_center_protocol.h" +#include "msg_center_cmd.h" +#include "ohos_init.h" +#include "dial_market.h" + +namespace OHOS { + +#ifdef __cplusplus +extern "C" { +#endif + +static const msg_center_cmd_map_t g_msg_center_dial_market_tbl[] = { + { MSGCENTER_CMD_DIAL_MARKET, MSGCENTER_TYPE_ID_DM_GET_SYS_INFO, msg_center_dial_market_get_sys_info}, + { MSGCENTER_CMD_DIAL_MARKET, MSGCENTER_TYPE_ID_DM_GET_DEV_CAP, msg_center_dial_market_get_dev_cap}, + { MSGCENTER_CMD_DIAL_MARKET, MSGCENTER_TYPE_ID_DM_GET_ONE_WATCH_INFO, msg_center_dial_market_get_one_watch_info}, + { MSGCENTER_CMD_DIAL_MARKET, MSGCENTER_TYPE_ID_DM_INSTALL_WATCH, msg_center_dial_market_install_watch}, + { MSGCENTER_CMD_DIAL_MARKET, MSGCENTER_TYPE_ID_DM_UNINSTALL_WATCH, msg_center_dial_market_uninstall_watch}, + { MSGCENTER_CMD_DIAL_MARKET, MSGCENTER_TYPE_ID_DM_SET_WATCH, msg_center_dial_market_set_watch}, + { MSGCENTER_CMD_DIAL_MARKET, MSGCENTER_TYPE_ID_DM_GET_ALL_WATCH_INFO, msg_center_dial_market_get_all_watch_info}, + { MSGCENTER_CMD_DIAL_MARKET, MSGCENTER_TYPE_ID_DM_GET_CUR_WATCH_INFO, msg_center_dial_market_get_cur_watch_info}, +}; + +errcode_t msg_center_dial_market_dispatch(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + uint8_t tbl_size = sizeof(g_msg_center_dial_market_tbl) / sizeof(g_msg_center_dial_market_tbl[0]); + uint8_t i; + for (i = 0; i < tbl_size; i++) { + msg_center_cmd_map_t *item = (msg_center_cmd_map_t *)&g_msg_center_dial_market_tbl[i]; + if ((item->type == type) && (item->handler != NULL)) { + item->handler(cmd_id, type, usr_data, usr_len); + return ERRCODE_SUCC; + } + } + return ERRCODE_NOT_SUPPORT; +} + +void dial_market_init(void) +{ + msg_center_register_cmd(MSGCENTER_CMD_DIAL_MARKET, msg_center_dial_market_dispatch); +} + +APP_FEATURE_INIT_PRI(dial_market_init, LAYER_INIT_LEVEL_4); +#ifdef __cplusplus +} +#endif +} // namespace OHOS \ No newline at end of file diff --git a/code/sdk/application/wearable/fd230/service/msg_center/CMakeLists.txt b/code/sdk/application/wearable/fd230/service/msg_center/CMakeLists.txt index 86ae19f8c..64f708e71 100644 --- a/code/sdk/application/wearable/fd230/service/msg_center/CMakeLists.txt +++ b/code/sdk/application/wearable/fd230/service/msg_center/CMakeLists.txt @@ -18,9 +18,13 @@ set(PRIVATE_HEADER ${ROOT_DIR}/middleware/services/gui/uikit/proprietary/src/ui/frameworks/components_ext ${ROOT_DIR}/open_source/openharmony/drivers/peripheral/display/interfaces/include ${ROOT_DIR}/application/wearable/service/xiaodu_voice + ${ROOT_DIR}/application/wearable/service/watch_setting_msg/include ${ROOT_DIR}/application/wearable/service/xiaodu_navi_vector ${ROOT_DIR}/application/wearable/service/xiaodu_navi_vector/libs ${ROOT_DIR}/application/wearable/service/msg_center/src/notify/ketinput/include + ${ROOT_DIR}/application/wearable/nativeapp/nativelauncher/include + ${ROOT_DIR}/application/wearable/nativeabilityfwk/include + ${ROOT_DIR}/open_source/openharmony/foundation/multimedia/player/interfaces/kits ) set(SOURCES @@ -109,8 +113,7 @@ set(PRIVATE_HEADER ${ROOT_DIR}/middleware/services/gui/uikit/utils/interfaces/kits/gfx_utils ${ROOT_DIR}/middleware/services/gui/uikit/surface/interfaces/kits ${ROOT_DIR}/middleware/services/gui/uikit/ui/frameworks - ${ROOT_DIR}/middleware/services/gui/uikit/proprietary/include/components - ${ROOT_DIR}/middleware/services/gui/uikit/proprietary/src/ui/frameworks/components/ + ${ROOT_DIR}/middleware/services/gui/uikit/proprietary/src/ui/frameworks/components_ext ${ROOT_DIR}/open_source/openharmony/foundation/multimedia/audio_player/interfaces/kits ${ROOT_DIR}/open_source/openharmony/foundation/multimedia/audiomanager/interfaces/kits/audiomanager ${ROOT_DIR}/open_source/openharmony/foundation/multimedia/audiomanager/interfaces/kits/audiocommon @@ -123,6 +126,8 @@ set(PRIVATE_HEADER ${ROOT_DIR}/include/middleware/services/bts/common ${ROOT_DIR}/application/auto_ota ${ROOT_DIR}/application/wearable/service/xiaodu_navi_vector + ${ROOT_DIR}/open_source/openharmony/third_party/cJSON + ${ROOT_DIR}/application/wearable/service/device_msg ${ROOT_DIR}/application/wearable/service/msg_center/src/notify/ketinput/include ${ROOT_DIR}/application/wearable/nativeapp/nativelauncher/include ${ROOT_DIR}/application/wearable/nativeabilityfwk/include @@ -154,7 +159,9 @@ set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src/notify/makephone_notification.cpp ${CMAKE_CURRENT_SOURCE_DIR}/src/common/msg_center_common.cpp ${CMAKE_CURRENT_SOURCE_DIR}/src/common/msg_center_utils.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/src/common/msg_center_self_cmd.cpp ${CMAKE_CURRENT_SOURCE_DIR}/src/notify/ketinput/src/NotifyOnKeyListener.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/src/notify/phone_msg_notification.cpp ${CMAKE_CURRENT_SOURCE_DIR}/src/notify/pairing_notification.cpp ${CMAKE_CURRENT_SOURCE_DIR}/src/notify/transmitting.cpp ${CMAKE_CURRENT_SOURCE_DIR}/src/notify/charge_notification.cpp @@ -174,10 +181,10 @@ else() set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src/msg_center_customer.cpp ${CMAKE_CURRENT_SOURCE_DIR}/src/msg_center_cmd.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/src/msg_center_self_cmd.cpp ${CMAKE_CURRENT_SOURCE_DIR}/src/notify/alarm_notification.cpp ${CMAKE_CURRENT_SOURCE_DIR}/src/notify/makephone_notification.cpp ${CMAKE_CURRENT_SOURCE_DIR}/src/notify/ketinput/src/NotifyOnKeyListener.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/src/notify/phone_msg_notification.cpp ${CMAKE_CURRENT_SOURCE_DIR}/src/notify/pairing_notification.cpp ${CMAKE_CURRENT_SOURCE_DIR}/src/notify/transmitting.cpp ${CMAKE_CURRENT_SOURCE_DIR}/src/notify/charge_notification.cpp diff --git a/code/sdk/application/wearable/fd230/service/msg_center/brandy-auto-ota-cli/libmsg_center.a b/code/sdk/application/wearable/fd230/service/msg_center/brandy-auto-ota-cli/libmsg_center.a index f6ea17c48..c6b588af4 100644 Binary files a/code/sdk/application/wearable/fd230/service/msg_center/brandy-auto-ota-cli/libmsg_center.a and b/code/sdk/application/wearable/fd230/service/msg_center/brandy-auto-ota-cli/libmsg_center.a differ diff --git a/code/sdk/application/wearable/fd230/service/msg_center/brandy-auto-ota-ser/libmsg_center.a b/code/sdk/application/wearable/fd230/service/msg_center/brandy-auto-ota-ser/libmsg_center.a index c7c253e08..19e2cb51d 100644 Binary files a/code/sdk/application/wearable/fd230/service/msg_center/brandy-auto-ota-ser/libmsg_center.a and b/code/sdk/application/wearable/fd230/service/msg_center/brandy-auto-ota-ser/libmsg_center.a differ diff --git a/code/sdk/application/wearable/fd230/service/msg_center/brandy-native-js/libmsg_center.a b/code/sdk/application/wearable/fd230/service/msg_center/brandy-native-js/libmsg_center.a index 0e24be78a..b1e105a9c 100644 Binary files a/code/sdk/application/wearable/fd230/service/msg_center/brandy-native-js/libmsg_center.a and b/code/sdk/application/wearable/fd230/service/msg_center/brandy-native-js/libmsg_center.a differ diff --git a/code/sdk/application/wearable/fd230/service/msg_center/brandy-xts/libmsg_center.a b/code/sdk/application/wearable/fd230/service/msg_center/brandy-xts/libmsg_center.a index c686df549..7f842a9c9 100644 Binary files a/code/sdk/application/wearable/fd230/service/msg_center/brandy-xts/libmsg_center.a and b/code/sdk/application/wearable/fd230/service/msg_center/brandy-xts/libmsg_center.a differ diff --git a/code/sdk/application/wearable/fd230/service/msg_center/include/msg_center_protocol.h b/code/sdk/application/wearable/fd230/service/msg_center/include/msg_center_protocol.h index 02cf29c8f..ed6ece04c 100644 --- a/code/sdk/application/wearable/fd230/service/msg_center/include/msg_center_protocol.h +++ b/code/sdk/application/wearable/fd230/service/msg_center/include/msg_center_protocol.h @@ -62,6 +62,8 @@ typedef enum msg_center_cmd_id { MSGCENTER_CMD_WATCH_CONNECT = 0x8, MSGCENTER_CMD_APP_STORE = 0x9, MSGCENTER_CMD_DIAL_MARKET = 0xa, + MSGCENTER_CMD_PHONE_MSG = 0xb, // 增加消息通知; + MSGCENTER_CMD_DEVICE = 0xc, MSGCENTER_CMD_MAX } msg_center_cmd_id_t; diff --git a/code/sdk/application/wearable/fd230/service/msg_center/include/notify/notification_manager.h b/code/sdk/application/wearable/fd230/service/msg_center/include/notify/notification_manager.h index 532f1c11d..345828de1 100644 --- a/code/sdk/application/wearable/fd230/service/msg_center/include/notify/notification_manager.h +++ b/code/sdk/application/wearable/fd230/service/msg_center/include/notify/notification_manager.h @@ -24,6 +24,7 @@ #include "components/ui_view_group.h" #include "alarm_notification.h" #include "makephone_notification.h" +#include "phone_msg_notification.h" constexpr uint16_t HALF_SCREEN = 2; constexpr int16_t NOTIFY_PRIORITY_DEFAULT = 4; diff --git a/code/sdk/application/wearable/fd230/service/msg_center/include/notify/phone_msg_notification.h b/code/sdk/application/wearable/fd230/service/msg_center/include/notify/phone_msg_notification.h new file mode 100644 index 000000000..735c01edf --- /dev/null +++ b/code/sdk/application/wearable/fd230/service/msg_center/include/notify/phone_msg_notification.h @@ -0,0 +1,75 @@ +/* + * Copyright (c) Huawei Technologies Co., Ltd. 2025-2025. All rights reserved. + * Description: phone message notification + * Author: + * Create: 2025-04-25 + */ + +#ifndef PHONE_MSG_NOTIFICATION_H +#define PHONE_MSG_NOTIFICATION_H + +#include "components/ui_view_group.h" +#include "components/ui_view_group.h" +#include "components/ui_label.h" +#include "components/ui_label_button_ext.h" +#include "graphic_timer.h" +#include + +struct PhoneMsg { + std::string appName; + std::string msgTitle; + std::string msgContent; +}; + +namespace OHOS { +class PhoneMsgView { +public: + static UIViewGroup *CreatePhoneMsgView(); + static void FreePhoneMsgView(void); + static void UpDatePhoneMsg(std::string appName, std::string titile, std::string content); + static void StartPhoneMsgTimer(int32_t interval); + static void DisablePhoneMsgTimer(); + static const uint32_t notifyTime = 5000; + +private: + static UIViewGroup *phoneMsgView_; + static UILabel *appNameLabel_; + static UILabel *titleLabel_; + static UILabel *contentLabel_; + static GraphicTimer *phoneMsgNotifyStop_; + static PhoneMsg phoneMsg_; + static UILabelButtonExt *cancelButton_; +}; + +class PhoneMsgViewEventListener : public OHOS::UIView::OnClickListener, + public OHOS::UIView::OnLongPressListener, + public OHOS::UIView::OnTouchListener, + public OHOS::UIView::OnDragListener { +public: + PhoneMsgViewEventListener(); + virtual ~PhoneMsgViewEventListener(); + static PhoneMsgViewEventListener *GetInstance(void); + bool OnDrag(UIView& view, const DragEvent& event) override; + bool OnDragEnd(OHOS::UIView& view, const OHOS::DragEvent& event) override; + bool OnClick(OHOS::UIView& view, const OHOS::ClickEvent& event) override; + bool OnPress(OHOS::UIView& view, const OHOS::PressEvent& event) override + { + return true; + } + bool OnLongPress(OHOS::UIView& view, const OHOS::LongPressEvent& event) override + { + return true; + } + bool OnRelease(OHOS::UIView& view, const OHOS::ReleaseEvent& event) override + { + return true; + } + + bool OnDragStart(OHOS::UIView& view, const OHOS::DragEvent& event) override + { + return true; + } +}; +}; // namespace OHOS + +#endif /* PHONE_MSG_NOTIFICATION_H */ diff --git a/code/sdk/application/wearable/fd230/service/msg_center/src/common/msg_center_self_cmd.cpp b/code/sdk/application/wearable/fd230/service/msg_center/src/common/msg_center_self_cmd.cpp new file mode 100644 index 000000000..ee822bec1 --- /dev/null +++ b/code/sdk/application/wearable/fd230/service/msg_center/src/common/msg_center_self_cmd.cpp @@ -0,0 +1,43 @@ +#include "msg_center_protocol.h" +#include "msg_center_cmd.h" +#include "ohos_init.h" +#include "msg_center_common.h" +namespace OHOS { + +#ifdef __cplusplus +extern "C" { +#endif + +static const msg_center_cmd_map_t g_msg_center_self_cmd_tbl[] = { +#ifdef JS_ENABLE + { MSGCENTER_CMD_PING, MSGCENTER_TYPE_ID_PING_REC, msg_center_ping_rec}, + { MSGCENTER_CMD_PING, MSGCENTER_TYPE_ID_PING_RSP, NULL}, +#endif +}; + +errcode_t msg_center_self_cmd_type(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + uint8_t tbl_size = sizeof(g_msg_center_self_cmd_tbl) / sizeof(g_msg_center_self_cmd_tbl[0]); + uint8_t i; + for (i = 0; i < tbl_size; i++) { + msg_center_cmd_map_t *item = (msg_center_cmd_map_t *)&g_msg_center_self_cmd_tbl[i]; + if ((item->type == type) && (item->handler != NULL)) { + item->handler(cmd_id, type, usr_data, usr_len); + return ERRCODE_SUCC; + } + } + return ERRCODE_NOT_SUPPORT; +} + +void xiaodu_self_cmd_init(void) +{ + msg_center_register_cmd(MSGCENTER_CMD_PING, msg_center_self_cmd_type); +} + +#ifdef JS_ENABLE +APP_FEATURE_INIT_PRI(xiaodu_self_cmd_init, LAYER_INIT_LEVEL_4); +#endif +#ifdef __cplusplus +} +#endif +} // namespace OHOS \ No newline at end of file diff --git a/code/sdk/application/wearable/fd230/service/msg_center/src/notify/phone_msg_notification.cpp b/code/sdk/application/wearable/fd230/service/msg_center/src/notify/phone_msg_notification.cpp new file mode 100644 index 000000000..eb6a40883 --- /dev/null +++ b/code/sdk/application/wearable/fd230/service/msg_center/src/notify/phone_msg_notification.cpp @@ -0,0 +1,206 @@ +/* + * Copyright (c) Huawei Technologies Co., Ltd. 2025-2025. All rights reserved. + * Description: phone message notification + * Create: 2025-04-25 + */ + +#include "notification_manager.h" +#include "ohos_timer.h" +#include "wearable_log.h" +#include +#include "main/MessageModel.h" + +namespace OHOS { +// 三方应用名 +static const uint32_t APP_NAME_POS_X = 180; +static const uint32_t APP_NAME_POS_Y = 82; +static const uint32_t APP_NAME_WIDTH = 200; +static const uint32_t APP_NAME_HEIGHT = 60; +// 三方消息主题 +static const uint32_t MSG_TITLE_POS_X = 81; +static const uint32_t MSG_TITLE_POS_Y = 122; +static const uint32_t MSG_TITLE_WIDTH = 409; +static const uint32_t MSG_TITLE_HEIGHT = 83; +// 三方消息内容 +static const uint32_t MSG_CONTENT_POS_X = 78; +static const uint32_t MSG_CONTENT_POS_Y = 176; +static const uint32_t MSG_CONTENT_WIDTH = 457; +static const uint32_t MSG_CONTENT_HEIGHT = 269; +// 取消通知 +static const uint32_t CANCEL_BUTTON_POS_X = 150; +static const uint32_t CANCEL_BUTTON_POS_Y = 323; +static const uint32_t CANCEL_BUTTON_WIDTH = 165; +static const uint32_t CANCEL_BUTTON_HEIGHT = 44; + +// 设置字体大小 +static const uint32_t APP_NAME_FONT_SIZE = 20; +static const uint32_t MSG_TITLE_FONT_SIZE = 20; +static const uint32_t MSG_CONTENT_FONT_SIZE = 40; + +UIViewGroup *PhoneMsgView::phoneMsgView_ = nullptr; +UILabel *PhoneMsgView::appNameLabel_ = nullptr; +UILabel *PhoneMsgView::titleLabel_ = nullptr; +UILabel *PhoneMsgView::contentLabel_ = nullptr; +GraphicTimer *PhoneMsgView::phoneMsgNotifyStop_ = nullptr; +PhoneMsg PhoneMsgView::phoneMsg_; +UILabelButtonExt *PhoneMsgView::cancelButton_ = nullptr; + +void PhoneMsgStopNotifyCallback(void *data) +{ + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "PhoneMsgStopNotifyCallback"); + (void)data; + NotificationManager::GetInstance()->StopNotify(); +} + +void PhoneMsgView::StartPhoneMsgTimer(int32_t interval) +{ + uint32_t tick = GetOSTick(interval); + phoneMsgNotifyStop_ = new GraphicTimer(tick, PhoneMsgStopNotifyCallback, nullptr, true); + phoneMsgNotifyStop_->Start(); +} + +void PhoneMsgView::DisablePhoneMsgTimer() +{ + if (phoneMsgNotifyStop_ != nullptr) { + phoneMsgNotifyStop_->Stop(); + delete phoneMsgNotifyStop_; + phoneMsgNotifyStop_ = nullptr; + } +} + +UIViewGroup *PhoneMsgView::CreatePhoneMsgView() +{ + if (phoneMsgView_ == nullptr) { + phoneMsgView_ = new UIViewGroup(); + phoneMsgView_->SetPosition(0, 0, Screen::GetInstance().GetWidth(), Screen::GetInstance().GetHeight()); + phoneMsgView_->SetViewId("phoneMsgView"); + } + + if (appNameLabel_ == nullptr) { + appNameLabel_ = new UILabel(); + } + appNameLabel_->SetPosition(APP_NAME_POS_X, APP_NAME_POS_Y, APP_NAME_WIDTH, APP_NAME_HEIGHT); + appNameLabel_->SetText(phoneMsg_.appName.c_str()); + appNameLabel_->SetFont(DEFAULT_VECTOR_FONT_FILENAME, APP_NAME_FONT_SIZE); + appNameLabel_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER); + // Add to rootView + phoneMsgView_->Add(appNameLabel_); + appNameLabel_->SetVisible(true); + + if (titleLabel_ == nullptr) { + titleLabel_ = new UILabel(); + } + titleLabel_->SetPosition(MSG_TITLE_POS_X, MSG_TITLE_POS_Y, MSG_TITLE_WIDTH, MSG_TITLE_HEIGHT); + titleLabel_->SetText(phoneMsg_.msgTitle.c_str()); + titleLabel_->SetFont(DEFAULT_VECTOR_FONT_FILENAME, MSG_TITLE_FONT_SIZE); + titleLabel_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER); + // Add to rootView + phoneMsgView_->Add(titleLabel_); + titleLabel_->SetVisible(true); + + if (contentLabel_ == nullptr) { + contentLabel_ = new UILabel(); + } + contentLabel_->SetPosition(MSG_CONTENT_POS_X, MSG_CONTENT_POS_Y, MSG_CONTENT_WIDTH, MSG_CONTENT_HEIGHT); + contentLabel_->SetText(phoneMsg_.msgContent.c_str()); + contentLabel_->SetFont(DEFAULT_VECTOR_FONT_FILENAME, MSG_CONTENT_FONT_SIZE); + contentLabel_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER); + // Add to rootView + phoneMsgView_->Add(contentLabel_); + contentLabel_->SetVisible(true); + + if (cancelButton_ == nullptr) { + cancelButton_ = new UILabelButtonExt(); + } + cancelButton_->SetPosition(CANCEL_BUTTON_POS_X, CANCEL_BUTTON_POS_Y, CANCEL_BUTTON_WIDTH, CANCEL_BUTTON_HEIGHT); + cancelButton_->SetViewId("cancelButton"); + cancelButton_->SetText("取消通知"); + cancelButton_->SetTouchable(true); + cancelButton_->SetFont(DEFAULT_VECTOR_FONT_FILENAME, APP_NAME_FONT_SIZE); + // Add to rootView + phoneMsgView_->Add(cancelButton_); + + phoneMsgView_->SetDraggable(true); + phoneMsgView_->SetTouchable(true); + UIView::OnDragListener *dragListener = + static_cast(PhoneMsgViewEventListener::GetInstance()); + UIView::OnClickListener *clickListener = + static_cast(PhoneMsgViewEventListener::GetInstance()); + phoneMsgView_->SetOnDragListener(dragListener); + phoneMsgView_->SetOnClickListener(clickListener); + cancelButton_->SetOnClickListener(clickListener); + StartPhoneMsgTimer(PhoneMsgView::notifyTime); + NotificationManager::GetInstance()->RegisterNotifyCleanupFunction(FreePhoneMsgView); + return phoneMsgView_; +} + +void PhoneMsgView::FreePhoneMsgView(void) +{ + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "FreePhoneMsgView"); + if (phoneMsgView_ != nullptr) { + DisablePhoneMsgTimer(); + phoneMsgView_->RemoveAll(); + delete appNameLabel_; + appNameLabel_ = nullptr; + delete titleLabel_; + titleLabel_ = nullptr; + delete contentLabel_; + contentLabel_ = nullptr; + delete cancelButton_; + cancelButton_ = nullptr; + RootView::GetInstance()->Remove(phoneMsgView_); + delete phoneMsgView_; + phoneMsgView_ = nullptr; + } +} + +void PhoneMsgView::UpDatePhoneMsg(std::string appName, std::string titile, std::string content) +{ + phoneMsg_.appName = appName; + phoneMsg_.msgTitle = titile; + phoneMsg_.msgContent = content; + MessageModel::GetInstance().GetMessageInfo(appName, titile, content); +} + +PhoneMsgViewEventListener::PhoneMsgViewEventListener() +{ + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "PhoneMsgViewEventListener :%p", this); +} + +PhoneMsgViewEventListener::~PhoneMsgViewEventListener() +{ + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "~PhoneMsgViewEventListener"); +} + +PhoneMsgViewEventListener *PhoneMsgViewEventListener::GetInstance(void) +{ + static PhoneMsgViewEventListener phoneMsgViewEventListener; + return &phoneMsgViewEventListener; +} + +bool PhoneMsgViewEventListener::OnDrag(UIView &view, const DragEvent &event) +{ + return true; +} + +bool PhoneMsgViewEventListener::OnDragEnd(UIView &view, const DragEvent &event) +{ + std::string viewId = view.GetViewId(); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "PhoneMsgViewEventListener OnDragEnd %s", viewId.c_str()); + if (viewId == "phoneMsgView") { + NotificationManager::GetInstance()->StopNotify(); + } + return true; +} + +bool PhoneMsgViewEventListener::OnClick(UIView &view, const ClickEvent &event) +{ + UNUSED(event); + std::string viewId = view.GetViewId(); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "PhoneMsgViewEventListener ClickListener %s", viewId.c_str()); + if (viewId == "phoneMsgView") { + NotificationManager::GetInstance()->StopNotify(); + } + return true; +} +} // namespace OHOS \ No newline at end of file diff --git a/code/sdk/application/wearable/fd230/service/power_manager/src/actions/display_action.c b/code/sdk/application/wearable/fd230/service/power_manager/src/actions/display_action.c index ff369683c..f869cf3a0 100644 --- a/code/sdk/application/wearable/fd230/service/power_manager/src/actions/display_action.c +++ b/code/sdk/application/wearable/fd230/service/power_manager/src/actions/display_action.c @@ -23,7 +23,7 @@ #include "nandflash_to_os.h" #endif #ifdef SUPPORT_OHOSFWK -#include "ui_screennotify.h" +#include "screennotify/ui_screennotify.h" #endif #include "sys/time.h" #include "touch_screen_def.h" diff --git a/code/sdk/application/wearable/fd230/service/power_manager/src/filters/gui_event_filter.c b/code/sdk/application/wearable/fd230/service/power_manager/src/filters/gui_event_filter.c index 334b4adb9..1df196eb3 100644 --- a/code/sdk/application/wearable/fd230/service/power_manager/src/filters/gui_event_filter.c +++ b/code/sdk/application/wearable/fd230/service/power_manager/src/filters/gui_event_filter.c @@ -47,7 +47,18 @@ static input_action_t filter_gui_execute_touch_event(screen_context_t *current, ac = TURN_OFF_SCREEN; } } else { - ac = TURN_ON_SCREEN; + if (sc->enable_aod) { + if (sc->current_state == SCREEN_AMBIENT) { + // The driver needs to implement the logic for reporting these events. + if (event == MC_TP_SHORT_CLICK || event == MC_TP_DOUBLE_CLICK) { + ac = TURN_ON_SCREEN; + } + } else { + ac = TURN_ON_SCREEN; + } + } else { + ac = TURN_ON_SCREEN; + } } POWER_DISPLAY_PRINT_DEBUG(0, "filter_gui_execute_touch_event,ac:%u.", ac); return ac; diff --git a/code/sdk/application/wearable/fd230/service/remote_msg/CMakeLists.txt b/code/sdk/application/wearable/fd230/service/remote_msg/CMakeLists.txt new file mode 100644 index 000000000..f8e5abb7a --- /dev/null +++ b/code/sdk/application/wearable/fd230/service/remote_msg/CMakeLists.txt @@ -0,0 +1,37 @@ +set(COMPONENT_NAME "remote_msg") + +set(PUBLIC_HEADER +) + +set(PRIVATE_HEADER + ${ROOT_DIR}/middleware/services/gui/uikit/utils/interfaces/innerkits + ${ROOT_DIR}/middleware/services/gui/uikit/utils/interfaces/kits +) + +set(SOURCES + ${CMAKE_CURRENT_SOURCE_DIR}/remote_msg.cpp +) + +set(COMPONENT_PUBLIC_CCFLAGS +) + +set(COMPONENT_CCFLAGS + -std=c++11 + -Wno-missing-field-initializers +) + +set(WHOLE_LINK + true +) + +set(PUBLIC_DEFINES +) + +set(PRIVATE_DEFINES + APP_PLATFORM_WATCHGT + CONFIG_ACELITE_ENABLE +) + +build_component() + + diff --git a/code/sdk/application/wearable/fd230/service/remote_msg/remote_msg.cpp b/code/sdk/application/wearable/fd230/service/remote_msg/remote_msg.cpp new file mode 100644 index 000000000..a33965430 --- /dev/null +++ b/code/sdk/application/wearable/fd230/service/remote_msg/remote_msg.cpp @@ -0,0 +1,73 @@ +/* + * Copyright (c) CompanyNameMagicTag 2023-2023. All rights reserved. + * Description: ota upgrade handle. + * This file should be changed only infrequently and with great care. + */ +#include +#include "securec.h" +#include "msg_center.h" +#include "msg_center_protocol.h" +#include "msg_center_cmd.h" +#include "wearable_log.h" +#include "securec.h" +#include "msg_center.h" +#include "msg_center_common.h" +#include "ohos_init.h" +#include "remote_msg.h" +#ifdef __cplusplus +extern "C" { +#endif + +static const msg_center_cmd_map_t g_msg_center_phone_msg_tbl[] = { + {MSGCENTER_CMD_PHONE_MSG, MSGCENTER_TYPE_ID_MSG_THIRD_APP, msg_center_phone_msg_rec}, + {MSGCENTER_CMD_PHONE_MSG, MSGCENTER_TYPE_ID_MSG_SMS, msg_center_phone_msg_rec}, + {MSGCENTER_CMD_PHONE_MSG, MSGCENTER_TYPE_ID_MSG_PHONE, msg_center_phone_msg_rec}, +}; + +errcode_t msg_center_phone_msg_rec(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data); + uint16_t payload_len = usr_len - tl_len; + uint8_t *tlv_payload = (uint8_t *)msg_center_get_tlv_payload(usr_data); + errcode_t ret = ERRCODE_SUCC; + uint8_t msg_result = 0; + WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "msg_center_phone_msg_rec, cmd_id = %d, type = %d\r\n", cmd_id, type); + Request request; + request.msgId = type; + request.len = payload_len; + request.data = tlv_payload; + MsgCenterNotifyProc(TOPIC_DEMO_ALL_MSG, &request); + ret = msg_center_send_data(cmd_id, type, &msg_result, sizeof(msg_result)); + if (ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "phone msg_result fail, ret = %d\r\n", ret); + return ERRCODE_FAIL; + } + return ERRCODE_SUCC; +} + +errcode_t msg_center_phone_msg_type_dispatch(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) +{ + WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "msg_center_phone_msg_type_dispatch, cmd_id = %d, type = %d\r\n", + cmd_id, type); + uint8_t tbl_size = sizeof(g_msg_center_phone_msg_tbl) / sizeof(g_msg_center_phone_msg_tbl[0]); + uint8_t i; + for (i = 0; i < tbl_size; i++) { + msg_center_cmd_map_t *item = (msg_center_cmd_map_t *)&g_msg_center_phone_msg_tbl[i]; + if ((item->type == type) && (item->handler != NULL)) { + item->handler(cmd_id, type, usr_data, usr_len); + return ERRCODE_SUCC; + } + } + return ERRCODE_NOT_SUPPORT; +} + +void phone_msg_init(void) +{ + msg_center_register_cmd(MSGCENTER_CMD_PHONE_MSG, msg_center_phone_msg_type_dispatch); +} + +APP_FEATURE_INIT_PRI(phone_msg_init, LAYER_INIT_LEVEL_4); + +#ifdef __cplusplus +} +#endif \ No newline at end of file diff --git a/code/sdk/application/wearable/fd230/service/remote_msg/remote_msg.h b/code/sdk/application/wearable/fd230/service/remote_msg/remote_msg.h new file mode 100644 index 000000000..2787377ff --- /dev/null +++ b/code/sdk/application/wearable/fd230/service/remote_msg/remote_msg.h @@ -0,0 +1,33 @@ +/* + * Copyright (c) CompanyNameMagicTag 2021-2021. All rights reserved. + * Description: third application message + * Author: CompanyName + * Create: 2021-11-11 + */ + +#ifndef REMOTE_MSG_H +#define REMOTE_MSG_H + +#include "msg_center_protocol.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif + +typedef enum msg_center_phone_msg_type_id { + MSGCENTER_TYPE_ID_MSG_THIRD_APP = 0x1, // 三方应用消息 + MSGCENTER_TYPE_ID_MSG_SMS, // 短信 + MSGCENTER_TYPE_ID_MSG_PHONE, // 电话 + MSGCENTER_TYPE_ID_MSG_MAX, +} msg_center_msg_notify_type_id_t; + +errcode_t msg_center_phone_msg_rec(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif +#endif /* REMOTE_MSG_H */ \ No newline at end of file diff --git a/code/sdk/application/wearable/fd230/service/xiaodu_voice/xiaodu_voice.cpp b/code/sdk/application/wearable/fd230/service/xiaodu_voice/xiaodu_voice.cpp index 6ca6ae711..9e88a4365 100644 --- a/code/sdk/application/wearable/fd230/service/xiaodu_voice/xiaodu_voice.cpp +++ b/code/sdk/application/wearable/fd230/service/xiaodu_voice/xiaodu_voice.cpp @@ -20,6 +20,9 @@ #include "watchdog.h" #include "js_ability.h" #include "recording_module.h" +#ifdef CONFIG_BRANDY_BLE_TRANS_OPTIMIZE +#include "bluetooth/BluetoothChangeBle.h" +#endif #ifdef __cplusplus extern "C" { @@ -62,6 +65,43 @@ static void pcm_stream_del_queue(void) return; } +static errcode_t send_pcm_stream_data(pcm_stream_queue_msg msg) +{ + uint8_t retry_cnt = 100; + uint8_t msg_send_delay = 10; + errcode_t res; + + while (retry_cnt--) { + if (msg.msg_id == MSGCENTER_TYPE_ID_XIAODU_SEND_PCM_STREAM) { + res = msg_center_xiaodu_send_pcm_stream(MSGCENTER_CMD_XIAODU, MSGCENTER_TYPE_ID_XIAODU_SEND_PCM_STREAM, + msg.data, msg.len); + } else if (msg.msg_id == MSGCENTER_TYPE_ID_XIAODU_END_RECORD) { + res = msg_center_xiaodu_send_end_record(MSGCENTER_CMD_XIAODU, MSGCENTER_TYPE_ID_XIAODU_END_RECORD, msg.data, + msg.len); +#ifdef CONFIG_BRANDY_BLE_TRANS_OPTIMIZE + ChangeBleConnectToDefault(); +#endif + } + + if (res != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "send stream fail, retry_cnt: %d, type = %d\n", retry_cnt, + msg.msg_id); + osDelay(msg_send_delay); + } else { + break; + } + } + free(msg.data); + msg.data = nullptr; + if (res != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "after retry, send stream still fail, retry_cnt: %d, type = %d\n", + retry_cnt, msg.msg_id); + pcm_stream_del_queue(); + return ERRCODE_FAIL; + } + return ERRCODE_SUCC; +} + static errcode_t pcm_stream_task_body(void *data) { UNUSED(data); @@ -75,39 +115,22 @@ static errcode_t pcm_stream_task_body(void *data) } g_pcm_stream_end_record_sended_flag = false; +#ifdef CONFIG_BRANDY_BLE_TRANS_OPTIMIZE + ChangeBleConnectToMax(); +#endif for (;;) { osStatus_t ret = osMessageQueueGet(g_pcm_stream_msg_queue_id, &msg, nullptr, osWaitForever); if (ret != osOK) { - msg.msg_id = MSGCENTER_TYPE_ID_XIAODU_END_RECORD; - msg.data = nullptr; + continue; } - if (msg.msg_id == MSGCENTER_TYPE_ID_XIAODU_SEND_PCM_STREAM) { - res = msg_center_xiaodu_send_pcm_stream(MSGCENTER_CMD_XIAODU, MSGCENTER_TYPE_ID_XIAODU_SEND_PCM_STREAM, - msg.data, msg.len); - free(msg.data); - msg.data = nullptr; - if (res != ERRCODE_SUCC) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "send pcm stream failed"); - pcm_stream_del_queue(); - return ERRCODE_FAIL; - } - } else if (msg.msg_id == MSGCENTER_TYPE_ID_XIAODU_END_RECORD) { - res = msg_center_xiaodu_send_end_record(MSGCENTER_CMD_XIAODU, MSGCENTER_TYPE_ID_XIAODU_END_RECORD, msg.data, - msg.len); - free(msg.data); - msg.data = nullptr; - if (res != ERRCODE_SUCC) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "send pcm end failed"); - pcm_stream_del_queue(); - return ERRCODE_FAIL; - } - g_pcm_stream_end_record_sended_flag = true; - return ERRCODE_SUCC; + + /* pcm帧、end帧合并处理 */ + res = send_pcm_stream_data(msg); + if (res == ERRCODE_FAIL || (res == ERRCODE_SUCC && msg.msg_id == MSGCENTER_TYPE_ID_XIAODU_END_RECORD)) { + return res; } } - - return ERRCODE_SUCC; } /* @@ -163,7 +186,6 @@ errcode_t pcm_stream_create_task(void) errcode_t msg_center_xiaodu_start(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len) { - unused(usr_data); uint8_t ack = 1; errcode_t ret = ERRCODE_SUCC; @@ -174,16 +196,21 @@ errcode_t msg_center_xiaodu_start(uint8_t cmd_id, uint8_t type, void *usr_data, } display_api->set_screen_set_keepon_timeout(30000); // 30000ms #endif -#ifdef JS_ENABLE - StartJsApp("com.vendor.voiceassistant"); -#endif /* ack */ ret = msg_center_send_data(cmd_id, type, &ack, sizeof(ack)); if (ret != ERRCODE_SUCC) { return ERRCODE_FAIL; } + uint8_t *tlv_payload = (uint8_t *)msg_center_get_tlv_payload(usr_data); +#ifdef JS_ENABLE + if(tlv_payload[0] == 1) { + StartJsApp("com.vendor.Aidialogue"); + } else { + StartJsApp("com.vendor.Aidial"); + } +#endif return ERRCODE_SUCC; } @@ -407,6 +434,7 @@ errcode_t msg_center_xiaodu_send_end_record(uint8_t cmd_id, uint8_t type, void * WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "send pcm stream end, usr_data = %d, usr_len = %d\r\n", *(uint8_t *)usr_data, usr_len); /* usr_data参考协议msg_center_pcm_end_flag_t */ pcm_stream_del_queue(); + g_pcm_stream_end_record_sended_flag = true; return ERRCODE_SUCC; } diff --git a/code/sdk/application/wearable/fd230/service/xiaodu_voice/xiaodu_voice_msg.cpp b/code/sdk/application/wearable/fd230/service/xiaodu_voice/xiaodu_voice_msg.cpp index ebe9e4086..1d3047a54 100644 --- a/code/sdk/application/wearable/fd230/service/xiaodu_voice/xiaodu_voice_msg.cpp +++ b/code/sdk/application/wearable/fd230/service/xiaodu_voice/xiaodu_voice_msg.cpp @@ -3,6 +3,9 @@ #include "msg_center_protocol.h" #include "msg_center_cmd.h" #include "ohos_init.h" +#include "msg_center_common.h" +#include "wearable_log.h" + namespace OHOS { #ifdef __cplusplus