1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "audio_memo.h"
17 #include "log.h"
18 #include "audio_stream_info.h"
19 #include "audio_source_type.h"
20 #include "audio_info.h"
21 #include "monitor_error.h"
22
23 namespace {
24 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN_FOUNDATION, "AudioMemo"};
25 }
26
27 namespace OHOS {
28 namespace Media {
29 namespace MediaMonitor {
30
UpdataRouteInfo(std::shared_ptr<EventBean> & bean)31 void AudioMemo::UpdataRouteInfo(std::shared_ptr<EventBean> &bean)
32 {
33 MEDIA_LOG_D("Begin updata perferred device");
34 if (bean == nullptr) {
35 MEDIA_LOG_E("eventBean is nullptr");
36 return;
37 }
38 bool isInDeviceMap = false;
39 PerferredType perferredType = GetPerferredType(bean);
40 std::map<PerferredType, std::shared_ptr<MonitorDeviceInfo>>::iterator iter;
41 std::lock_guard<std::mutex> lockEventMap(perferredDeviceMutex_);
42 for (iter = perferredDevices_.begin(); iter != perferredDevices_.end(); iter++) {
43 if (iter->first == perferredType) {
44 iter->second->deviceType_ = bean->GetIntValue("DEVICE_TYPE");
45 iter->second->deviceName_ = bean->GetIntValue("DEVICE_NAME");
46 iter->second->address_ = bean->GetIntValue("ADDRESS");
47 iter->second->deviceCategory_ = bean->GetIntValue("BT_TYPE");
48 iter->second->usageOrSourceType_ = bean->GetIntValue("STREAM_TYPE");
49 isInDeviceMap = true;
50 }
51 }
52 if (!isInDeviceMap) {
53 std::shared_ptr<MonitorDeviceInfo> deviceInfo = std::make_shared<MonitorDeviceInfo>();
54 deviceInfo->deviceType_ = bean->GetIntValue("DEVICE_TYPE");
55 deviceInfo->deviceName_ = bean->GetIntValue("DEVICE_NAME");
56 deviceInfo->address_ = bean->GetIntValue("ADDRESS");
57 deviceInfo->deviceCategory_ = bean->GetIntValue("BT_TYPE");
58 deviceInfo->usageOrSourceType_ = bean->GetIntValue("STREAM_TYPE");
59 perferredDevices_.emplace(perferredType, deviceInfo);
60 }
61 }
62
GetAudioRouteMsg(std::map<PerferredType,std::shared_ptr<MonitorDeviceInfo>> & perferredDevices)63 int32_t AudioMemo::GetAudioRouteMsg(std::map<PerferredType, std::shared_ptr<MonitorDeviceInfo>> &perferredDevices)
64 {
65 MEDIA_LOG_D("Begin get perferred device");
66 std::lock_guard<std::mutex> lockEventMap(perferredDeviceMutex_);
67 perferredDevices = perferredDevices_;
68 return SUCCESS;
69 }
70
GetPerferredType(std::shared_ptr<EventBean> & bean)71 PerferredType AudioMemo::GetPerferredType(std::shared_ptr<EventBean> &bean)
72 {
73 if (bean->GetIntValue("IS_PLAYBACK")) {
74 return GetPerferredRenderType(bean->GetIntValue("STREAM_TYPE"));
75 } else {
76 return GetPerferredCaptureType(bean->GetIntValue("AUDIO_SCENE"));
77 }
78 }
79
GetPerferredRenderType(int32_t streamUsage)80 PerferredType AudioMemo::GetPerferredRenderType(int32_t streamUsage)
81 {
82 if (streamUsage == AudioStandard::STREAM_USAGE_VOICE_COMMUNICATION ||
83 streamUsage == AudioStandard::STREAM_USAGE_VOICE_MODEM_COMMUNICATION ||
84 streamUsage == AudioStandard::STREAM_USAGE_VIDEO_COMMUNICATION) {
85 return CALL_RENDER;
86 } else {
87 return MEDIA_RENDER;
88 }
89 }
90
GetPerferredCaptureType(int32_t audioScene)91 PerferredType AudioMemo::GetPerferredCaptureType(int32_t audioScene)
92 {
93 if (audioScene == AudioStandard::AUDIO_SCENE_PHONE_CALL ||
94 audioScene == AudioStandard::AUDIO_SCENE_PHONE_CHAT ||
95 audioScene == AudioStandard::SOURCE_TYPE_VOICE_COMMUNICATION) {
96 return CALL_CAPTURE;
97 } else {
98 return RECORD_CAPTURE;
99 }
100 }
101
WriteInfo(int32_t fd,std::string & dumpString)102 void AudioMemo::WriteInfo(int32_t fd, std::string &dumpString)
103 {
104 if (fd != -1) {
105 std::lock_guard<std::mutex> lockEventMap(perferredDeviceMutex_);
106 if (perferredDevices_.size() == 0) {
107 dumpString += "No preferred device set.\n";
108 return;
109 }
110 dumpString += "Perferred Device\n";
111 for (auto &it : perferredDevices_) {
112 dumpString += " perferred type: " + GetPerferredNameFromType(it.first) + "\n";
113 dumpString += " device type: " + std::to_string(it.second->deviceType_) + "\n";
114 dumpString += "\n";
115 }
116 }
117 }
118
GetPerferredNameFromType(const PerferredType & type)119 std::string AudioMemo::GetPerferredNameFromType(const PerferredType &type)
120 {
121 std::string perferredName = "";
122 switch (type) {
123 case CALL_RENDER:
124 perferredName = "call render";
125 break;
126 case MEDIA_RENDER:
127 perferredName = "media render";
128 break;
129 case CALL_CAPTURE:
130 perferredName = "call capture";
131 break;
132 case RECORD_CAPTURE:
133 perferredName = "record capture";
134 break;
135 default:
136 break;
137 }
138 return perferredName;
139 }
140
ErasePreferredDeviceByType(const PerferredType & preferredType)141 int32_t AudioMemo::ErasePreferredDeviceByType(const PerferredType &preferredType)
142 {
143 MEDIA_LOG_D("Erase preferred device by type");
144 std::lock_guard<std::mutex> lockEventMap(perferredDeviceMutex_);
145 auto iter = perferredDevices_.find(preferredType);
146 if (iter != perferredDevices_.end()) {
147 perferredDevices_.erase(iter);
148 return SUCCESS;
149 }
150 return ERROR;
151 }
152 } // namespace MediaMonitor
153 } // namespace Media
154 } // namespace OHOS