1 /*
2  * Copyright (c) 2022-2024 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 #include "avcontroller_callback_stub.h"
16 #include "avsession_errors.h"
17 #include "avsession_log.h"
18 #include "avsession_trace.h"
19 
20 namespace OHOS::AVSession {
CheckInterfaceToken(MessageParcel & data)21 bool AVControllerCallbackStub::CheckInterfaceToken(MessageParcel& data)
22 {
23     auto localDescriptor = IAVControllerCallback::GetDescriptor();
24     auto remoteDescriptor = data.ReadInterfaceToken();
25     if (remoteDescriptor != localDescriptor) {
26         SLOGI("interface token is not equal");
27         return false;
28     }
29     return true;
30 }
31 
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)32 int32_t AVControllerCallbackStub::OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply,
33     MessageOption &option)
34 {
35     if (!CheckInterfaceToken(data)) {
36         return AVSESSION_ERROR;
37     }
38     if (code >= static_cast<uint32_t>(IAVControllerCallback::CONTROLLER_CMD_ON_SESSION_DESTROY)
39         && code < static_cast<uint32_t>(IAVControllerCallback::CONTROLLER_CMD_MAX)) {
40         return handlers[code](data, reply);
41     }
42     return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
43 }
44 
HandleOnSessionDestroy(MessageParcel & data,MessageParcel & reply)45 int32_t AVControllerCallbackStub::HandleOnSessionDestroy(MessageParcel& data, MessageParcel& reply)
46 {
47     OnSessionDestroy();
48     return ERR_NONE;
49 }
50 
HandleOnAVCallMetadataChange(MessageParcel & data,MessageParcel & reply)51 int32_t AVControllerCallbackStub::HandleOnAVCallMetadataChange(MessageParcel& data, MessageParcel& reply)
52 {
53     sptr<AVCallMetaData> metaData = data.ReadParcelable<AVCallMetaData>();
54 
55     CHECK_AND_RETURN_RET_LOG(metaData != nullptr, ERR_NONE, "read AVCall MetaData failed");
56     AVSESSION_TRACE_SYNC_START("AVControllerCallbackStub::OnAVCallMetaDataChange");
57     OnAVCallMetaDataChange(*metaData);
58     return ERR_NONE;
59 }
60 
HandleOnAVCallStateChange(MessageParcel & data,MessageParcel & reply)61 int32_t AVControllerCallbackStub::HandleOnAVCallStateChange(MessageParcel& data, MessageParcel& reply)
62 {
63     sptr<AVCallState> state = data.ReadParcelable<AVCallState>();
64 
65     CHECK_AND_RETURN_RET_LOG(state != nullptr, ERR_NONE, "read AVCallState failed");
66     AVSESSION_TRACE_SYNC_START("AVControllerCallbackStub::OnAVCallStateChange");
67     OnAVCallStateChange(*state);
68     return ERR_NONE;
69 }
70 
HandleOnPlaybackStateChange(MessageParcel & data,MessageParcel & reply)71 int32_t AVControllerCallbackStub::HandleOnPlaybackStateChange(MessageParcel& data, MessageParcel& reply)
72 {
73     sptr<AVPlaybackState> state = data.ReadParcelable<AVPlaybackState>();
74     if (state == nullptr) {
75         SLOGE("HandleOnPlaybackStateChange meet state nullptr, return");
76         return ERR_NONE;
77     }
78 
79     std::lock_guard lockGuard(onPlaybackChangeLock_);
80     SLOGD("do HandleOnPlaybackStateChange");
81 
82     CHECK_AND_RETURN_RET_LOG(state != nullptr, ERR_NONE, "read PlaybackState failed");
83     AVSESSION_TRACE_SYNC_START("AVControllerCallbackStub::OnPlaybackStateChange");
84     OnPlaybackStateChange(*state);
85     return ERR_NONE;
86 }
87 
HandleOnMetadataChange(MessageParcel & data,MessageParcel & reply)88 int32_t AVControllerCallbackStub::HandleOnMetadataChange(MessageParcel& data, MessageParcel& reply)
89 {
90     std::lock_guard lockGuard(onMetadataChangeLock_);
91     SLOGD("do HandleOnMetadataChange");
92 
93     AVSESSION_TRACE_SYNC_START("AVControllerCallbackStub::OnMetaDataChange");
94     int twoImageLength = data.ReadInt32();
95     SLOGD("HandleOnMetadataChange read length from twoImage %{public}d", twoImageLength);
96     if (twoImageLength <= 0 || twoImageLength > MAX_IMAGE_SIZE) {
97         sptr avMetaData = data.ReadParcelable<AVMetaData>();
98         CHECK_AND_RETURN_RET_LOG(avMetaData != nullptr, ERR_NONE, "read MetaData failed");
99         OnMetaDataChange(*avMetaData);
100         return ERR_NONE;
101     }
102 
103     AVMetaData meta;
104     AVMetaData::UnmarshallingExceptImg(data, meta);
105     const char *buffer = nullptr;
106     buffer = reinterpret_cast<const char *>(data.ReadRawData(twoImageLength));
107     int mediaImageLength = meta.GetMediaLength();
108     if (buffer == nullptr || mediaImageLength <= 0 || mediaImageLength > twoImageLength) {
109         SLOGE("read raw data with null %{public}d, or err media img length:%{public}d",
110             static_cast<int>(buffer == nullptr), mediaImageLength);
111         OnMetaDataChange(meta);
112         return ERR_NONE;
113     }
114 
115     auto mediaPixelMap = new (std::nothrow) AVSessionPixelMap();
116     std::vector<uint8_t> mediaImageBuffer;
117     for (int i = 0; i < mediaImageLength; i++) {
118         mediaImageBuffer.push_back((uint8_t)buffer[i]);
119     }
120     mediaPixelMap->SetInnerImgBuffer(mediaImageBuffer);
121     meta.SetMediaImage(std::shared_ptr<AVSessionPixelMap>(mediaPixelMap));
122 
123     if (twoImageLength > mediaImageLength) {
124         auto avQueuePixelMap = new (std::nothrow) AVSessionPixelMap();
125         std::vector<uint8_t> avQueueImageBuffer;
126         for (int j = mediaImageLength; j < twoImageLength; j++) {
127             avQueueImageBuffer.push_back((uint8_t)buffer[j]);
128         }
129         avQueuePixelMap->SetInnerImgBuffer(avQueueImageBuffer);
130         meta.SetAVQueueImage(std::shared_ptr<AVSessionPixelMap>(avQueuePixelMap));
131     }
132     OnMetaDataChange(meta);
133     return ERR_NONE;
134 }
135 
HandleOnActiveStateChange(MessageParcel & data,MessageParcel & reply)136 int32_t AVControllerCallbackStub::HandleOnActiveStateChange(MessageParcel& data, MessageParcel& reply)
137 {
138     bool isActive = false;
139     CHECK_AND_RETURN_RET_LOG(data.ReadBool(isActive), ERR_NONE, "read isActive failed");
140     OnActiveStateChange(isActive);
141     return ERR_NONE;
142 }
143 
HandleOnValidCommandChange(MessageParcel & data,MessageParcel & reply)144 int32_t AVControllerCallbackStub::HandleOnValidCommandChange(MessageParcel& data, MessageParcel& reply)
145 {
146     std::vector<int32_t> cmds;
147     CHECK_AND_RETURN_RET_LOG(data.ReadInt32Vector(&cmds), ERR_NONE, "read int32 vector failed");
148     std::lock_guard lockGuard(onValidCommandChangeLock_);
149     SLOGD("do HandleOnValidCommandChange with cmd list size %{public}d", static_cast<int>(cmds.size()));
150 
151     OnValidCommandChange(cmds);
152     return ERR_NONE;
153 }
154 
HandleOnOutputDeviceChange(MessageParcel & data,MessageParcel & reply)155 int32_t AVControllerCallbackStub::HandleOnOutputDeviceChange(MessageParcel& data, MessageParcel& reply)
156 {
157     int32_t connectionState;
158     CHECK_AND_RETURN_RET_LOG(data.ReadInt32(connectionState), false, "write deviceInfoSize failed");
159     OutputDeviceInfo outputDeviceInfo;
160     int32_t deviceInfoSize;
161     CHECK_AND_RETURN_RET_LOG(data.ReadInt32(deviceInfoSize), false, "write deviceInfoSize failed");
162     int32_t maxDeviceInfoSize = 1000; // A maximum of 1000 device change events can be processed at a time
163     CHECK_AND_RETURN_RET_LOG((deviceInfoSize >= 0) && (deviceInfoSize < maxDeviceInfoSize),
164         false, "deviceInfoSize is illegal");
165     for (int i = 0; i < deviceInfoSize; i++) {
166         DeviceInfo deviceInfo;
167         CHECK_AND_RETURN_RET_LOG(data.ReadInt32(deviceInfo.castCategory_), false, "Read castCategory failed");
168         CHECK_AND_RETURN_RET_LOG(data.ReadString(deviceInfo.deviceId_), false, "Read deviceId failed");
169         CHECK_AND_RETURN_RET_LOG(data.ReadString(deviceInfo.deviceName_), false, "Read deviceName failed");
170         CHECK_AND_RETURN_RET_LOG(data.ReadInt32(deviceInfo.deviceType_), false, "Read deviceType failed");
171         CHECK_AND_RETURN_RET_LOG(data.ReadString(deviceInfo.ipAddress_), false, "Read ipAddress failed");
172         CHECK_AND_RETURN_RET_LOG(data.ReadString(deviceInfo.manufacturer_), false, "Read manufacturer failed");
173         CHECK_AND_RETURN_RET_LOG(data.ReadString(deviceInfo.modelName_), false, "Read modelName failed");
174         CHECK_AND_RETURN_RET_LOG(data.ReadInt32(deviceInfo.providerId_), false, "Read providerId failed");
175         CHECK_AND_RETURN_RET_LOG(data.ReadInt32(deviceInfo.supportedProtocols_), false,
176             "Read supportedProtocols failed");
177         CHECK_AND_RETURN_RET_LOG(data.ReadInt32(deviceInfo.authenticationStatus_), false,
178             "Read authenticationStatus failed");
179         int32_t supportedDrmCapabilityLen = 0;
180         CHECK_AND_RETURN_RET_LOG(data.ReadInt32(supportedDrmCapabilityLen), false,
181             "read supportedDrmCapabilityLen failed");
182         std::vector<std::string> supportedDrmCapabilities;
183         int32_t maxSupportedDrmCapabilityLen = 10;
184         CHECK_AND_RETURN_RET_LOG((supportedDrmCapabilityLen >= 0) &&
185             (supportedDrmCapabilityLen <= maxSupportedDrmCapabilityLen), false, "supportedDrmCapabilityLen is illegal");
186         for (int j = 0; j < supportedDrmCapabilityLen; j++) {
187             std::string supportedDrmCapability;
188             CHECK_AND_RETURN_RET_LOG(data.ReadString(supportedDrmCapability), false,
189                 "read supportedDrmCapability failed");
190             supportedDrmCapabilities.emplace_back(supportedDrmCapability);
191         }
192         deviceInfo.supportedDrmCapabilities_ = supportedDrmCapabilities;
193         CHECK_AND_RETURN_RET_LOG(data.ReadBool(deviceInfo.isLegacy_), false, "Read isLegacy failed");
194         CHECK_AND_RETURN_RET_LOG(data.ReadInt32(deviceInfo.mediumTypes_), false, "Read mediumTypes failed");
195         outputDeviceInfo.deviceInfos_.emplace_back(deviceInfo);
196     }
197 
198     OnOutputDeviceChange(connectionState, outputDeviceInfo);
199     return ERR_NONE;
200 }
201 
HandleOnSessionEventChange(MessageParcel & data,MessageParcel & reply)202 int32_t AVControllerCallbackStub::HandleOnSessionEventChange(MessageParcel& data, MessageParcel& reply)
203 {
204     auto event = data.ReadString();
205     sptr want = data.ReadParcelable<AAFwk::WantParams>();
206 
207     CHECK_AND_RETURN_RET_LOG(want != nullptr, ERR_NONE, "read want args failed");
208     AVSESSION_TRACE_SYNC_START("AVControllerCallbackStub::OnSessionEventChange");
209     OnSessionEventChange(event, *want);
210     return ERR_NONE;
211 }
212 
HandleOnQueueItemsChange(MessageParcel & data,MessageParcel & reply)213 int32_t AVControllerCallbackStub::HandleOnQueueItemsChange(MessageParcel& data, MessageParcel& reply)
214 {
215     std::vector<AVQueueItem> items_;
216     int32_t maxItemNumber = 1000; // A maximum of 1000 queue items can be processed at a time
217     int32_t itemNum = data.ReadInt32();
218     CHECK_AND_RETURN_RET_LOG((itemNum >= 0) && (itemNum < maxItemNumber), ERR_NONE, "read int32 itemNum failed");
219     for (int32_t i = 0; i < itemNum; i++) {
220         AVQueueItem *item = data.ReadParcelable<AVQueueItem>();
221         if (item == nullptr) {
222             SLOGE("GetAVQueueItems: read parcelable AVQueueItem failed");
223             delete item;
224             return ERR_UNMARSHALLING;
225         }
226         items_.emplace_back(*item);
227         delete item;
228     }
229     AVSESSION_TRACE_SYNC_START("AVControllerCallbackStub::OnQueueItemsChange");
230     OnQueueItemsChange(items_);
231     return ERR_NONE;
232 }
233 
HandleOnQueueTitleChange(MessageParcel & data,MessageParcel & reply)234 int32_t AVControllerCallbackStub::HandleOnQueueTitleChange(MessageParcel& data, MessageParcel& reply)
235 {
236     auto title = data.ReadString();
237     AVSESSION_TRACE_SYNC_START("AVControllerCallbackStub::OnQueueTitleChange");
238     OnQueueTitleChange(title);
239     return ERR_NONE;
240 }
241 
HandleOnExtrasChange(MessageParcel & data,MessageParcel & reply)242 int32_t AVControllerCallbackStub::HandleOnExtrasChange(MessageParcel& data, MessageParcel& reply)
243 {
244     sptr extras = data.ReadParcelable<AAFwk::WantParams>();
245     CHECK_AND_RETURN_RET_LOG(extras != nullptr, ERR_NONE, "read extras failed");
246     AVSESSION_TRACE_SYNC_START("AVControllerCallbackStub::OnExtrasChange");
247     OnExtrasChange(*extras);
248     return ERR_NONE;
249 }
250 } // namespace OHOS::AVSession
251