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 #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 < CONTROLLER_CMD_MAX) {
39 return (this->*handlers[code])(data, reply);
40 }
41 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
42 }
43
HandleOnSessionDestroy(MessageParcel & data,MessageParcel & reply)44 int32_t AVControllerCallbackStub::HandleOnSessionDestroy(MessageParcel& data, MessageParcel& reply)
45 {
46 OnSessionDestroy();
47 return ERR_NONE;
48 }
49
HandleOnAVCallMetadataChange(MessageParcel & data,MessageParcel & reply)50 int32_t AVControllerCallbackStub::HandleOnAVCallMetadataChange(MessageParcel& data, MessageParcel& reply)
51 {
52 sptr<AVCallMetaData> metaData = data.ReadParcelable<AVCallMetaData>();
53
54 CHECK_AND_RETURN_RET_LOG(metaData != nullptr, ERR_NONE, "read AVCall MetaData failed");
55 AVSESSION_TRACE_SYNC_START("AVControllerCallbackStub::OnAVCallMetaDataChange");
56 OnAVCallMetaDataChange(*metaData);
57 return ERR_NONE;
58 }
59
HandleOnAVCallStateChange(MessageParcel & data,MessageParcel & reply)60 int32_t AVControllerCallbackStub::HandleOnAVCallStateChange(MessageParcel& data, MessageParcel& reply)
61 {
62 sptr<AVCallState> state = data.ReadParcelable<AVCallState>();
63
64 CHECK_AND_RETURN_RET_LOG(state != nullptr, ERR_NONE, "read AVCallState failed");
65 AVSESSION_TRACE_SYNC_START("AVControllerCallbackStub::OnAVCallStateChange");
66 OnAVCallStateChange(*state);
67 return ERR_NONE;
68 }
69
HandleOnPlaybackStateChange(MessageParcel & data,MessageParcel & reply)70 int32_t AVControllerCallbackStub::HandleOnPlaybackStateChange(MessageParcel& data, MessageParcel& reply)
71 {
72 sptr<AVPlaybackState> state = data.ReadParcelable<AVPlaybackState>();
73
74 CHECK_AND_RETURN_RET_LOG(state != nullptr, ERR_NONE, "read PlaybackState failed");
75 AVSESSION_TRACE_SYNC_START("AVControllerCallbackStub::OnPlaybackStateChange");
76 OnPlaybackStateChange(*state);
77 return ERR_NONE;
78 }
79
HandleOnMetadataChange(MessageParcel & data,MessageParcel & reply)80 int32_t AVControllerCallbackStub::HandleOnMetadataChange(MessageParcel& data, MessageParcel& reply)
81 {
82 AVSESSION_TRACE_SYNC_START("AVControllerCallbackStub::OnMetaDataChange");
83 int twoImageLength = data.ReadInt32();
84 SLOGD("read length from twoImage %{public}d", twoImageLength);
85 if (twoImageLength <= 0 || twoImageLength > MAX_IMAGE_SIZE) {
86 sptr avMetaData = data.ReadParcelable<AVMetaData>();
87 CHECK_AND_RETURN_RET_LOG(avMetaData != nullptr, ERR_NONE, "read MetaData failed");
88 OnMetaDataChange(*avMetaData);
89 return ERR_NONE;
90 }
91
92 AVMetaData meta;
93 AVMetaData::UnmarshallingExceptImg(data, meta);
94 const char *buffer = nullptr;
95 if ((buffer = reinterpret_cast<const char *>(data.ReadRawData(twoImageLength))) == nullptr) {
96 SLOGE("read raw data failed, length = %{public}d", twoImageLength);
97 return AVSESSION_ERROR;
98 }
99
100 int mediaImageLength = meta.GetMediaLength();
101 auto mediaPixelMap = new (std::nothrow) AVSessionPixelMap();
102 std::vector<uint8_t> mediaImageBuffer;
103 for (int i = 0; i < mediaImageLength; i++) {
104 mediaImageBuffer.push_back((uint8_t)buffer[i]);
105 }
106 mediaPixelMap->SetInnerImgBuffer(mediaImageBuffer);
107 meta.SetMediaImage(std::shared_ptr<AVSessionPixelMap>(mediaPixelMap));
108
109 if (twoImageLength > mediaImageLength) {
110 auto avQueuePixelMap = new (std::nothrow) AVSessionPixelMap();
111 std::vector<uint8_t> avQueueImageBuffer;
112 for (int j = mediaImageLength; j < twoImageLength; j++) {
113 avQueueImageBuffer.push_back((uint8_t)buffer[j]);
114 }
115 avQueuePixelMap->SetInnerImgBuffer(avQueueImageBuffer);
116 meta.SetAVQueueImage(std::shared_ptr<AVSessionPixelMap>(avQueuePixelMap));
117 }
118 OnMetaDataChange(meta);
119 return ERR_NONE;
120 }
121
HandleOnActiveStateChange(MessageParcel & data,MessageParcel & reply)122 int32_t AVControllerCallbackStub::HandleOnActiveStateChange(MessageParcel& data, MessageParcel& reply)
123 {
124 bool isActive = false;
125 CHECK_AND_RETURN_RET_LOG(data.ReadBool(isActive), ERR_NONE, "read isActive failed");
126 OnActiveStateChange(isActive);
127 return ERR_NONE;
128 }
129
HandleOnValidCommandChange(MessageParcel & data,MessageParcel & reply)130 int32_t AVControllerCallbackStub::HandleOnValidCommandChange(MessageParcel& data, MessageParcel& reply)
131 {
132 std::vector<int32_t> cmds;
133 CHECK_AND_RETURN_RET_LOG(data.ReadInt32Vector(&cmds), ERR_NONE, "read int32 vector failed");
134 OnValidCommandChange(cmds);
135 return ERR_NONE;
136 }
137
HandleOnOutputDeviceChange(MessageParcel & data,MessageParcel & reply)138 int32_t AVControllerCallbackStub::HandleOnOutputDeviceChange(MessageParcel& data, MessageParcel& reply)
139 {
140 int32_t connectionState;
141 CHECK_AND_RETURN_RET_LOG(data.ReadInt32(connectionState), false, "write deviceInfoSize failed");
142 OutputDeviceInfo outputDeviceInfo;
143 int32_t deviceInfoSize;
144 CHECK_AND_RETURN_RET_LOG(data.ReadInt32(deviceInfoSize), false, "write deviceInfoSize failed");
145 int32_t maxDeviceInfoSize = 1000; // A maximum of 1000 device change events can be processed at a time
146 CHECK_AND_RETURN_RET_LOG((deviceInfoSize >= 0) && (deviceInfoSize < maxDeviceInfoSize),
147 false, "deviceInfoSize is illegal");
148 for (int i = 0; i < deviceInfoSize; i++) {
149 DeviceInfo deviceInfo;
150 CHECK_AND_RETURN_RET_LOG(data.ReadInt32(deviceInfo.castCategory_), false, "Read castCategory failed");
151 CHECK_AND_RETURN_RET_LOG(data.ReadString(deviceInfo.deviceId_), false, "Read deviceId failed");
152 CHECK_AND_RETURN_RET_LOG(data.ReadString(deviceInfo.deviceName_), false, "Read deviceName failed");
153 CHECK_AND_RETURN_RET_LOG(data.ReadInt32(deviceInfo.deviceType_), false, "Read deviceType failed");
154 CHECK_AND_RETURN_RET_LOG(data.ReadString(deviceInfo.ipAddress_), false, "Read ipAddress failed");
155 CHECK_AND_RETURN_RET_LOG(data.ReadInt32(deviceInfo.providerId_), false, "Read providerId failed");
156 CHECK_AND_RETURN_RET_LOG(data.ReadInt32(deviceInfo.supportedProtocols_), false,
157 "Read supportedProtocols failed");
158 CHECK_AND_RETURN_RET_LOG(data.ReadInt32(deviceInfo.authenticationStatus_), false,
159 "Read authenticationStatus failed");
160 outputDeviceInfo.deviceInfos_.emplace_back(deviceInfo);
161 }
162
163 OnOutputDeviceChange(connectionState, outputDeviceInfo);
164 return ERR_NONE;
165 }
166
HandleOnSessionEventChange(MessageParcel & data,MessageParcel & reply)167 int32_t AVControllerCallbackStub::HandleOnSessionEventChange(MessageParcel& data, MessageParcel& reply)
168 {
169 auto event = data.ReadString();
170 sptr want = data.ReadParcelable<AAFwk::WantParams>();
171
172 CHECK_AND_RETURN_RET_LOG(want != nullptr, ERR_NONE, "read want args failed");
173 AVSESSION_TRACE_SYNC_START("AVControllerCallbackStub::OnSessionEventChange");
174 OnSessionEventChange(event, *want);
175 return ERR_NONE;
176 }
177
HandleOnQueueItemsChange(MessageParcel & data,MessageParcel & reply)178 int32_t AVControllerCallbackStub::HandleOnQueueItemsChange(MessageParcel& data, MessageParcel& reply)
179 {
180 std::vector<AVQueueItem> items_;
181 int32_t maxItemNumber = 1000; // A maximum of 1000 queue items can be processed at a time
182 int32_t itemNum = data.ReadInt32();
183 CHECK_AND_RETURN_RET_LOG((itemNum >= 0) && (itemNum < maxItemNumber), ERR_NONE, "read int32 itemNum failed");
184 for (int32_t i = 0; i < itemNum; i++) {
185 AVQueueItem *item = data.ReadParcelable<AVQueueItem>();
186 CHECK_AND_RETURN_RET_LOG(item != nullptr, ERR_UNMARSHALLING, "read parcelable AVQueueItem failed");
187 items_.emplace_back(*item);
188 delete item;
189 }
190 AVSESSION_TRACE_SYNC_START("AVControllerCallbackStub::OnQueueItemsChange");
191 OnQueueItemsChange(items_);
192 return ERR_NONE;
193 }
194
HandleOnQueueTitleChange(MessageParcel & data,MessageParcel & reply)195 int32_t AVControllerCallbackStub::HandleOnQueueTitleChange(MessageParcel& data, MessageParcel& reply)
196 {
197 auto title = data.ReadString();
198 AVSESSION_TRACE_SYNC_START("AVControllerCallbackStub::OnQueueTitleChange");
199 OnQueueTitleChange(title);
200 return ERR_NONE;
201 }
202
HandleOnExtrasChange(MessageParcel & data,MessageParcel & reply)203 int32_t AVControllerCallbackStub::HandleOnExtrasChange(MessageParcel& data, MessageParcel& reply)
204 {
205 sptr extras = data.ReadParcelable<AAFwk::WantParams>();
206 CHECK_AND_RETURN_RET_LOG(extras != nullptr, ERR_NONE, "read extras failed");
207 AVSESSION_TRACE_SYNC_START("AVControllerCallbackStub::OnExtrasChange");
208 OnExtrasChange(*extras);
209 return ERR_NONE;
210 }
211 } // namespace OHOS::AVSession
212