1 /*
2 * Copyright (c) 2022-2023 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_sink_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_sink_manager.h"
30 #include "daudio_util.h"
31
32 #include "token_setproc.h"
33
34 #undef DH_LOG_TAG
35 #define DH_LOG_TAG "DAudioSinkService"
36
37 namespace OHOS {
38 namespace DistributedHardware {
39 REGISTER_SYSTEM_ABILITY_BY_ID(DAudioSinkService, DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID, true);
40
DAudioSinkService(int32_t saId,bool runOnCreate)41 DAudioSinkService::DAudioSinkService(int32_t saId, bool runOnCreate) : SystemAbility(saId, runOnCreate)
42 {
43 DHLOGD("Distributed audio sink service constructed.");
44 }
45
OnStart()46 void DAudioSinkService::OnStart()
47 {
48 DHLOGI("Distributed audio service on start.");
49 if (!Init()) {
50 DHLOGE("Init service failed.");
51 return;
52 }
53 DHLOGD("Start distributed audio service success.");
54 }
55
OnStop()56 void DAudioSinkService::OnStop()
57 {
58 DHLOGI("Distributed audio service on stop.");
59 isServiceStarted_ = false;
60 }
61
Init()62 bool DAudioSinkService::Init()
63 {
64 DHLOGI("Start init distributed audio service.");
65 if (!isServiceStarted_) {
66 bool ret = Publish(this);
67 if (!ret) {
68 DHLOGE("Publish service failed.");
69 return false;
70 }
71 isServiceStarted_ = true;
72 }
73 DHLOGD("Init distributed audio service success.");
74 return true;
75 }
76
InitSink(const std::string & params,const sptr<IDAudioSinkIpcCallback> & sinkCallback)77 int32_t DAudioSinkService::InitSink(const std::string ¶ms, const sptr<IDAudioSinkIpcCallback> &sinkCallback)
78 {
79 DAudioSinkManager::GetInstance().Init(sinkCallback);
80 auto callerTokenId = GetFirstCallerTokenID();
81 DAudioSinkManager::GetInstance().SetCallerTokenId(callerTokenId);
82 return DH_SUCCESS;
83 }
84
ReleaseSink()85 int32_t DAudioSinkService::ReleaseSink()
86 {
87 DHLOGI("Release sink service.");
88 DAudioSinkManager::GetInstance().UnInit();
89 DHLOGD("Audio sink service process exit.");
90 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
91 CHECK_NULL_RETURN(systemAbilityMgr, ERR_DH_AUDIO_NULLPTR);
92 int32_t ret = systemAbilityMgr->UnloadSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID);
93 if (ret != DH_SUCCESS) {
94 DHLOGE("Sink systemabilitymgr unloadsystemability failed, ret: %{public}d", ret);
95 return ERR_DH_AUDIO_SA_LOAD_FAILED;
96 }
97 DHLOGD("Sink systemabilitymgr unloadsystemability successfully!");
98 return DH_SUCCESS;
99 }
100
SubscribeLocalHardware(const std::string & dhId,const std::string & param)101 int32_t DAudioSinkService::SubscribeLocalHardware(const std::string &dhId, const std::string ¶m)
102 {
103 DHLOGD("Subscribe local hardware.");
104 return DH_SUCCESS;
105 }
106
UnsubscribeLocalHardware(const std::string & dhId)107 int32_t DAudioSinkService::UnsubscribeLocalHardware(const std::string &dhId)
108 {
109 DHLOGD("Unsubscribe local hardware.");
110 return DH_SUCCESS;
111 }
112
DAudioNotify(const std::string & devId,const std::string & dhId,const int32_t eventType,const std::string & eventContent)113 void DAudioSinkService::DAudioNotify(const std::string &devId, const std::string &dhId, const int32_t eventType,
114 const std::string &eventContent)
115 {
116 DHLOGI("DAudioNotify devId:%{public}s, dhId:%{public}s, eventType:%{public}d.", GetAnonyString(devId).c_str(),
117 dhId.c_str(), eventType);
118 DAudioSinkManager::GetInstance().HandleDAudioNotify(devId, dhId, eventType, eventContent);
119 }
120
Dump(int32_t fd,const std::vector<std::u16string> & args)121 int DAudioSinkService::Dump(int32_t fd, const std::vector<std::u16string> &args)
122 {
123 DHLOGD("Distributed audio sink service dump.");
124 std::string result;
125 std::vector<std::string> argsStr;
126
127 std::transform(args.cbegin(), args.cend(), std::back_inserter(argsStr),
128 [](const std::u16string& item) { return Str16ToStr8(item); });
129
130 if (!DaudioSinkHidumper::GetInstance().Dump(argsStr, result)) {
131 DHLOGE("Hidump error");
132 return ERR_DH_AUDIO_BAD_VALUE;
133 }
134
135 int ret = dprintf(fd, "%s\n", result.c_str());
136 if (ret < 0) {
137 DHLOGE("Dprintf error");
138 return ERR_DH_AUDIO_BAD_VALUE;
139 }
140
141 return DH_SUCCESS;
142 }
143
PauseDistributedHardware(const std::string & networkId)144 int32_t DAudioSinkService::PauseDistributedHardware(const std::string &networkId)
145 {
146 DHLOGI("PauseDistributedHardware networkId:%{public}s.", GetAnonyString(networkId).c_str());
147 DAudioSinkManager::GetInstance().PauseDistributedHardware(networkId);
148 return DH_SUCCESS;
149 }
150
ResumeDistributedHardware(const std::string & networkId)151 int32_t DAudioSinkService::ResumeDistributedHardware(const std::string &networkId)
152 {
153 DHLOGI("ResumeDistributedHardware networkId:%{public}s.", GetAnonyString(networkId).c_str());
154 DAudioSinkManager::GetInstance().ResumeDistributedHardware(networkId);
155 return DH_SUCCESS;
156 }
157
StopDistributedHardware(const std::string & networkId)158 int32_t DAudioSinkService::StopDistributedHardware(const std::string &networkId)
159 {
160 DHLOGI("StopDistributedHardware networkId:%{public}s.", GetAnonyString(networkId).c_str());
161 DAudioSinkManager::GetInstance().StopDistributedHardware(networkId);
162 return DH_SUCCESS;
163 }
164 } // namespace DistributedHardware
165 } // namespace OHOS