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