1 /*
2 * Copyright (c) 2022 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 "daudio_source_service.h"
17
18 #include "if_system_ability_manager.h"
19 #include "ipc_skeleton.h"
20 #include "ipc_types.h"
21 #include "iservice_registry.h"
22 #include "string_ex.h"
23 #include "system_ability_definition.h"
24
25 #include "daudio_constants.h"
26 #include "daudio_errorcode.h"
27 #include "daudio_hisysevent.h"
28 #include "daudio_log.h"
29 #include "daudio_source_manager.h"
30 #include "daudio_util.h"
31
32 #undef DH_LOG_TAG
33 #define DH_LOG_TAG "DAudioSourceService"
34
35 namespace OHOS {
36 namespace DistributedHardware {
37 REGISTER_SYSTEM_ABILITY_BY_ID(DAudioSourceService, DISTRIBUTED_HARDWARE_AUDIO_SOURCE_SA_ID, true);
OnStart()38 void DAudioSourceService::OnStart()
39 {
40 DHLOGI("Distributed audio service on start.");
41 if (!Init()) {
42 DHLOGE("Init service failed.");
43 return;
44 }
45 DHLOGI("Start distributed audio service success.");
46 }
47
OnStop()48 void DAudioSourceService::OnStop()
49 {
50 DHLOGI("Distributed audio service on stop.");
51 isServiceStarted_ = false;
52 }
53
Init()54 bool DAudioSourceService::Init()
55 {
56 if (!isServiceStarted_) {
57 DHLOGI("Publish distributed audio service.");
58 bool ret = Publish(this);
59 if (!ret) {
60 DHLOGE("Publish service failed.");
61 return false;
62 }
63 isServiceStarted_ = true;
64 }
65 return true;
66 }
67
InitSource(const std::string & params,const sptr<IDAudioIpcCallback> & callback)68 int32_t DAudioSourceService::InitSource(const std::string ¶ms, const sptr<IDAudioIpcCallback> &callback)
69 {
70 DHLOGI("Init source service.");
71 (void)params;
72 int32_t ret = DAudioSourceManager::GetInstance().Init(callback);
73 if (ret != DH_SUCCESS) {
74 DHLOGE("Distributed audio source manager init failed.");
75 return ret;
76 }
77 return DH_SUCCESS;
78 }
79
ReleaseSource()80 int32_t DAudioSourceService::ReleaseSource()
81 {
82 DHLOGI("Release source service.");
83 DAudioHisysevent::GetInstance().SysEventWriteBehavior(DAUDIO_EXIT, "daudio source sa exit success.");
84 DAudioSourceManager::GetInstance().UnInit();
85 DHLOGI("Audio source service process exit.");
86 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
87 if (systemAbilityMgr == nullptr) {
88 DHLOGE("Failed to get systemabilitymanager.");
89 return ERR_DH_AUDIO_BAD_VALUE;
90 }
91 int32_t ret = systemAbilityMgr->UnloadSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SOURCE_SA_ID);
92 if (ret != DH_SUCCESS) {
93 DHLOGE("Source systemabilitymgr unloadsystemability failed, ret: %d", ret);
94 return ERR_DH_AUDIO_BAD_VALUE;
95 }
96 DHLOGI("Source systemabilitymgr unloadsystemability successfully!");
97 return DH_SUCCESS;
98 }
99
RegisterDistributedHardware(const std::string & devId,const std::string & dhId,const EnableParam & param,const std::string & reqId)100 int32_t DAudioSourceService::RegisterDistributedHardware(const std::string &devId, const std::string &dhId,
101 const EnableParam ¶m, const std::string &reqId)
102 {
103 DHLOGI("Register distributed audio device, devId: %s, dhId: %s.", GetAnonyString(devId).c_str(),
104 dhId.c_str());
105 std::string version = param.version;
106 std::string attrs = param.attrs;
107 return DAudioSourceManager::GetInstance().EnableDAudio(devId, dhId, version, attrs, reqId);
108 }
109
UnregisterDistributedHardware(const std::string & devId,const std::string & dhId,const std::string & reqId)110 int32_t DAudioSourceService::UnregisterDistributedHardware(const std::string &devId, const std::string &dhId,
111 const std::string &reqId)
112 {
113 DHLOGI("Unregister distributed audio device, devId: %s, dhId: %s.", GetAnonyString(devId).c_str(),
114 dhId.c_str());
115 return DAudioSourceManager::GetInstance().DisableDAudio(devId, dhId, reqId);
116 }
117
ConfigDistributedHardware(const std::string & devId,const std::string & dhId,const std::string & key,const std::string & value)118 int32_t DAudioSourceService::ConfigDistributedHardware(const std::string &devId, const std::string &dhId,
119 const std::string &key, const std::string &value)
120 {
121 DHLOGI("Config distributed audio device, devId: %s, dhId: %s.", GetAnonyString(devId).c_str(),
122 dhId.c_str());
123 return ERR_DH_AUDIO_SA_FUNCTION_NOT_IMPLEMENT;
124 }
125
DAudioNotify(const std::string & devId,const std::string & dhId,const int32_t eventType,const std::string & eventContent)126 void DAudioSourceService::DAudioNotify(const std::string &devId, const std::string &dhId, const int32_t eventType,
127 const std::string &eventContent)
128 {
129 DHLOGD("Notify distributed audio device, devId: %s, dhId: %s.", GetAnonyString(devId).c_str(),
130 dhId.c_str());
131 DAudioSourceManager::GetInstance().HandleDAudioNotify(devId, dhId, eventType, eventContent);
132 }
133
Dump(int32_t fd,const std::vector<std::u16string> & args)134 int DAudioSourceService::Dump(int32_t fd, const std::vector<std::u16string>& args)
135 {
136 DHLOGD("Distributed audio source service dump.");
137 std::string result;
138 std::vector<std::string> argsStr;
139
140 std::transform(args.cbegin(), args.cend(), std::back_inserter(argsStr),
141 [](const std::u16string& item) { return Str16ToStr8(item); });
142
143 if (!DaudioHidumper::GetInstance().Dump(argsStr, result)) {
144 DHLOGE("Hidump error");
145 return ERR_DH_AUDIO_BAD_VALUE;
146 }
147
148 int ret = dprintf(fd, "%s\n", result.c_str());
149 if (ret < 0) {
150 DHLOGE("Dprintf error");
151 return ERR_DH_AUDIO_BAD_VALUE;
152 }
153
154 return DH_SUCCESS;
155 }
156 } // namespace DistributedHardware
157 } // namespace OHOS