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 DHLOGD("Audio source service process exit.");
86 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
87 CHECK_NULL_RETURN(systemAbilityMgr, ERR_DH_AUDIO_NULLPTR);
88 int32_t ret = systemAbilityMgr->UnloadSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SOURCE_SA_ID);
89 if (ret != DH_SUCCESS) {
90 DHLOGE("Source systemabilitymgr unloadsystemability failed, ret: %{public}d", ret);
91 return ERR_DH_AUDIO_SA_LOAD_FAILED;
92 }
93 DHLOGD("Source systemabilitymgr unloadsystemability successfully!");
94 return DH_SUCCESS;
95 }
96
RegisterDistributedHardware(const std::string & devId,const std::string & dhId,const EnableParam & param,const std::string & reqId)97 int32_t DAudioSourceService::RegisterDistributedHardware(const std::string &devId, const std::string &dhId,
98 const EnableParam ¶m, const std::string &reqId)
99 {
100 DHLOGI("Register distributed audio device, devId: %{public}s, dhId: %{public}s.", GetAnonyString(devId).c_str(),
101 dhId.c_str());
102 std::string version = param.sinkVersion;
103 std::string attrs = param.sinkAttrs;
104 return DAudioSourceManager::GetInstance().EnableDAudio(devId, dhId, version, attrs, reqId);
105 }
106
UnregisterDistributedHardware(const std::string & devId,const std::string & dhId,const std::string & reqId)107 int32_t DAudioSourceService::UnregisterDistributedHardware(const std::string &devId, const std::string &dhId,
108 const std::string &reqId)
109 {
110 DHLOGI("Unregister distributed audio device, devId: %{public}s, dhId: %{public}s.", GetAnonyString(devId).c_str(),
111 dhId.c_str());
112 return DAudioSourceManager::GetInstance().DisableDAudio(devId, dhId, reqId);
113 }
114
ConfigDistributedHardware(const std::string & devId,const std::string & dhId,const std::string & key,const std::string & value)115 int32_t DAudioSourceService::ConfigDistributedHardware(const std::string &devId, const std::string &dhId,
116 const std::string &key, const std::string &value)
117 {
118 DHLOGI("Config distributed audio device, devId: %{public}s, dhId: %{public}s.", GetAnonyString(devId).c_str(),
119 dhId.c_str());
120 return DH_SUCCESS;
121 }
122
DAudioNotify(const std::string & devId,const std::string & dhId,const int32_t eventType,const std::string & eventContent)123 void DAudioSourceService::DAudioNotify(const std::string &devId, const std::string &dhId, const int32_t eventType,
124 const std::string &eventContent)
125 {
126 DHLOGD("Notify distributed audio device, devId: %{public}s, dhId: %{public}s.", GetAnonyString(devId).c_str(),
127 dhId.c_str());
128 DAudioSourceManager::GetInstance().HandleDAudioNotify(devId, dhId, eventType, eventContent);
129 }
130
Dump(int32_t fd,const std::vector<std::u16string> & args)131 int DAudioSourceService::Dump(int32_t fd, const std::vector<std::u16string>& args)
132 {
133 DHLOGD("Distributed audio source service dump.");
134 std::string result;
135 std::vector<std::string> argsStr;
136
137 std::transform(args.cbegin(), args.cend(), std::back_inserter(argsStr),
138 [](const std::u16string& item) { return Str16ToStr8(item); });
139
140 if (!DaudioHidumper::GetInstance().Dump(argsStr, result)) {
141 DHLOGE("Hidump error");
142 return ERR_DH_AUDIO_BAD_VALUE;
143 }
144
145 int ret = dprintf(fd, "%s\n", result.c_str());
146 if (ret < 0) {
147 DHLOGE("Dprintf error");
148 return ERR_DH_AUDIO_BAD_VALUE;
149 }
150
151 return DH_SUCCESS;
152 }
153 } // namespace DistributedHardware
154 } // namespace OHOS