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_stub.h"
17 
18 #include "accesstoken_kit.h"
19 #include "ipc_skeleton.h"
20 #include "tokenid_kit.h"
21 
22 #include "daudio_constants.h"
23 #include "daudio_errorcode.h"
24 #include "daudio_ipc_interface_code.h"
25 #include "daudio_log.h"
26 #include "daudio_sink_ipc_callback_proxy.h"
27 
28 #undef DH_LOG_TAG
29 #define DH_LOG_TAG "DAudioSinkStub"
30 
31 namespace OHOS {
32 namespace DistributedHardware {
DAudioSinkStub()33 DAudioSinkStub::DAudioSinkStub() : IRemoteStub(true)
34 {
35     DHLOGD("Distributed audio sink stub constructed.");
36     memberFuncMap_[static_cast<uint32_t>(IDAudioSinkInterfaceCode::INIT_SINK)] =
37         &DAudioSinkStub::InitSinkInner;
38     memberFuncMap_[static_cast<uint32_t>(IDAudioSinkInterfaceCode::RELEASE_SINK)] =
39         &DAudioSinkStub::ReleaseSinkInner;
40     memberFuncMap_[static_cast<uint32_t>(IDAudioSinkInterfaceCode::SUBSCRIBE_LOCAL_HARDWARE)] =
41         &DAudioSinkStub::SubscribeLocalHardwareInner;
42     memberFuncMap_[static_cast<uint32_t>(IDAudioSinkInterfaceCode::UNSUBSCRIBE_LOCAL_HARDWARE)] =
43         &DAudioSinkStub::UnsubscribeLocalHardwareInner;
44     memberFuncMap_[static_cast<uint32_t>(IDAudioSinkInterfaceCode::DAUDIO_NOTIFY)] =
45         &DAudioSinkStub::DAudioNotifyInner;
46     memberFuncMap_[static_cast<uint32_t>(IDAudioSinkInterfaceCode::PAUSE_DISTRIBUTED_HARDWARE)] =
47         &DAudioSinkStub::PauseDistributedHardwareInner;
48     memberFuncMap_[static_cast<uint32_t>(IDAudioSinkInterfaceCode::RESUME_DISTRIBUTED_HARDWARE)] =
49         &DAudioSinkStub::ResumeDistributedHardwareInner;
50     memberFuncMap_[static_cast<uint32_t>(IDAudioSinkInterfaceCode::STOP_DISTRIBUTED_HARDWARE)] =
51         &DAudioSinkStub::StopDistributedHardwareInner;
52 }
53 
~DAudioSinkStub()54 DAudioSinkStub::~DAudioSinkStub()
55 {
56     DHLOGD("Distributed audio sink stub deconstructed.");
57 }
58 
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)59 int32_t DAudioSinkStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
60 {
61     DHLOGI("On remote request, code: %{public}d.", code);
62     std::u16string desc = DAudioSinkStub::GetDescriptor();
63     std::u16string remoteDesc = data.ReadInterfaceToken();
64     if (desc != remoteDesc) {
65         DHLOGE("RemoteDesc is invalid.");
66         return ERR_DH_AUDIO_SA_INVALID_INTERFACE_TOKEN;
67     }
68 
69     switch (code) {
70         case static_cast<uint32_t>(IDAudioSinkInterfaceCode::INIT_SINK):
71             return InitSinkInner(data, reply, option);
72         case static_cast<uint32_t>(IDAudioSinkInterfaceCode::RELEASE_SINK):
73             return ReleaseSinkInner(data, reply, option);
74         case static_cast<uint32_t>(IDAudioSinkInterfaceCode::SUBSCRIBE_LOCAL_HARDWARE):
75             return SubscribeLocalHardwareInner(data, reply, option);
76         case static_cast<uint32_t>(IDAudioSinkInterfaceCode::UNSUBSCRIBE_LOCAL_HARDWARE):
77             return UnsubscribeLocalHardwareInner(data, reply, option);
78         case static_cast<uint32_t>(IDAudioSinkInterfaceCode::DAUDIO_NOTIFY):
79             return DAudioNotifyInner(data, reply, option);
80         case static_cast<uint32_t>(IDAudioSinkInterfaceCode::PAUSE_DISTRIBUTED_HARDWARE):
81             return PauseDistributedHardwareInner(data, reply, option);
82         case static_cast<uint32_t>(IDAudioSinkInterfaceCode::RESUME_DISTRIBUTED_HARDWARE):
83             return ResumeDistributedHardwareInner(data, reply, option);
84         case static_cast<uint32_t>(IDAudioSinkInterfaceCode::STOP_DISTRIBUTED_HARDWARE):
85             return StopDistributedHardwareInner(data, reply, option);
86         default:
87             DHLOGE("Invalid request code.");
88             return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
89     }
90     return ERR_DH_AUDIO_NOT_FOUND_KEY;
91 }
92 
VerifyPermission()93 bool DAudioSinkStub::VerifyPermission()
94 {
95     Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
96     int result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken, AUDIO_PERMISSION_NAME);
97     if (result == Security::AccessToken::PERMISSION_GRANTED) {
98         return true;
99     }
100     return false;
101 }
102 
InitSinkInner(MessageParcel & data,MessageParcel & reply,MessageOption & option)103 int32_t DAudioSinkStub::InitSinkInner(MessageParcel &data, MessageParcel &reply, MessageOption &option)
104 {
105     if (!VerifyPermission()) {
106         DHLOGE("Permission verification fail.");
107         return ERR_DH_AUDIO_SA_PERMISSION_FAIED;
108     }
109     std::string param = data.ReadString();
110     sptr<IRemoteObject> remoteObject = data.ReadRemoteObject();
111     CHECK_NULL_RETURN(remoteObject, ERR_DH_AUDIO_NULLPTR);
112     sptr<DAudioSinkIpcCallbackProxy> dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject));
113     int32_t ret = InitSink(param, dAudioSinkIpcCallbackProxy);
114     reply.WriteInt32(ret);
115     return DH_SUCCESS;
116 }
117 
ReleaseSinkInner(MessageParcel & data,MessageParcel & reply,MessageOption & option)118 int32_t DAudioSinkStub::ReleaseSinkInner(MessageParcel &data, MessageParcel &reply, MessageOption &option)
119 {
120     if (!VerifyPermission()) {
121         DHLOGE("Permission verification fail.");
122         return ERR_DH_AUDIO_SA_PERMISSION_FAIED;
123     }
124     int32_t ret = ReleaseSink();
125     reply.WriteInt32(ret);
126     return DH_SUCCESS;
127 }
128 
SubscribeLocalHardwareInner(MessageParcel & data,MessageParcel & reply,MessageOption & option)129 int32_t DAudioSinkStub::SubscribeLocalHardwareInner(MessageParcel &data, MessageParcel &reply, MessageOption &option)
130 {
131     if (!VerifyPermission()) {
132         DHLOGE("Permission verification fail.");
133         return ERR_DH_AUDIO_SA_PERMISSION_FAIED;
134     }
135     std::string dhId = data.ReadString();
136     std::string param = data.ReadString();
137     int32_t ret = SubscribeLocalHardware(dhId, param);
138     reply.WriteInt32(ret);
139     return DH_SUCCESS;
140 }
141 
UnsubscribeLocalHardwareInner(MessageParcel & data,MessageParcel & reply,MessageOption & option)142 int32_t DAudioSinkStub::UnsubscribeLocalHardwareInner(MessageParcel &data, MessageParcel &reply, MessageOption &option)
143 {
144     if (!VerifyPermission()) {
145         DHLOGE("Permission verification fail.");
146         return ERR_DH_AUDIO_SA_PERMISSION_FAIED;
147     }
148     std::string dhId = data.ReadString();
149     int32_t ret = UnsubscribeLocalHardware(dhId);
150     reply.WriteInt32(ret);
151     return DH_SUCCESS;
152 }
153 
DAudioNotifyInner(MessageParcel & data,MessageParcel & reply,MessageOption & option)154 int32_t DAudioSinkStub::DAudioNotifyInner(MessageParcel &data, MessageParcel &reply, MessageOption &option)
155 {
156     std::string networkId = data.ReadString();
157     std::string dhId = data.ReadString();
158     int32_t eventType = data.ReadInt32();
159     std::string eventContent = data.ReadString();
160 
161     DAudioNotify(networkId, dhId, eventType, eventContent);
162     return DH_SUCCESS;
163 }
164 
PauseDistributedHardwareInner(MessageParcel & data,MessageParcel & reply,MessageOption & option)165 int32_t DAudioSinkStub::PauseDistributedHardwareInner(MessageParcel &data, MessageParcel &reply, MessageOption &option)
166 {
167     if (!VerifyPermission()) {
168         DHLOGE("Permission verification fail.");
169         return ERR_DH_AUDIO_SA_PERMISSION_FAIED;
170     }
171     std::string networkId = data.ReadString();
172     int32_t ret = PauseDistributedHardware(networkId);
173     reply.WriteInt32(ret);
174     return DH_SUCCESS;
175 }
176 
ResumeDistributedHardwareInner(MessageParcel & data,MessageParcel & reply,MessageOption & option)177 int32_t DAudioSinkStub::ResumeDistributedHardwareInner(MessageParcel &data, MessageParcel &reply, MessageOption &option)
178 {
179     if (!VerifyPermission()) {
180         DHLOGE("Permission verification fail.");
181         return ERR_DH_AUDIO_SA_PERMISSION_FAIED;
182     }
183     std::string networkId = data.ReadString();
184     int32_t ret = ResumeDistributedHardware(networkId);
185     reply.WriteInt32(ret);
186     return DH_SUCCESS;
187 }
188 
StopDistributedHardwareInner(MessageParcel & data,MessageParcel & reply,MessageOption & option)189 int32_t DAudioSinkStub::StopDistributedHardwareInner(MessageParcel &data, MessageParcel &reply, MessageOption &option)
190 {
191     if (!VerifyPermission()) {
192         DHLOGE("Permission verification fail.");
193         return ERR_DH_AUDIO_SA_PERMISSION_FAIED;
194     }
195     std::string networkId = data.ReadString();
196     int32_t ret = StopDistributedHardware(networkId);
197     reply.WriteInt32(ret);
198     return DH_SUCCESS;
199 }
200 } // namespace DistributedHardware
201 } // namespace OHOS