#include "PhoneService.h"
#include "PhoneAudio.h"
#include "securec.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
#include "audio_base_type.h"
#include "audio_manager.h"
-#include "time.h"
+#include <ctime>
#include "wearable_log.h"
#include "unistd.h"
#include "dirent.h"
#include "service_id_define.h"
#include "samgr_lite.h"
#include "ui_service.h"
+#include "msg_center_msg.h"
#include "cat1_server_hal.h"
-#if defined(SUPPORT_POWER_MANAGER)
-#include "power_display_service.h"
-#endif
#ifdef __cplusplus
extern "C" {
#endif
static void PhoneServiceScreenCtr(bool turnOnFlag)
{
-#if defined(SUPPORT_POWER_MANAGER)
- const power_display_svr_api_t *display_api = power_display_svr_get_api();
if (turnOnFlag) {
- if (display_api->get_screen_state() != SCREEN_ON) {
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[PhoneServiceScreenCtr] turn_on_screen");
- display_api->turn_on_screen();
- }
- display_api->set_screen_set_keepon_timeout(-1);
+ int32_t timeout = -1;
+ SendMsgToUIService(SCREEN_TURN_ON_TO_UI, 0, &timeout, sizeof(int32_t));
} else {
- display_api->set_screen_set_keepon_timeout(0);
+ SendMsgToUIService(SCREEN_TURN_OFF_TO_UI, 0, nullptr, 0);
}
-#endif
}
static void InitMutex(void)
int RegisterCallChangedCb(PhoneServiceCb *phoneServiceFun)
{
- if (phoneServiceFun == NULL) {
+ if (phoneServiceFun == nullptr) {
return OHOS_FAILURE;
}
// 初始化媒体
static void AudioInit(void)
{
- int ret;
- ret = PhoneAudioManagerInit();
+ int32_t ret = PhoneAudioManagerInit();
if (ret != OHOS_SUCCESS) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioInit] [PhoneAudioManagerInit] failed!");
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioInit] failed!");
}
}
// 释放音频焦点
static void AudioDeactInterrupt(AudioStreamType type)
{
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[AudioDeactInterrupt] start type: 0x%x, g_audioState: 0x%x",
- type, g_audioState);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[AudioDeactInterrupt] start type:0x%x, audioState:0x%x",
+ type, g_audioState);
if ((type == AUDIO_STREAM_VOICE_CALL_BT_SCO && g_audioState >= AUDIO_ACT_INTERRUPT_BT_SCO) ||
(type == AUDIO_STREAM_RING && g_audioState == AUDIO_ACT_INTERRUPT_WATCH_RING)) {
{
int ret = OHOS_SUCCESS;
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[AudioActInterrupt] start type: 0x%x, g_audioState: 0x%x",
- type, g_audioState);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[AudioActInterrupt] start type:0x%x, audioState:0x%x",
+ type, g_audioState);
if (type != AUDIO_STREAM_VOICE_CALL_BT_SCO && type != AUDIO_STREAM_RING) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioActInterrupt] failed! type: 0x%x, g_audioState: 0x%x",
- type, g_audioState);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioActInterrupt] failed! type:0x%x, audioState:0x%x",
+ type, g_audioState);
return;
}
}
if (ret != OHOS_SUCCESS) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioActInterrupt] failed! type: 0x%x, g_audioState: 0x%x",
- type, g_audioState);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioActInterrupt] failed! type:0x%x, audioState:0x%x",
+ type, g_audioState);
}
MUTEX_Unlock(g_audioMutex);
{
int ret;
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[AudioConnectScoDevInit] start g_scoFlag: 0x%x, g_audioState: 0x%x",
- g_scoFlag, g_audioState);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[AudioConnectScoDevInit] start scoFlag:0x%x, audioState:0x%x",
+ g_scoFlag, g_audioState);
if (g_scoFlag != HFP_SCO_STATE_CONNECTED || g_audioState < AUDIO_ACT_INTERRUPT_BT_SCO) {
return;
}
// 配置媒体连接SCO设配状态（下行），只有在SCO连接后才能设置
ret = PhoneAudioManagerSetDeviceConnState(IN_BLUETOOTH_SCO, AUDIO_DEVICE_CONNECTED);
if (ret != OHOS_SUCCESS) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioConnectScoDevInit] [PhoneAudioManagerSetDeviceConnState] \
- IN_BLUETOOTH_SCO failed! ret = %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioConnectScoDevInit] sco in ret:%d", ret);
MUTEX_Unlock(g_audioMutex);
return;
} else {
// 配置媒体连接SCO设配状态（上行），只有在SCO连接后才能设置
ret = PhoneAudioManagerSetDeviceConnState(OUT_BLUETOOTH_SCO, AUDIO_DEVICE_CONNECTED);
if (ret != OHOS_SUCCESS) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioConnectScoDevInit] [PhoneAudioManagerSetDeviceConnState] \
- OUT_BLUETOOTH_SCO failed! ret = %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioConnectScoDevInit] sco out ret:%d", ret);
MUTEX_Unlock(g_audioMutex);
return;
} else {
g_audioState = AUDIO_STREAM_INIT;
}
}
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[AudioConnectScoDevInit] end g_audioState: %d, g_hdlUpSco: %d, g_hdlDnSco: %d",
- g_audioState, g_hdlUpSco, g_hdlDnSco);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[AudioConnectScoDevInit] end audioState:%d, hdlUpSco:%d, hdlDnSco:%d",
+ g_audioState, g_hdlUpSco, g_hdlDnSco);
MUTEX_Unlock(g_audioMutex);
return;
int ret = OHOS_SUCCESS;
uint32 micShmId = 0;
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[AudioUpStart] start g_scoFlag: %d, g_audioState: %d", g_scoFlag, g_audioState);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[AudioUpStart] start scoFlag:%d, audioState:%d", g_scoFlag, g_audioState);
if (g_scoFlag != HFP_SCO_STATE_CONNECTED || g_audioState < AUDIO_STREAM_INIT) {
return;
g_hdlUpMic = PhoneAudioStreamInInit(AUDIO_UP_LINK);
}
- if (g_audioState < AUDIO_STREAM_START_SCO) {
+ if (g_audioState < AUDIO_STREAM_START_SCO) {
ret = PhoneAudioStreamInStart(g_hdlDnSco);
if (ret != OHOS_SUCCESS) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioUpStart] [AudioStreamInStart] [dn_sco] error! ret: %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioUpStart] dn_sco ret:%d", ret);
}
ret |= PhoneAudioStreamOutStart(g_hdlUpSco);
if (ret != OHOS_SUCCESS) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioUpStart] [AudioStreamOutStart] [up_sco] error ret: %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioUpStart] up_sco ret:%d", ret);
}
if (ret == OHOS_SUCCESS) {
g_audioState = AUDIO_STREAM_START_SCO;
ret |= PhoneAudioStreamInStart(g_hdlUpMic);
if (ret != OHOS_SUCCESS) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioUpStart] [PhoneAudioStreamInStart] [up_mic] error! ret = %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioUpStart] up_mic ret:%d", ret);
}
ret |= PhoneAudioStreamInGetChannelId(g_hdlUpMic, &micShmId);
if (ret != OHOS_SUCCESS) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioUpStart] [AudioStreamInGetChannelId] [up_mic] error ret: %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioUpStart] up_mic shm ret:%d", ret);
}
ret |= PhoneAudioStreamOutAttachFrontend(g_hdlUpSco, micShmId);
if (ret != OHOS_SUCCESS) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioUpStart] [AudioStreamOutAttachFrontend] [up_sco] error ret:%d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioUpStart] up_sco attach ret:%d", ret);
}
if (ret == OHOS_SUCCESS) {
g_audioState = AUDIO_STREAM_START_UP;
}
}
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[AudioUpStart] end g_audioState:%d, g_hdlUpMic:%d, g_hdlUpSco:%d, micShmId:0x%x",
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[AudioUpStart] end audioState:%d, hdlUpMic:%d, hdlUpSco:%d, micShmId:0x%x",
g_audioState, g_hdlUpMic, g_hdlUpSco, micShmId);
MUTEX_Unlock(g_audioMutex);
return;
int ret = OHOS_SUCCESS;
uint32 spkShmId = 0;
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[AudioDnStart] start g_scoFlag: %d, g_audioState: %d", g_scoFlag, g_audioState);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[AudioDnStart] start scoFlag:%d, audioState:%d", g_scoFlag, g_audioState);
if (g_scoFlag != HFP_SCO_STATE_CONNECTED || g_audioState < AUDIO_STREAM_INIT) {
return;
if (g_audioState < AUDIO_STREAM_START_SCO) {
ret = PhoneAudioStreamOutStart(g_hdlUpSco);
if (ret != OHOS_SUCCESS) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioDnStart] [AudioStreamOutStart] [up_sco] error! ret = %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioDnStart] up_sco ret:%d", ret);
}
ret |= PhoneAudioStreamInStart(g_hdlDnSco);
if (ret != OHOS_SUCCESS) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioDnStart] [AudioStreamInStart] [dn_sco] error! ret = %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioDnStart] dn_sco ret:%d", ret);
}
if (ret == OHOS_SUCCESS) {
ret |= PhoneAudioStreamOutStart(g_hdlDnSpk);
if (ret != OHOS_SUCCESS) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioDnStart] [PhoneAudioStreamOutStart] [dn_spk] error! ret = %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioDnStart] dn_spk ret:%d", ret);
}
ret |= PhoneAudioStreamOutGetChannelId(g_hdlDnSpk, &spkShmId);
if (ret != OHOS_SUCCESS) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioDnStart] [AudioStreamOutGetChannelId] [dn_spk] error ret: %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioDnStart] dn_spk shm ret:%d", ret);
}
ret |= PhoneAudioStreamInAttachBackend(g_hdlDnSco, spkShmId);
if (ret != OHOS_SUCCESS) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioDnStart] [AudioStreamInAttachBackend] [dn_sco] error ret: %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioDnStart] dn_sco attach ret:%d", ret);
}
if (ret == OHOS_SUCCESS) {
g_audioState = AUDIO_STREAM_START_DN;
}
}
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[AudioDnStart] end g_audioState:%d, g_hdlDnSpk:%d, g_hdlDnSco:%d, spkShmId: 0x%x",
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[AudioDnStart] end audioState:%d, hdlDnSpk:%d, hdlDnSco:%d, spkShmId:0x%x",
g_audioState, g_hdlDnSpk, g_hdlDnSco, spkShmId);
MUTEX_Unlock(g_audioMutex);
// 蓝牙通话下行
static void AudioDn(void)
{
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[AudioDn] start g_audioState: %d", g_audioState);
-
// 申请蓝牙通话音频焦点
AudioActInterrupt(AUDIO_STREAM_VOICE_CALL_BT_SCO);
AudioDnStart();
if (g_audioState == AUDIO_STREAM_START_DN) {
// 同步音量
- PostGraphicEvent(SyncVolume);
+ SyncVolume();
}
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[AudioDn] end g_audioState: %d", g_audioState);
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[AudioDn] audioState:%d", g_audioState);
}
// 蓝牙通话上行
static void AudioUp(void)
{
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[AudioUp] start g_audioState: %d", g_audioState);
-
// 申请蓝牙通话音频焦点
AudioActInterrupt(AUDIO_STREAM_VOICE_CALL_BT_SCO);
// 建立音频上行通路
AudioUpStart();
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[AudioUp] end g_audioState: %d", g_audioState);
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[AudioUp] audioState:%d", g_audioState);
+}
+static void AudioSetup(void)
+{
+ if (g_audioState < AUDIO_STREAM_START_DN) {
+ AudioDn();
+ }
+
+ if (g_audioState != AUDIO_STREAM_START_UP) {
+ AudioUp();
+ }
}
static void AudioUpRelease(void)
if (g_hdlUpSco != INVALID_PHONE_SERVICE_VALUE) {
ret = PhoneAudioStreamOutStop(g_hdlUpSco);
if (ret != OHOS_SUCCESS) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioUpRelease] [OutStop] g_hdlUpSco error! ret = %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioUpRelease] [OutStop] hdlUpSco ret:%d", ret);
}
ret = PhoneAudioStreamOutDeinit(g_hdlUpSco);
if (ret != OHOS_SUCCESS) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioUpRelease] [OutDeinit] g_hdlUpSco error! ret = %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioUpRelease] [OutDeinit] hdlUpSco ret:%d", ret);
}
}
if (g_hdlUpMic != INVALID_PHONE_SERVICE_VALUE) {
ret = PhoneAudioStreamInStop(g_hdlUpMic);
if (ret != OHOS_SUCCESS) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioDnRelease] [InStop] g_hdlUpMic error! ret = %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioDnRelease] [InStop] hdlUpMic ret:%d", ret);
}
ret = PhoneAudioStreamInDeinit(g_hdlUpMic);
if (ret != OHOS_SUCCESS) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioDnRelease] [InDeinit] g_hdlUpMic error! ret = %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioDnRelease] [InDeinit] hdlUpMic ret:%d", ret);
}
}
if (g_audioState >= AUDIO_CONN_OUT_BT_SCO) {
ret = PhoneAudioManagerSetDeviceConnState(OUT_BLUETOOTH_SCO, AUDIO_DEVICE_DISCONNECTED);
if (ret != OHOS_SUCCESS) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioDnRelease] OUT_BLUETOOTH_SCO error! ret = %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioDnRelease] sco out ret:%d", ret);
}
}
g_hdlUpSco = INVALID_PHONE_SERVICE_VALUE;
g_hdlUpMic = INVALID_PHONE_SERVICE_VALUE;
-
}
static void AudioDnRelease(void)
if (g_hdlDnSco != INVALID_PHONE_SERVICE_VALUE) {
ret = PhoneAudioStreamInStop(g_hdlDnSco);
if (ret != OHOS_SUCCESS) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioUpRelease] [InStop] g_hdlDnSco error! ret = %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioUpRelease] [InStop] hdlDnSco ret:%d", ret);
}
ret = PhoneAudioStreamInDeinit(g_hdlDnSco);
if (ret != OHOS_SUCCESS) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioUpRelease] [InDeinit] g_hdlDnSco error! ret = %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioUpRelease] [InDeinit] hdlDnSco ret:%d", ret);
}
}
if (g_hdlDnSpk != INVALID_PHONE_SERVICE_VALUE) {
ret = PhoneAudioStreamOutStop(g_hdlDnSpk);
if (ret != OHOS_SUCCESS) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioDnRelease] [OutStop] g_hdlDnSpk error! ret = %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioDnRelease] [OutStop] hdlDnSpk ret:%d", ret);
}
ret = PhoneAudioStreamOutDeinit(g_hdlDnSpk);
if (ret != OHOS_SUCCESS) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioDnRelease] [OutDeinit] g_hdlDnSpk error! ret = %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioDnRelease] [OutDeinit] hdlDnSpk ret:%d", ret);
}
}
if (g_audioState >= AUDIO_CONN_IN_BT_SCO) {
ret = PhoneAudioManagerSetDeviceConnState(IN_BLUETOOTH_SCO, AUDIO_DEVICE_DISCONNECTED);
if (ret != OHOS_SUCCESS) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioDnRelease] IN_BLUETOOTH_SCO error! ret = %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioDnRelease] sco in ret:%d", ret);
}
}
AudioDeactInterrupt(AUDIO_STREAM_RING); // 适配某些机型不触发SCO
g_audioState = AUDIO_UNKNOW;
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[AudioRelease] end g_audioState: %d,", g_audioState);
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[AudioRelease] audioState:%d,", g_audioState);
MUTEX_Unlock(g_audioMutex);
}
PhoneServiceErrorCallback(ERROR_BT, PROFILE_STATE_DISCONNECTED);
CallListInit();
- // 释放媒体资源
- PostGraphicEvent(AudioRelease);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "BtDisconnectedPro callState:%d", g_currCallState);
+ if (g_currCallState == HFP_HF_CALL_STATE_INCOMING) {
+ /* 处理呼入阶段，取消手表配对 */
+ hfp_hf_calls_info_t call = {0};
+ HfpIncomingEventPublish(TOPIC_EVENT_HFP_FINISHED, call);
+ }
+
g_currCallState = HFP_HF_CALL_STATE_FINISHED;
g_scoFlag = HFP_SCO_STATE_DISCONNECTED;
g_completeCallFlag = false;
// 蓝牙状态连接
static void ConnStateChanged(const bd_addr_t *bdAddr, profile_connect_state_t state)
{
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[ConnStateChanged] state = 0x%X bdAddr: ", state);
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[ConnStateChanged] state = 0x%X bdAddr: ", state);
CatBdAddr(bdAddr);
- if (state == PROFILE_STATE_CONNECTED) {
- SendMsgToUIService(BT_CONNECTED_TO_UI, 0, NULL, 0);
- } else if (state == PROFILE_STATE_DISCONNECTED) {
- SendMsgToUIService(BT_DISCONNECTED_TO_UI, 0, NULL, 0);
- }
-
switch (state) {
case PROFILE_STATE_CONNECTING: // 蓝牙正在连接
WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[ConnStateChanged] BT connecting");
case PROFILE_STATE_CONNECTED: // 蓝牙连接成功
WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[ConnStateChanged] BT connected");
BtConnectedPro(bdAddr);
+ SendMsgToUIService(BT_CONNECTED_TO_UI, 0, nullptr, 0);
+ SendMsgToMsgCenterService(BT_CONNECTED_TO_MSGCENTER, 0, nullptr, 0);
break;
case PROFILE_STATE_DISCONNECTING: // 蓝牙连接断连
WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[ConnStateChanged] BT disconnecting");
case PROFILE_STATE_DISCONNECTED: // 蓝牙断开连接
WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[ConnStateChanged] BT disconnected");
BtDisconnectedPro();
+ SendMsgToUIService(BT_DISCONNECTED_TO_UI, 0, nullptr, 0);
+ SendMsgToMsgCenterService(BT_DISCONNECTED_TO_MSGCENTER, 0, nullptr, 0);
break;
default:
break;
// SCO连接处理
static void ScoConnectPro(void)
{
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[ScoConnectPro] g_currCallNum = %d, g_scoFlag = %d", g_currCallNum, g_scoFlag);
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[ScoConnectPro] CallNum:%d, ScoFlag:%d", g_currCallNum, g_scoFlag);
// 通知sco建立连接(或通话转移：手机 -> 手表)
ScoStatusCb(HFP_SCO_STATE_CONNECTED);
if (g_currCallState == HFP_HF_CALL_STATE_ACTIVE && g_scoFlag == HFP_SCO_STATE_CONNECTED) {
hfp_hf_calls_info_t call = {0};
HfpIncomingEventPublish(TOPIC_EVENT_HFP_PHONE_TO_WATCH, call);
}
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[ScoConnectPro] g_audioState: %d ", g_audioState);
-
- if (g_audioState < AUDIO_STREAM_START_DN) {
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[ScoConnectPro] post AudioDn");
- PostGraphicEvent(AudioDn);
- }
-
- if (g_audioState != AUDIO_STREAM_START_UP) {
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[ScoConnectPro] post AudioUp");
- PostGraphicEvent(AudioUp);
- }
+ PostGraphicEvent(AudioSetup);
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[ScoConnectPro] audioState:%d", g_audioState);
}
// SCO断连处理
static void ScoDisconnectPro(void)
{
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[ScoDisconnectPro] start g_currCallState = %d", g_currCallState);
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[ScoDisconnectPro] start CallState:%d", g_currCallState);
- // 通知sco断开连接（或通话转移：手表 -> 手机）
- if (g_currCallState != HFP_HF_CALL_STATE_INCOMING) {
- ScoStatusCb(HFP_SCO_STATE_DISCONNECTED);
- }
+ ScoStatusCb(HFP_SCO_STATE_DISCONNECTED);
if (g_currCallState == HFP_HF_CALL_STATE_ACTIVE && g_scoFlag == HFP_SCO_STATE_DISCONNECTED) {
// The call is transferred from the watch to the phone. Need to close the call notification view.
hfp_hf_calls_info_t call = {0};
HfpIncomingEventPublish(TOPIC_EVENT_HFP_WATCH_TO_PHONE, call);
}
-
- usleep(5000); // 增加延时确保SCO断开后状态复位成功
-
- if (g_currCallState == HFP_HF_CALL_STATE_INCOMING) { // 规避某些型号手机在电话呼入时重复断开和连接SCO
- return;
- }
-
- PostGraphicEvent(AudioRelease);
+ AudioRelease(); // 为了保持时序，此处采取同步调用
+ usleep(5000); // 增加延时确保SCO断开AUDIO通路释放成功
}
// Sco连接状态变化回调函数，音频连接状态
static void ScoStateChanged(const bd_addr_t *bdAddr, hfp_sco_connect_state_t state)
{
g_scoFlag = state;
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[ScoStateChanged] state = %d, g_scoFlag = %d, g_currCallNum = %d", state,
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[ScoStateChanged] hfpState:%d, ScoFlag:%d, CallNum:%d", state,
g_scoFlag, g_currCallNum);
switch (state) {
static void CallLogCreatDir(void)
{
- DIR *dir = NULL;
+ DIR *dir = nullptr;
dir = opendir(CALL_LOG_DIR);
- if (dir == NULL) {
+ if (dir == nullptr) {
mkdir(CALL_LOG_DIR, S_IREAD | S_IWRITE);
} else {
closedir(dir);
{
int len = 0;
FILE *fp = fopen(CALL_LOG_PATH, "rb");
- if (fp == NULL) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[GetCallLogFileSize] fopen CALL_LOG_PATH error");
+ if (fp == nullptr) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[GetCallLogFileSize] fopen %s failed", CALL_LOG_PATH);
return OHOS_FAILURE;
}
fseek(fp, 0, SEEK_SET);
fclose(fp);
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[GetCallLogFileSize] len = %d", len);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[GetCallLogFileSize] len:%d", len);
return len;
}
// 添加通话进通话记录文件
void AddToCallLog(CallLogInfo *info)
{
- FILE *fp = NULL;
+ FILE *fp = nullptr;
size_t ret;
fp = fopen(CALL_LOG_PATH, "ab");
- if (fp == NULL) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AddToCallLog] fopen failed!");
+ if (fp == nullptr) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AddToCallLog] fopen %s failed!", CALL_LOG_PATH);
return;
}
ret = fwrite(info, sizeof(CallLogInfo), 1, fp);
if (ret != 1) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AddToCallLog] fwrite failed! ret = %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AddToCallLog] fwrite failed! ret:%d", ret);
}
fclose(fp);
static int CopyPhoneLogToTmpLog(void)
{
- FILE *fp = NULL;
- FILE *ftp = NULL;
- CallLogInfo *info = NULL;
+ FILE *fp = nullptr;
+ FILE *ftp = nullptr;
+ CallLogInfo *info = nullptr;
int retLen;
int fileSize = GetCallLogFileSize();
-
if (fileSize == OHOS_FAILURE || fileSize == 0) {
return fileSize;
}
return ClearCallLogFile(); // 只有一条记录，清空通话记录
}
- fp = fopen(CALL_LOG_PATH,"rb");
- if (fp == NULL) {
+ fp = fopen(CALL_LOG_PATH, "rb");
+ if (fp == nullptr) {
return OHOS_FAILURE;
}
ftp = fopen(CALL_TMP_LOG_PATH, "wb+");
- if (ftp == NULL) {
+ if (ftp == nullptr) {
fclose(fp);
return OHOS_FAILURE;
}
info = (CallLogInfo *)malloc(fileSize);
- if (info == NULL) {
+ if (info == nullptr) {
fclose(fp);
fclose(ftp);
return OHOS_FAILURE;
}
(void)memset_s(info, fileSize, 0, fileSize);
- if(fread(info, fileSize, 1, fp) != 1) {
+ if (fread(info, fileSize, 1, fp) != 1) {
retLen = OHOS_FAILURE;
goto END;
}
- if(fwrite((info + 1), retLen, 1, ftp) != 1) {
+ if (fwrite((info + 1), retLen, 1, ftp) != 1) {
retLen = OHOS_FAILURE;
goto END;
}
fclose(fp);
fclose(ftp);
free(info);
- info = NULL;
+ info = nullptr;
return retLen;
}
// 删除第一条通话记录
int RemoveFirstCallLog(void)
{
- FILE *fp = NULL;
- FILE *ftp = NULL;
- CallLogInfo *info = NULL;
+ FILE *fp = nullptr;
+ FILE *ftp = nullptr;
+ CallLogInfo *info = nullptr;
int ret = OHOS_SUCCESS;
int fileSize = CopyPhoneLogToTmpLog();
return fileSize;
}
- fp = fopen(CALL_LOG_PATH,"wb+");
- if (fp == NULL) {
+ fp = fopen(CALL_LOG_PATH, "wb+");
+ if (fp == nullptr) {
return OHOS_FAILURE;
}
ftp = fopen(CALL_TMP_LOG_PATH, "rb");
- if (ftp == NULL) {
+ if (ftp == nullptr) {
fclose(fp);
return OHOS_FAILURE;
}
info = (CallLogInfo *)malloc(fileSize);
- if (info == NULL) {
+ if (info == nullptr) {
fclose(fp);
fclose(ftp);
return OHOS_FAILURE;
}
(void)memset_s(info, fileSize, 0, fileSize);
- if(fread(info, fileSize, 1, ftp) != 1) {
+ if (fread(info, fileSize, 1, ftp) != 1) {
ret = OHOS_FAILURE;
goto END;
}
- if(fwrite(info, fileSize, 1, fp) != 1) {
+ if (fwrite(info, fileSize, 1, fp) != 1) {
ret = OHOS_FAILURE;
goto END;
}
fclose(fp);
fclose(ftp);
free(info);
- info = NULL;
+ info = nullptr;
return ret;
}
// 添加通话记录
static void AddToCallLogPro(PhoneCallInfo *callInfo)
{
- int ret, num, fileSize;
- CallLogInfo info;
-
- if (callInfo == NULL) {
+ if (callInfo == nullptr) {
return;
}
- fileSize = GetCallLogFileSize();
- num = fileSize / sizeof(CallLogInfo);
+ int fileSize = GetCallLogFileSize();
+ int num = fileSize / sizeof(CallLogInfo);
if (num >= CALL_LOG_MAX_NUM) {
- ret = RemoveFirstCallLog();
+ int ret = RemoveFirstCallLog();
if (ret == OHOS_FAILURE) {
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AddToCallLogPro] RemoveFirstCallLog error");
return;
}
}
+ CallLogInfo info;
(void)memset_s(info.name, NAME_SIZE, '\0', NAME_SIZE);
(void)memset_s(info.tel, MAX_PHONE_NUM, '\0', MAX_PHONE_NUM);
- ret = memcpy_s(info.name, NAME_SIZE, callInfo->name, callInfo->nameLen);
+ int ret = memcpy_s(info.name, NAME_SIZE, callInfo->name, callInfo->nameLen);
if (ret != EOK) {
info.nameLen = 0;
} else {
info.creationTime = callInfo->creationTime;
if (callInfo->lastStatus == HFP_HF_CALL_STATE_ACTIVE || callInfo->lastStatus == HFP_HF_CALL_STATE_HELD ||
callInfo->lastStatus == HFP_HF_CALL_STATE_RESPONSE_HELD) {
- info.callDurTime = time(NULL) - callInfo->activeTime;
+ info.callDurTime = time(nullptr) - callInfo->activeTime;
} else {
info.callDurTime = 0;
}
// 获取通话记录
int GetCallLog(CallLogInfo **info, int *num)
{
- FILE *fp = NULL;
- int ret, fileSize, number;
- CallLogInfo *callInfo = NULL;
-
- fp = fopen(CALL_LOG_PATH, "rb");
- if (fp == NULL) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AddToCallLog] fopen CALL_LOG_PATH failed!");
+ FILE *fp = fopen(CALL_LOG_PATH, "rb");
+ if (fp == nullptr) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AddToCallLog] fopen %s failed!", CALL_LOG_PATH);
return OHOS_FAILURE;
}
- fileSize = GetCallLogFileSize();
+ int fileSize = GetCallLogFileSize();
if (fileSize == 0) {
- *info = NULL;
+ *info = nullptr;
*num = 0;
fclose(fp);
return OHOS_SUCCESS;
}
- number = fileSize / sizeof(CallLogInfo);
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[GetCallLog] fileSize = %d, number = %d", fileSize, number);
- callInfo = (CallLogInfo *)malloc(fileSize);
- if (callInfo == NULL) {
+ int number = fileSize / sizeof(CallLogInfo);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[GetCallLog] fileSize:%d, number:%d", fileSize, number);
+ CallLogInfo *callInfo = (CallLogInfo *)malloc(fileSize);
+ if (callInfo == nullptr) {
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[GetCallLog] malloc callInfo fail!");
- *info = NULL;
+ *info = nullptr;
*num = 0;
fclose(fp);
return OHOS_FAILURE;
}
(void)memset_s(callInfo, fileSize, 0, fileSize);
- ret = fread(callInfo, sizeof(CallLogInfo), number, fp);
+ int ret = fread(callInfo, sizeof(CallLogInfo), number, fp);
if (ret != number) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[GetCallLog] fread fp fail ret = %d", ret);
- *info = NULL;
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[GetCallLog] fread fp fail ret:%d", ret);
+ *info = nullptr;
*num = 0;
fclose(fp);
return OHOS_FAILURE;
int ClearCallLogFile(void)
{
FILE *fp = fopen(CALL_LOG_PATH, "wb");
- if (fp == NULL) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ClearCallLogFile] fopen CALL_LOG_PATH failed!");
+ if (fp == nullptr) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ClearCallLogFile] fopen %s failed!", CALL_LOG_PATH);
return OHOS_FAILURE;
}
static PhoneCallInfo *FindCallInfoInCallList(const unsigned char *number, unsigned char numberLen)
{
int i;
- const char *str1 = NULL;
- const char *str2 = NULL;
+ const char *str1 = nullptr;
+ const char *str2 = nullptr;
if (g_currCallNum == 0) {
- return NULL;
+ return nullptr;
}
for (i = 0; i < MULTI_CALL_MAX_NUME; i++) {
}
}
- return NULL;
+ return nullptr;
}
static void CatPhoneNumber(char *number, unsigned char len)
static void AddCurrCallToCallList(const hfp_hf_calls_info_t *call)
{
- PhoneCallInfo *phoneCall = NULL;
- int tmp, ret;
-
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[AddCurrCallToCallList] start, call->state = %d", call->state);
- if (call == NULL || g_currCallNum >= MULTI_CALL_MAX_NUME ||
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[AddCurrCallToCallList] state:%d", call->state);
+ if (call == nullptr || g_currCallNum >= MULTI_CALL_MAX_NUME ||
(call->state != HFP_HF_CALL_STATE_ACTIVE && call->state != HFP_HF_CALL_STATE_HELD &&
call->state != HFP_HF_CALL_STATE_ALERTING)) {
return;
}
g_currCallNum++;
- tmp = g_currCallNum - 1;
- phoneCall = &g_callList[tmp];
+ int32_t tmp = g_currCallNum - 1;
+ PhoneCallInfo *phoneCall = &g_callList[tmp];
if (call->state == HFP_HF_CALL_STATE_ACTIVE) { // 正在通话
phoneCall->operate = OPERATE_PHONE_ACTIVE;
- phoneCall->activeTime = time(NULL);
+ phoneCall->activeTime = time(nullptr);
} else if (call->state == HFP_HF_CALL_STATE_HELD) { // 挂起
phoneCall->operate = OPERATE_PHONE_HOLD;
- phoneCall->activeTime = time(NULL);
+ phoneCall->activeTime = time(nullptr);
} else if (call->state == HFP_HF_CALL_STATE_ALERTING) { // 呼出，对方响铃
phoneCall->operate = OPERATE_ALERTING;
}
// 使用通讯录接口获取当前电话对应的备注人名(通讯录待开发)
phoneCall->lastStatus = call->state;
- phoneCall->creationTime = time(NULL);
+ phoneCall->creationTime = time(nullptr);
- ret = memcpy_s(phoneCall->tel, MAX_PHONE_NUM, call->number, call->number_len);
+ int32_t ret = memcpy_s(phoneCall->tel, MAX_PHONE_NUM, call->number, call->number_len);
if (ret != EOK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AddCurrCallToCallList] memcpy_s tel fail, ret = %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AddCurrCallToCallList] copy tel ret:%d", ret);
CatPhoneNumber(call->number, call->number_len);
}
phoneCall->telLen = call->number_len;
// 通话状态变化--呼出，正在拨号处理
static void CallChangeDialPro(const hfp_hf_calls_info_t *call)
{
- PhoneCallInfo *phoneCall = NULL;
- int tmp, ret;
-
- if (call == NULL) {
+ if (call == nullptr) {
return;
}
- g_currCallNum++;
- tmp = g_currCallNum - 1;
- phoneCall = &g_callList[tmp];
+ g_currCallNum++;
+ int32_t tmp = g_currCallNum - 1;
+ PhoneCallInfo *phoneCall = &g_callList[tmp];
// 使用通讯录接口获取当前电话对应的备注人名(通讯录待开发)
phoneCall->operate = OPERATE_DIALING;
phoneCall->lastStatus = call->state;
- phoneCall->creationTime = time(NULL);
+ phoneCall->creationTime = time(nullptr);
- ret = memcpy_s(phoneCall->tel, MAX_PHONE_NUM, call->number, call->number_len);
+ int32_t ret = memcpy_s(phoneCall->tel, MAX_PHONE_NUM, call->number, call->number_len);
if (ret != EOK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[CallChangeDialPro] memcpy_s tel fail, ret = %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[CallChangeDialPro] copy tel ret:%d", ret);
CatPhoneNumber(call->number, call->number_len);
}
phoneCall->telLen = call->number_len;
// 通话状态变化--呼出，对方响铃
static void CallChangeAlertPro(const hfp_hf_calls_info_t *call)
{
- PhoneCallInfo *phoneCall = NULL;
+ PhoneCallInfo *phoneCall = nullptr;
- if (call == NULL) {
+ if (call == nullptr) {
return;
}
phoneCall = FindCallInfoInCallList((const unsigned char*)call->number, call->number_len);
- if (phoneCall == NULL) {
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[CallChangeAlertPro] FindCallInfoInCallList Alert no this call");
+ if (phoneCall == nullptr) {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[CallChangeAlertPro] Alert no this call");
AddCurrCallToCallList(call);
return;
}
{
int32 ret;
uint32 size = sizeof(hfp_hf_calls_info_t);
- Request *request = NULL;
- BroadcastApi *broadcastApi = NULL;
- IUnknown *api = NULL;
+ Request *request = nullptr;
+ BroadcastApi *broadcastApi = nullptr;
+ IUnknown *api = nullptr;
WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HfpIncomingEventPublish topic=%u!!", topic);
/* alloc request */
request = SAMGR_AllocRequestMsg(0, PLATFORM_CORE, BROADCAST_SVR_ID, size);
- if (request == NULL) {
+ if (request == nullptr) {
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "SAMGR_AllocRequestMsg failed");
return;
}
request->msgId = topic;
ret = memcpy_s(request->data, size, (const void *)&callsInfo, size);
if (ret != EOK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HfpIncomingEventPublish memcpy_s rateDataTmp fail! ret = %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HfpIncomingEventPublish memcpy_s rateDataTmp fail! ret:%d", ret);
return;
}
request->len = size;
/* public request */
api = SAMGR_GetInstance()->GetFeatureApi(BROADCAST_SERVICE_NAME, BROADCAST_FEATURE_NAME);
- if (api == NULL) {
+ if (api == nullptr) {
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GetFeatureApi failed");
SAMGR_FreeRequestMsg(request);
return;
}
ret = api->QueryInterface(api, DEFAULT_VERSION, (void **)&broadcastApi);
- if (ret != 0 || broadcastApi == NULL) {
+ if (ret != 0 || broadcastApi == nullptr) {
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "QueryInterface failed");
SAMGR_FreeRequestMsg(request);
return;
}
// 通话状态变化--呼入处理
-void CallChangeIncomePro(const hfp_hf_calls_info_t *call)
+static void CallChangeIncomePro(const hfp_hf_calls_info_t *call)
{
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[hu] call");
- PhoneCallInfo *phoneCall = NULL;
- int tmp, ret;
-
- if (call == NULL || g_currCallNum >= MULTI_CALL_MAX_NUME ||
+ if (call == nullptr || g_currCallNum >= MULTI_CALL_MAX_NUME ||
(call->state != HFP_HF_CALL_STATE_INCOMING && call->state != HFP_HF_CALL_STATE_WAITING)) {
return;
}
- phoneCall = FindCallInfoInCallList((const unsigned char*)call->number, call->number_len);
- if (phoneCall != NULL) {
+ PhoneCallInfo *phoneCall = FindCallInfoInCallList((const unsigned char*)call->number, call->number_len);
+ if (phoneCall != nullptr) {
// 通话状态由呼入等待转换成呼入情况
} else {
g_currCallNum++;
- tmp = g_currCallNum - 1;
+ int32_t tmp = g_currCallNum - 1;
phoneCall = &g_callList[tmp];
}
phoneCall->operate = OPERATE_WAITING;
}
phoneCall->lastStatus = call->state;
- phoneCall->creationTime = time(NULL);
+ phoneCall->creationTime = time(nullptr);
- ret = memcpy_s(phoneCall->tel, MAX_PHONE_NUM, call->number, call->number_len);
+ int32_t ret = memcpy_s(phoneCall->tel, MAX_PHONE_NUM, call->number, call->number_len);
if (ret != EOK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[CallChangeIncomePro] memcpy_s tel fail, ret = %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[CallChangeIncomePro] copy tel ret:%d", ret);
CatPhoneNumber(call->number, call->number_len);
}
phoneCall->telLen = call->number_len;
// 通话状态变化--接听流程处理
static void CallChangeActivePro(const hfp_hf_calls_info_t *call)
{
- PhoneCallInfo *phoneCall = NULL;
+ PhoneCallInfo *phoneCall = nullptr;
- if (call == NULL) {
+ if (call == nullptr) {
return;
}
phoneCall = FindCallInfoInCallList((const unsigned char*)call->number, call->number_len);
- if (phoneCall == NULL) {
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[CallChangeActivePro] FindCallInfoInCallList Active no this call");
+ if (phoneCall == nullptr) {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[CallChangeActivePro] Active no this call");
AddCurrCallToCallList(call);
+ TransCallToMobilePhone();
return;
}
- if (phoneCall->lastStatus == HFP_HF_CALL_STATE_HELD && IsCompleteCallFlow() == true) { // 挂起状态切换到接听状态
+ if (phoneCall->lastStatus == HFP_HF_CALL_STATE_HELD && IsCompleteCallFlow()) { // 挂起状态切换到接听状态
phoneCall->operate = OPERATE_WATCH_ACTIVE;
- } else if (phoneCall->lastStatus == HFP_HF_CALL_STATE_HELD && IsCompleteCallFlow() == false) {
+ } else if (phoneCall->lastStatus == HFP_HF_CALL_STATE_HELD && (!IsCompleteCallFlow())) {
phoneCall->operate = OPERATE_PHONE_ACTIVE;
} else if (phoneCall->operate == OPERATE_WATCH_ACTIVE) { // 手表接听
// 不做操作
if (phoneCall->activeTime == 0 &&
(phoneCall->lastStatus == HFP_HF_CALL_STATE_DIALING || phoneCall->lastStatus == HFP_HF_CALL_STATE_ALERTING ||
phoneCall->lastStatus == HFP_HF_CALL_STATE_INCOMING || phoneCall->lastStatus == HFP_HF_CALL_STATE_WAITING)) {
- phoneCall->activeTime = time(NULL);
+ phoneCall->activeTime = time(nullptr);
}
phoneCall->lastStatus = call->state;
if (phoneCall->operate == OPERATE_PHONE_ACTIVE) {
// 发布电话接听事件，手表关闭来电通知
HfpIncomingEventPublish(TOPIC_EVENT_HFP_PHONE_ACTIVE, phoneCall->unitCalls);
- } else if (phoneCall->operate == OPERATE_WATCH_ACTIVE) {
+ } else if (phoneCall->operate == OPERATE_WATCH_ACTIVE && g_scoFlag == HFP_SCO_STATE_CONNECTED) {
// 发布手表接听事件，通知切换接听界面
HfpIncomingEventPublish(TOPIC_EVENT_HFP_WATCH_ACTIVE, phoneCall->unitCalls);
}
// 通话状态变化--拒接/结束流程处理
static void CallChangeFinishPro(const hfp_hf_calls_info_t *call)
{
- PhoneCallInfo *phoneCall = NULL;
+ PhoneCallInfo *phoneCall = nullptr;
PhoneCallInfo tmp;
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[CallChangeFinishPro] start g_scoFlag = %d, g_currCallNum = %d",
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[CallChangeFinishPro] start scoFlag:%d, CallNum:%d",
g_scoFlag, g_currCallNum);
- if (call == NULL || g_currCallNum == 0) {
+ if (call == nullptr || g_currCallNum == 0) {
return;
}
phoneCall = FindCallInfoInCallList((const unsigned char*)call->number, call->number_len);
- if (phoneCall == NULL) {
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[CallChangeFinishPro] FindCallInfoInCallList Finish no this call");
+ if (phoneCall == nullptr) {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[CallChangeFinishPro] Finish no this call");
return;
}
if (g_finishOperate == OPERATE_WATCH_FINISH) {
// 通知手表通话结束
CallChangedCb(&tmp);
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[CallChangeFinishPro] end g_scoFlag = %d, g_currCallNum = %d",
- g_scoFlag, g_currCallNum);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[CallChangeFinishPro] end scoFlag:%d, CallNum:%d",
+ g_scoFlag, g_currCallNum);
}
// 通话状态变化--挂起通话（当前只有手机挂起触发（并且手表不需感知），手表不支持挂起触发，对方挂起不感知）
static void CallChangeHeldPro(const hfp_hf_calls_info_t *call)
{
- PhoneCallInfo *phoneCall = NULL;
+ PhoneCallInfo *phoneCall = nullptr;
- if (call == NULL) {
+ if (call == nullptr) {
return;
}
phoneCall = FindCallInfoInCallList((const unsigned char*)call->number, call->number_len);
- if (phoneCall == NULL) {
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[CallChangeHeldPro] FindCallInfoInCallList Held no this call");
+ if (phoneCall == nullptr) {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[CallChangeHeldPro] Held no this call");
AddCurrCallToCallList(call);
return;
}
// 手机挂起通话
phoneCall->operate = OPERATE_PHONE_HOLD;
if (phoneCall->lastStatus == HFP_HF_CALL_STATE_INCOMING || phoneCall->lastStatus == HFP_HF_CALL_STATE_WAITING) {
- phoneCall->activeTime = time(NULL);
+ phoneCall->activeTime = time(nullptr);
}
phoneCall->lastStatus = call->state;
(void)memcpy_s(&phoneCall->unitCalls, sizeof(hfp_hf_calls_info_t), call, sizeof(hfp_hf_calls_info_t));
static void PlayWatchRing(void)
{
WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[PlayWatchRing] start");
- // 申请手表铃声焦点
- // AudioActInterrupt(AUDIO_STREAM_RING);
- // 播放手表铃声（播放方案待定）
}
static void CallAudioHandle(const hfp_hf_calls_info_t *call)
{
int state = call->state;
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[CallAudioHandle] start g_audioState: %d", g_audioState);
-
if (state == HFP_HF_CALL_STATE_INCOMING || state == HFP_HF_CALL_STATE_DIALING ||
state == HFP_HF_CALL_STATE_ALERTING) { // 电话呼入，支持播放手机铃声
- if (call->in_band_ring == true) {
+ if (call->in_band_ring) {
// 播放手机端铃声
PostGraphicEvent(AudioDn);
} else {
} else if (state == HFP_HF_CALL_STATE_FINISHED) {
return;
} else if (g_scoFlag == HFP_SCO_STATE_CONNECTED) {
- if (g_audioState < AUDIO_STREAM_START_DN) {
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[CallAudioHandle] post AudioDn");
- PostGraphicEvent(AudioDn);
- }
- if (g_audioState != AUDIO_STREAM_START_UP) {
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[CallAudioHandle] post AudioUp");
- PostGraphicEvent(AudioUp);
- }
+ PostGraphicEvent(AudioSetup);
}
-
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[CallAudioHandle] end g_audioState: %d", g_audioState);
}
static void CatCallStateChangedInfo(const bd_addr_t *bdAddr, const hfp_hf_calls_info_t *call)
{
WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "***************************CallStateChanged***************************");
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "g_scoFlag = %d, g_currCallNum = %d, bdAddr: ", g_scoFlag, g_currCallNum);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "scoFlag:%d, CallNum:%d, bdAddr: ", g_scoFlag, g_currCallNum);
CatBdAddr(bdAddr);
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "id = %d, state = %d", call->id, call->state);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "id:%d, state:%d", call->id, call->state);
CatPhoneNumber(call->number, call->number_len);
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "multi_party = %d, outgoing = %d, in_band_ring = %d, creation_time = %ld",
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "multi_party:%d, outgoing:%d, in_band_ring:%d, creation_time:%ld",
call->multi_party, call->outgoing, call->in_band_ring, call->creation_time);
WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "***********************************************************************");
}
static void CallStateChanged(const bd_addr_t *bdAddr, const hfp_hf_calls_info_t *call)
{
CopyBdAddr(bdAddr);
- if (call == NULL || g_btConnState != PROFILE_STATE_CONNECTED) {
+ if (call == nullptr || g_btConnState != PROFILE_STATE_CONNECTED) {
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "call is null or BT disconnected connStatus: 0x%X", g_btConnState);
return;
}
CatCallStateChangedInfo(bdAddr, call);
CallAudioHandle(call);
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "CallStateChanged state = %d", call->state);
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "CallStateChanged state:%d", call->state);
switch (call->state) {
case HFP_HF_CALL_STATE_ACTIVE: // 正在通话
CallChangeActivePro(call);
CallChangeAlertPro(call);
break;
case HFP_HF_CALL_STATE_INCOMING: // 呼入
-
PhoneServiceScreenCtr(1);
CallChangeIncomePro(call);
break;
}
if (g_currCallNum == 0) {
- PostGraphicEvent(AudioRelease);
g_completeCallFlag = false;
}
}
-static int g_hfpVolumeType;
-static unsigned char g_hfpVolume;
-
-static void BtHfpVolumeChanged(void)
+static void BtHfpVolumeChanged(int volumeType, unsigned char hfpVolume)
{
- int maxVolume, minVolume, tmp;
- bool ret;
-
// mic
- if (g_hfpVolumeType == HFP_VOLUME_MIC) {
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[BtHfpVolumeChanged] g_hfpVolumeType = %d, g_hfpVolume = %d ",
- g_hfpVolumeType, g_hfpVolume);
+ if (volumeType == HFP_VOLUME_MIC) {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "VolumeChanged Type:%d, hfpVolume:%d",
+ volumeType, hfpVolume);
}
// speak
- if (g_hfpVolumeType == HFP_VOLUME_SPEAKER) {
- minVolume = PhoneAudioGetMinVolume();
- maxVolume = PhoneAudioGetMaxVolume();
- tmp = g_hfpVolume * (maxVolume - minVolume) / CALL_VOLUME_MAX; // 转换
-
- ret = PhoneAudioSetVolume(tmp);
- if (ret != true) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[BtHfpVolumeChanged] g_hfpVolumeType: %d, ret: %d", g_hfpVolumeType, ret);
+ if (volumeType == HFP_VOLUME_SPEAKER) {
+ int32_t minVolume = PhoneAudioGetMinVolume();
+ int32_t maxVolume = PhoneAudioGetMaxVolume();
+ int32_t volume = hfpVolume * (maxVolume - minVolume) / CALL_VOLUME_MAX; // 转换
+ volume = (volume == 0) ? ((maxVolume - minVolume) / CALL_VOLUME_MAX) : volume;
+ bool ret = PhoneAudioSetVolume(volume);
+ if (!ret) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "VolumeChanged Type:%d, ret:%d",
+ volumeType, ret);
}
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[BtHfpVolumeChanged] g_hfpVolumeType: %d, minVolume: %d, maxVolume: %d tmp: %d\
- ret：%d ", g_hfpVolumeType, minVolume, maxVolume, tmp, ret);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "VolumeChanged Type:%d, min:%d, max:%d volume:%d ret:%d",
+ volumeType, minVolume, maxVolume, volume, ret);
}
}
static void VolumeChanged(const bd_addr_t *bdAddr, hfp_volume_type_t type, unsigned char volume)
{
UNUSED(bdAddr);
- g_hfpVolumeType = type;
- g_hfpVolume = volume;
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[VolumeChanged] type = %d volume = %d", type, volume);
- PostGraphicEvent(BtHfpVolumeChanged); // 解决SdkMsgThread爆栈问题
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[VolumeChanged] type:%d volume:%d", type, volume);
+ GraphicService::GetInstance()->PostGraphicEvent(std::bind(BtHfpVolumeChanged, type, volume));
}
// 拨号失败回调
static void DialErrorCode(const bd_addr_t *bdAddr, int code)
{
UNUSED(bdAddr);
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[DialErrorCode] code = %d", code);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[DialErrorCode] code:%d", code);
PhoneServiceErrorCallback(ERROR_DIAL, code);
}
{
UNUSED(bdAddr);
UNUSED(batteryLevel);
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[HfpBatteryChanged] batteryLevel: %d", batteryLevel);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[HfpBatteryChanged] batteryLevel:%d", batteryLevel);
}
static void HfpSignalStrengthChanged(const bd_addr_t *bdAddr, int signalStrength)
{
UNUSED(bdAddr);
UNUSED(signalStrength);
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[HfpSignalStrengthChanged] signalStrength: %d", signalStrength);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[HfpSignalStrengthChanged] signalStrength:%d", signalStrength);
}
static void HfpRegistStatusChanged(const bd_addr_t *bdAddr, int status)
{
UNUSED(bdAddr);
UNUSED(status);
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[HfpRegistStatusChanged] status: %d", status);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[HfpRegistStatusChanged] status:%d", status);
}
static void HfpRoamingStatusChanged(const bd_addr_t *bdAddr, int status)
{
UNUSED(bdAddr);
UNUSED(status);
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[HfpRoamingStatusChanged] status: %d", status);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[HfpRoamingStatusChanged] status:%d", status);
}
static void HfpOperatorSelection(const bd_addr_t *bdAddr, unsigned char *name, unsigned int len)
UNUSED(bdAddr);
UNUSED(name);
UNUSED(len);
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[HfpOperatorSelection] name: %s, len: %d", name, len);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[HfpOperatorSelection] name: %s, len:%d", name, len);
}
static void HfpSubscriberNumber(const bd_addr_t *bdAddr, unsigned char *number, unsigned int len)
UNUSED(bdAddr);
UNUSED(number);
UNUSED(len);
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[HfpSubscriberNumber] number: %s, len: %d", number, len);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[HfpSubscriberNumber] number: %s, len:%d", number, len);
}
static void VoiceRecogStatusChanged(const bd_addr_t *bdAddr, int status)
{
UNUSED(bdAddr);
UNUSED(status);
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[VoiceRecogStatusChanged] status: %d", status);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[VoiceRecogStatusChanged] status:%d", status);
}
static void InbandRingtoneChanged(const bd_addr_t *bdAddr, int status)
{
UNUSED(bdAddr);
UNUSED(status);
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[InbandRingtoneChanged] status: %d", status);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[InbandRingtoneChanged] status:%d", status);
}
static void CodecChanged(const bd_addr_t *bdAddr, int codec)
} else if (codec == HFP_HF_CODEC_ID_MSBC) {
g_call_codec = mSBC;
}
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[CodecChanged] codec: %d, call_codec: %d", codec, g_call_codec);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[CodecChanged] codec:%d, call_codec:%d", codec, g_call_codec);
}
ret = hfp_hf_register_callbacks(&callbacks);
if (ret != 0) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[RegisterHfpHfCallbacks] ret = %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[RegisterHfpHfCallbacks] ret:%d", ret);
}
}
int DialCall(unsigned char *number, unsigned char len)
{
int ret;
- unsigned char *tel = NULL;
+ unsigned char *tel = nullptr;
WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[DialCall] start");
if (g_btConnState != PROFILE_STATE_CONNECTED) {
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DialCall] BT connStatus: 0x%X", g_btConnState);
}
// 有通话时，不允许拨出电话
- if (g_currCallNum > 0 || len > MAX_PHONE_NUM || number == NULL) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DialCall] g_currCallNum = %d", g_currCallNum);
+ if (g_currCallNum > 0 || len > MAX_PHONE_NUM || number == nullptr) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DialCall] g_currCallNum:%d", g_currCallNum);
return OHOS_FAILURE;
}
tel = (unsigned char *)malloc(len + 1);
- if (tel == NULL) {
+ if (tel == nullptr) {
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DialCall] malloc tel error");
return OHOS_FAILURE;
}
*(tel + len) = '\0';
ret = hfp_hf_start_dial(&g_bdAddr, tel, len);
if (ret != ERRCODE_BT_SUCCESS) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DialCall] hfp_hf_start_dial error ret %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DialCall] hfp_hf_start_dial ret %d", ret);
free(tel);
return OHOS_FAILURE;
}
int AcceptIncomingCall(void)
{
WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[AcceptIncomingCall] start");
- int ret, i;
- PhoneCallInfo *phoneCall = NULL;
+ int32_t ret;
+ PhoneCallInfo *phoneCall = nullptr;
PhoneCallInfo *tmp = g_callList;
if (g_btConnState != PROFILE_STATE_CONNECTED) {
return OHOS_FAILURE;
}
- for (i = 0; i < MULTI_CALL_MAX_NUME; i++) {
+ for (int32_t i = 0; i < MULTI_CALL_MAX_NUME; i++) {
if (tmp->lastStatus == HFP_HF_CALL_STATE_INCOMING || tmp->lastStatus == HFP_HF_CALL_STATE_WAITING) {
phoneCall = tmp;
break;
tmp++;
}
- if (phoneCall == NULL) {
+ if (phoneCall == nullptr) {
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AcceptIncomingCall] no incoming");
return OHOS_FAILURE;
}
ret = hfp_hf_accept_incoming_call(&g_bdAddr, HFP_HF_ACCEPT_CALL_ACTION_NONE); // 无人通话，有人呼入，接听呼入电话
}
if (ret != ERRCODE_BT_SUCCESS) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AcceptIncomingCall] hfp_hf_accept_incoming_call error ret = %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AcceptIncomingCall] ret:%d", ret);
phoneCall->operate = OPERATE_NO_OPE;
return OHOS_FAILURE;
}
return OHOS_SUCCESS;
}
-
// 手表拒接呼入来电，成功：0，失败：错误码
int RejectIncomingCall(void)
{
WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[RejectIncomingCall] start");
- int ret, i;
- PhoneCallInfo *phoneCall = NULL;
+ PhoneCallInfo *phoneCall = nullptr;
PhoneCallInfo *tmp = g_callList;
if (g_btConnState != PROFILE_STATE_CONNECTED) {
return OHOS_FAILURE;
}
- for (i = 0; i < MULTI_CALL_MAX_NUME; i++) {
+ for (int32_t i = 0; i < MULTI_CALL_MAX_NUME; i++) {
if (tmp->lastStatus == HFP_HF_CALL_STATE_INCOMING || tmp->lastStatus == HFP_HF_CALL_STATE_WAITING) {
phoneCall = tmp;
}
tmp++;
}
- if (phoneCall == NULL) {
+ if (phoneCall == nullptr) {
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AcceptIncomingCall] no incoming");
return OHOS_SUCCESS;
}
- ret = hfp_hf_reject_incoming_call(&g_bdAddr);
+ int32_t ret = hfp_hf_reject_incoming_call(&g_bdAddr);
if (ret != ERRCODE_BT_SUCCESS) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[RejectIncomingCall] hfp_hf_reject_incoming_call error ret = %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[RejectIncomingCall] ret:%d", ret);
return OHOS_FAILURE;
}
g_finishOperate = OPERATE_WATCH_REJECT;
// 手表结束通话
int FinishCall(void)
{
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[FinishCall] start");
-
if (g_btConnState != PROFILE_STATE_CONNECTED) {
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[FinishCall] BT connStatus: 0x%X", g_btConnState);
return OHOS_FAILURE;
}
int ret = hfp_hf_finish_call(&g_bdAddr);
if (ret != ERRCODE_BT_SUCCESS) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[FinishCall] hfp_hf_finish_call error ret = %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[FinishCall] ret:%d", ret);
return OHOS_FAILURE;
}
g_finishOperate = OPERATE_WATCH_FINISH;
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[FinishCall] success!");
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "FinishCall");
return OHOS_SUCCESS;
}
*/
int GetCallInfoInCallList(PhoneCallInfo callList[], int listNum, int *retNum)
{
- int i, len;
PhoneCallInfo *tmp = g_callList;
PhoneCallInfo *tmp2 = callList;
- if (callList == NULL || listNum < MULTI_CALL_MAX_NUME) {
+ if (callList == nullptr || listNum < MULTI_CALL_MAX_NUME) {
*retNum = 0;
return OHOS_FAILURE;
}
return OHOS_SUCCESS;
}
- len = sizeof(PhoneCallInfo);
- for (i = 0; i < MULTI_CALL_MAX_NUME; i++) {
+ int32_t len = sizeof(PhoneCallInfo);
+ for (int32_t i = 0; i < MULTI_CALL_MAX_NUME; i++) {
if (tmp->lastStatus == HFP_HF_CALL_STATE_FINISHED) {
tmp++;
} else {
return OHOS_SUCCESS;
}
-static unsigned char g_changeSpkVolume;
-
-static void GetCallCurrVolumeEvent(void)
-{
- int volume;
- int minVolume;
- int maxVolume;
- unsigned char tmp;
-
- volume = PhoneAudioGetVolume();
- minVolume = PhoneAudioGetMinVolume();
- maxVolume = PhoneAudioGetMaxVolume();
- tmp = (unsigned char)((volume * CALL_VOLUME_MAX) / (maxVolume - minVolume)); // 转换
-
- if (volume != 0 && tmp == 0) {
- tmp = 1;
- }
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[GetCallCurrVolumeEvent] volume = %d, minVolume = %d, maxVolume = %d, tmp = %d",
- volume, minVolume, maxVolume, tmp);
- g_changeSpkVolume = tmp;
-}
-
// 获取当前通话音量大小 (0 - 15)
+// hfp音量范围 0-15, media 音量范围 0-100
unsigned char GetCallCurrVolume(void)
{
- GetCallCurrVolumeEvent();
- return g_changeSpkVolume;
+ int32_t volume = PhoneAudioGetVolume();
+ int32_t minVolume = PhoneAudioGetMinVolume();
+ int32_t maxVolume = PhoneAudioGetMaxVolume();
+ unsigned char hfpVolume = (unsigned char)((volume * CALL_VOLUME_MAX) / (maxVolume - minVolume)); // 转换
+
+ if (volume != 0 && hfpVolume == 0) {
+ hfpVolume = 1;
+ }
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[GetCallCurrVolume] volume:%d, minVolume:%d, maxVolume:%d, hfpVolume:%d",
+ volume, minVolume, maxVolume, hfpVolume);
+ return hfpVolume;
}
-static void SetSpeakerVolumeEvent(void)
+void SetSpeakerVolume(unsigned char hfpVolume)
{
- int ret, minVolume, maxVolume, tmp;
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] start, hfpVolume:%d", hfpVolume);
+ int32_t minVolume = PhoneAudioGetMinVolume();
+ int32_t maxVolume = PhoneAudioGetMaxVolume();
+ int32_t volume = hfpVolume * (maxVolume - minVolume) / CALL_VOLUME_MAX; // 转换
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] minVolume:%d, maxVolume:%d, volume:%d",
+ minVolume, maxVolume, volume);
- minVolume = PhoneAudioGetMinVolume();
- maxVolume = PhoneAudioGetMaxVolume();
- tmp = g_changeSpkVolume * (maxVolume - minVolume) / CALL_VOLUME_MAX; // 转换
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolumeEvent] minVolume = %d, maxVolume = %d, tmp = %d",
- minVolume, maxVolume, tmp);
-
- ret = PhoneAudioSetVolume(tmp);
- if (ret != true) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolumeEvent] PhoneAudioSetVolume ret = %d", ret);
+ int32_t ret = PhoneAudioSetVolume(volume);
+ if (!ret) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] PhoneAudioSetVolume ret:%d", ret);
return;
}
- ret = hfp_hf_set_volume(&g_bdAddr, HFP_VOLUME_SPEAKER, g_changeSpkVolume);
+ ret = hfp_hf_set_volume(&g_bdAddr, HFP_VOLUME_SPEAKER, hfpVolume);
if (ret != ERRCODE_BT_SUCCESS) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolumeEvent] hfp_hf_set_volume fail ret = %d, g_changeSpkVolume = %d",
- ret, g_changeSpkVolume);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] set_volume ret:%d, hfpVolume:%d",
+ ret, hfpVolume);
return;
}
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolumeEvent] success!");
-}
-
-// 设置手表通话Speaker音量:0 - 15
-void SetSpeakerVolume(unsigned char volume)
-{
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] start, volume = %d", volume);
- if (volume > CALL_VOLUME_MAX) {
- g_changeSpkVolume = CALL_VOLUME_MAX;
- } else {
- g_changeSpkVolume = volume;
- }
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] success!");
- SetSpeakerVolumeEvent();
return;
}
} else {
ret = hfp_hf_connect_sco(&g_bdAddr);
if (ret != 0) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[TransCallToWatch] ret = %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[TransCallToWatch] ret:%d", ret);
}
return ret;
}
} else {
ret = hfp_hf_disconnect_sco(&g_bdAddr);
if (ret != 0) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[TransCallToMobilePhone] ret = %d", ret);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[TransCallToMobilePhone] ret:%d", ret);
}
return ret;
}
projects / mirrors / FD230.git / commitdiff