1 /*
2  * Copyright (c) 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 "migrate_avsession_server.h"
17 
18 #include <chrono>
19 #include <thread>
20 
21 #include "avsession_errors.h"
22 #include "avsession_item.h"
23 #include "avsession_log.h"
24 #include "avsession_service.h"
25 #include "softbus/softbus_session_utils.h"
26 #include "migrate_avsession_constant.h"
27 #include "base64_utils.h"
28 #include "avsession_pixel_map_adapter.h"
29 #include "pixel_map.h"
30 #include "image_packer.h"
31 #include "avsession_event_handler.h"
32 
33 namespace OHOS::AVSession {
OnConnectProxy(const std::string &deviceId)34 void MigrateAVSessionServer::OnConnectProxy(const std::string &deviceId)
35 {
36     SLOGI("OnConnectProxy: %{public}s", SoftbusSessionUtils::AnonymizeDeviceId(deviceId).c_str());
37     isSoftbusConnecting_ = true;
38     deviceId_ = deviceId;
39     ObserveControllerChanged(deviceId);
40     SendSpecialKeepaliveData();
41     SendRemoteControllerList(deviceId);
42 }
43 
OnDisconnectProxy(const std::string &deviceId)44 void MigrateAVSessionServer::OnDisconnectProxy(const std::string &deviceId)
45 {
46     SLOGI("OnDisConnectProxy: %{public}s", SoftbusSessionUtils::AnonymizeDeviceId(deviceId).c_str());
47     isSoftbusConnecting_ = false;
48     StopObserveControllerChanged(deviceId);
49 }
50 
GetCharacteristic()51 int32_t MigrateAVSessionServer::GetCharacteristic()
52 {
53     return MSG_HEAD_MODE;
54 }
55 
ObserveControllerChanged(const std::string &deviceId)56 void MigrateAVSessionServer::ObserveControllerChanged(const std::string &deviceId)
57 {
58     std::vector<AVSessionDescriptor> descriptors;
59     auto res = servicePtr_->GetAllSessionDescriptors(descriptors);
60     if (res != AVSESSION_SUCCESS) {
61         SLOGW("GetAllSessionDescriptors fail");
62         return;
63     }
64 
65     for (auto &item : descriptors) {
66         if (item.isTopSession_) {
67             std::lock_guard lockGuard(topSessionLock_);
68             topSessionId_ = item.sessionId_;
69         }
70         CreateController(item.sessionId_);
71     }
72 }
73 
CreateController(const std::string &sessionId)74 void MigrateAVSessionServer::CreateController(const std::string &sessionId)
75 {
76     std::lock_guard lockGuard(migrateControllerLock_);
77     auto it = playerIdToControllerCallbackMap_.find(sessionId);
78     if (it != playerIdToControllerCallbackMap_.end()) {
79         SLOGW("CreateControlller has registered");
80         return;
81     }
82     sptr<IRemoteObject> proxyObject;
83     int32_t ret = servicePtr_->CreateControllerInner(sessionId, proxyObject);
84     if (ret != AVSESSION_SUCCESS && !(ret == ERR_CONTROLLER_IS_EXIST && proxyObject != nullptr)) {
85         SLOGW("CreateControllerInner fail");
86         return;
87     }
88     sptr<AVControllerItem> controller = iface_cast<AVControllerItem>(proxyObject);
89     if (controller == nullptr) {
90         SLOGW("controller is null");
91         return;
92     }
93     std::shared_ptr<AVControllerObserver> callback = std::make_shared<AVControllerObserver>(sessionId);
94     std::weak_ptr<MigrateAVSessionServer> migrageServerWeak(shared_from_this());
95     callback->Init(migrageServerWeak);
96     ret = controller->RegisterAVControllerCallback(callback);
97     if (ret != AVSESSION_SUCCESS) {
98         SLOGW("RegisteAVControllerCallback fail");
99         return;
100     }
101     AVMetaData::MetaMaskType metaDataFilter(METADATA_MASK_ALL);
102     AVPlaybackState::PlaybackStateMaskType playFilter(PLAYBACK_MASK_ALL);
103     controller->SetMetaFilter(metaDataFilter);
104     controller->SetPlaybackFilter(playFilter);
105     UpdateCache(sessionId, controller, callback, true);
106 }
107 
ClearCacheBySessionId(const std::string &sessionId)108 void MigrateAVSessionServer::ClearCacheBySessionId(const std::string &sessionId)
109 {
110     std::lock_guard lockGuard(migrateControllerLock_);
111     auto it = playerIdToControllerMap_.find(sessionId);
112     if (it != playerIdToControllerMap_.end()) {
113         playerIdToControllerMap_.erase(it);
114         sortControllerList_.remove(it->second);
115     }
116 
117     auto item = playerIdToControllerCallbackMap_.find(sessionId);
118     if (item != playerIdToControllerCallbackMap_.end()) {
119         playerIdToControllerCallbackMap_.erase(item);
120     }
121 }
122 
123 // LCOV_EXCL_START
UpdateCache(const std::string &sessionId, sptr<AVControllerItem> avcontroller, std::shared_ptr<AVControllerObserver> callback, bool isAdd)124 void MigrateAVSessionServer::UpdateCache(const std::string &sessionId, sptr<AVControllerItem> avcontroller,
125     std::shared_ptr<AVControllerObserver> callback, bool isAdd)
126 {
127     if (isAdd) {
128         if (avcontroller == nullptr) {
129             return;
130         }
131         std::lock_guard lockGuard(migrateControllerLock_);
132         playerIdToControllerMap_.insert({sessionId, avcontroller});
133         playerIdToControllerCallbackMap_.insert({sessionId, callback});
134         sortControllerList_.push_back(avcontroller);
135     } else {
136         ClearCacheBySessionId(sessionId);
137     }
138 }
139 // LCOV_EXCL_STOP
140 
StopObserveControllerChanged(const std::string &deviceId)141 void MigrateAVSessionServer::StopObserveControllerChanged(const std::string &deviceId)
142 {
143     SLOGI("StopObserveControllerChanged");
144     std::lock_guard lockGuard(migrateControllerLock_);
145     for (auto it = sortControllerList_.begin(); it != sortControllerList_.end(); it++) {
146         (*it)->Destroy();
147         SLOGI("Controller destroy");
148     }
149     deviceId_ = "";
150     playerIdToControllerMap_.clear();
151     sortControllerList_.clear();
152     playerIdToControllerCallbackMap_.clear();
153 }
154 
155 // LCOV_EXCL_START
OnBytesReceived(const std::string &deviceId, const std::string &data)156 void MigrateAVSessionServer::OnBytesReceived(const std::string &deviceId, const std::string &data)
157 {
158     SLOGI("OnBytesReceived: %{public}s", data.c_str());
159     if (data.length() < MSG_HEAD_LENGTH) {
160         SLOGW("OnBytesReceived: invalid data");
161         return;
162     }
163     if (data[1] == SYNC_COMMAND) {
164         ProcControlCommand(data);
165     } else if (data[1] == COLD_START) {
166         SLOGW("COLD_START not support");
167     }
168 }
169 // LCOV_EXCL_STOP
170 
ProcControlCommand(const std::string &data)171 void MigrateAVSessionServer::ProcControlCommand(const std::string &data)
172 {
173     std::string jsonStr = data.substr(MSG_HEAD_LENGTH);
174     SLOGI("ProcControlCommand: %{public}s", jsonStr.c_str());
175     Json::Reader reader;
176     Json::Value root;
177     if (!reader.parse(jsonStr, root)) {
178         SLOGE("json parse fail");
179         return;
180     }
181     if (!root.isMember(PLAYER_ID) || !root.isMember(MEDIA_COMMAND) ||
182         !root.isMember(COMMAND)) {
183         SLOGE("json parse with error member");
184         return;
185     }
186     std::string playerId = root[PLAYER_ID].isString() ?
187         root[PLAYER_ID].asString() : "ERROR_PLAYER_ID";
188     sptr<AVControllerItem> avcontroller{nullptr};
189     auto res = GetControllerById(playerId, avcontroller);
190     if (res != AVSESSION_SUCCESS || avcontroller == nullptr) {
191         SLOGW("GetControllerById fail");
192         return;
193     }
194     int mediaCommand = root[MEDIA_COMMAND].isInt() ? root[MEDIA_COMMAND].asInt() : -1;
195     std::string command = root[COMMAND].isString() ? root[COMMAND].asString() : "ERROR_COMMAND";
196     SLOGI("ProcContolCommand mediaCommand: %{public}d", mediaCommand);
197     std::string extras = (root.isMember(EXTRAS) && root[EXTRAS].isString()) ? root[EXTRAS].asString() : "ERROR_EXTRAS";
198     switch (mediaCommand) {
199         case SYNC_MEDIASESSION_CALLBACK_ON_COMMAND:
200             SendCommandProc(command, avcontroller);
201             break;
202         case SYNC_MEDIASESSION_CALLBACK_ON_MEDIABUTTON_EVENT:
203             MediaButtonEventProc(command, avcontroller);
204             break;
205         case SYNC_MEDIASESSION_CALLBACK_ON_PLAY_FROM_SEARCH:
206         case SYNC_MEDIASESSION_CALLBACK_ON_PLAY_FROM_MEDIAID:
207         case SYNC_MEDIASESSION_CALLBACK_ON_CUSTOMACTION:
208             CommandWithExtrasProc(mediaCommand, command, extras, avcontroller);
209             break;
210         default:
211             PlaybackCommandDataProc(mediaCommand, command, avcontroller);
212             break;
213     }
214 }
215 
216 // LCOV_EXCL_START
GetControllerById(const std::string &sessionId, sptr<AVControllerItem> &controller)217 int32_t MigrateAVSessionServer::GetControllerById(const std::string &sessionId, sptr<AVControllerItem> &controller)
218 {
219     if (sessionId.empty()) {
220         SLOGW("empty sessionId");
221         return AVSESSION_ERROR;
222     }
223 
224     std::lock_guard lockGuard(migrateControllerLock_);
225     for (auto it = playerIdToControllerMap_.begin(); it != playerIdToControllerMap_.end(); it++) {
226         std::string foundId = it->first;
227         if (it->first == sessionId) {
228             controller = it->second;
229             return AVSESSION_SUCCESS;
230         }
231     }
232     SLOGW("controller not found");
233     return AVSESSION_ERROR;
234 }
235 // LCOV_EXCL_STOP
236 
Init(AVSessionService *ptr)237 void MigrateAVSessionServer::Init(AVSessionService *ptr)
238 {
239     servicePtr_ = ptr;
240 }
241 
242 // LCOV_EXCL_START
OnSessionCreate(const AVSessionDescriptor &descriptor)243 void MigrateAVSessionServer::OnSessionCreate(const AVSessionDescriptor &descriptor)
244 {
245     SLOGI("OnSessionCreate");
246     std::string sessionId = descriptor.sessionId_;
247     if (sessionId.empty()) {
248         SLOGW("no valid avsession");
249         return;
250     }
251     std::string identity = IPCSkeleton::ResetCallingIdentity();
252     CreateController(sessionId);
253     IPCSkeleton::SetCallingIdentity(identity);
254 }
255 
OnSessionRelease(const AVSessionDescriptor &descriptor)256 void MigrateAVSessionServer::OnSessionRelease(const AVSessionDescriptor &descriptor)
257 {
258     std::string sessionId = descriptor.sessionId_;
259     if (sessionId.empty()) {
260         SLOGW("no valid avsession");
261         return;
262     }
263     SLOGI("OnSessionRelease : %{public}s", sessionId.c_str());
264     ClearCacheBySessionId(sessionId);
265 }
266 
OnTopSessionChange(const AVSessionDescriptor &descriptor)267 void MigrateAVSessionServer::OnTopSessionChange(const AVSessionDescriptor &descriptor)
268 {
269     SLOGI("OnTopSessionChange sessionId_: %{public}s", descriptor.sessionId_.c_str());
270     {
271         std::lock_guard lockGuard(topSessionLock_);
272         if (topSessionId_ == descriptor.sessionId_) {
273             return;
274         }
275         topSessionId_ = descriptor.sessionId_;
276         auto it = playerIdToControllerMap_.find(descriptor.sessionId_);
277         if (it == playerIdToControllerMap_.end()) {
278             CreateController(descriptor.sessionId_);
279         }
280     }
281     SendRemoteControllerList(deviceId_);
282 }
283 
SortControllers(std::list<sptr<AVControllerItem>> controllers)284 void MigrateAVSessionServer::SortControllers(std::list<sptr<AVControllerItem>> controllers)
285 {
286     SLOGI("SortControllers");
287     std::lock_guard topSessionLockGuard(topSessionLock_);
288     if (topSessionId_.empty()) {
289         SLOGE("SortControllers topSessionId is null");
290         return;
291     }
292     std::lock_guard lockGuard(migrateControllerLock_);
293     for (auto iter = controllers.begin(); iter != controllers.end(); iter++) {
294         if ((*iter)->GetSessionId() == topSessionId_) {
295             controllers.splice(controllers.begin(), controllers, iter);
296             break;
297         }
298     }
299 }
300 
SendRemoteControllerList(const std::string &deviceId)301 void MigrateAVSessionServer::SendRemoteControllerList(const std::string &deviceId)
302 {
303     SLOGI("SendRemoteControllerList");
304     SortControllers(sortControllerList_);
305     sptr<AVControllerItem> avcontroller{nullptr};
306     std::lock_guard lockGuard(topSessionLock_);
307     auto res = GetControllerById(topSessionId_, avcontroller);
308     if (res != AVSESSION_SUCCESS) {
309         SLOGE("SendRemoteControllerList no top session");
310         return;
311     }
312     if (avcontroller == nullptr) {
313         SLOGE("SendRemoteControllerList avcontroller is null");
314         return;
315     }
316     std::string msg = ConvertControllersToStr(avcontroller);
317 
318     if (!deviceId.empty()) {
319         SendByte(deviceId, msg);
320     } else {
321         SendByteToAll(msg);
322     }
323     AVSessionEventHandler::GetInstance().AVSessionPostTask([this]() {
324         DelaySendMetaData();
325         }, "DelaySendMetaData", DELAY_TIME);
326 }
327 
DelaySendMetaData()328 void MigrateAVSessionServer::DelaySendMetaData()
329 {
330     sptr<AVControllerItem> avcontroller{nullptr};
331     GetControllerById(topSessionId_, avcontroller);
332     if (avcontroller != nullptr) {
333         AVMetaData resultMetaData;
334         resultMetaData.Reset();
335         avcontroller->GetAVMetaData(resultMetaData);
336         std::string metaDataStr = ConvertMetadataInfoToStr(topSessionId_,
337             SYNC_CONTROLLER_CALLBACK_ON_METADATA_CHANNGED, resultMetaData);
338         SendByte(deviceId_, metaDataStr);
339     }
340 }
341 
ConvertControllersToStr(sptr<AVControllerItem> controller)342 std::string MigrateAVSessionServer::ConvertControllersToStr(sptr<AVControllerItem> controller)
343 {
344     SLOGI("ConvertControllersToStr");
345     Json::Value jsonArray;
346     jsonArray.resize(1);
347     std::string playerId = controller->GetSessionId();
348     Json::Value jsonObject = ConvertControllerToJson(controller);
349     jsonObject[PLAYER_ID] = playerId;
350     jsonArray[0] = jsonObject;
351     Json::Value jsonData;
352     jsonData[MEDIA_CONTROLLER_LIST] = jsonArray;
353 
354     Json::FastWriter writer;
355     std::string jsonStr = writer.write(jsonData);
356     char header[] = {MSG_HEAD_MODE, SYNC_CONTROLLER_LIST, '\0'};
357     std::string msg = std::string(header) + jsonStr;
358     return msg;
359 }
360 // LCOV_EXCL_STOP
361 
ConvertControllerToJson(sptr<AVControllerItem> avcontroller)362 Json::Value MigrateAVSessionServer::ConvertControllerToJson(sptr<AVControllerItem> avcontroller)
363 {
364     SLOGI("ConvertControllerToJson");
365     Json::Value metadata;
366     AVMetaData data;
367     if (AVSESSION_SUCCESS == avcontroller->GetAVMetaData(data)) {
368         metadata = ConvertMetadataToJson(data);
369     }
370 
371     AVPlaybackState state;
372     if (AVSESSION_SUCCESS == avcontroller->GetAVPlaybackState(state)) {
373         metadata[PLAYBACK_STATE] = RebuildPlayState(state);
374     }
375 
376     metadata[SESSION_INFO] =
377         "OAAAAEJOREwBAAAAEwAAAEMAbwBuAHQAcgBvAGwAbABlAHIAVwBoAGkAdABlAEwAaQBzAHQAAAAU\nAAAAAQAAAA==\n";
378     metadata[VOLUME_INFO] = VOLUMN_INFO;
379     metadata[PACKAGE_NAME] = GetBundleName(avcontroller->GetSessionId());
380     return metadata;
381 }
382 
383 // LCOV_EXCL_START
GetBundleName(std::string sessionId)384 std::string MigrateAVSessionServer::GetBundleName(std::string sessionId)
385 {
386     std::vector<AVSessionDescriptor> descriptors;
387 
388     auto res = servicePtr_->GetAllSessionDescriptors(descriptors);
389     if (res != AVSESSION_SUCCESS) {
390         SLOGW("GetAllSessionDescriptors fail");
391         return "";
392     }
393     for (auto iter = descriptors.begin(); iter != descriptors.end(); iter++) {
394         if (iter->sessionId_ == sessionId) {
395             std::string bundleName = iter->elementName_.GetBundleName();
396             std::string abilityName = iter->elementName_.GetAbilityName();
397             SLOGI("bundleName: %{public}s abilityName: %{public}s", bundleName.c_str(), abilityName.c_str());
398             return bundleName;
399         }
400     }
401     SLOGW("GetBundleName fail");
402     return "";
403 }
404 
ConvertStateFromSingleToDouble(int32_t state)405 int32_t MigrateAVSessionServer::ConvertStateFromSingleToDouble(int32_t state)
406 {
407     switch (state) {
408         case AVPlaybackState::PLAYBACK_STATE_PLAY:
409             return MEDIA_SESSION_PLAYBACK_STATE_PLAY;
410         case AVPlaybackState::PLAYBACK_STATE_PAUSE:
411             return MEDIA_SESSION_PLAYBACK_STATE_PAUSE;
412         case AVPlaybackState::PLAYBACK_STATE_STOP:
413             return MEDIA_SESSION_PLAYBACK_STATE_STOP;
414         case AVPlaybackState::PLAYBACK_STATE_ERROR:
415             return MEDIA_SESSION_PLAYBACK_STATE_ERROR;
416         default:
417             SLOGW("unknowState: %{public}d", state);
418             break;
419     }
420     return state;
421 }
422 
RebuildPlayState(const AVPlaybackState &playbackState)423 std::string MigrateAVSessionServer::RebuildPlayState(const AVPlaybackState &playbackState)
424 {
425     int64_t actions = 1911;
426     Parcel parcel;
427     parcel.WriteInt32(ConvertStateFromSingleToDouble(playbackState.GetState()))
428         && parcel.WriteInt64(playbackState.GetPosition().elapsedTime_)
429         && parcel.WriteFloat(playbackState.GetSpeed())
430         && parcel.WriteInt64(playbackState.GetPosition().updateTime_)
431         && parcel.WriteInt64(playbackState.GetBufferedTime())
432         && parcel.WriteInt64(actions)
433         && parcel.WriteInt32(-1)
434         && parcel.WriteInt64(playbackState.GetActiveItemId())
435         && parcel.WriteInt32(1)
436         && parcel.WriteCString("")
437         && parcel.WriteInt32(-1);
438 
439     uint8_t* pointer = reinterpret_cast<uint8_t*>(parcel.GetData());
440     size_t len = parcel.GetDataSize();
441     std::vector<uint8_t> vec(len);
442     for (size_t i = 0; i < len; ++i) {
443         vec[i] = pointer[i];
444     }
445     std::string str = Base64Utils::Base64Encode(vec);
446     return str;
447 }
448 
ConvertMetadataToJson(const AVMetaData &metadata)449 Json::Value MigrateAVSessionServer::ConvertMetadataToJson(const AVMetaData &metadata)
450 {
451     Json::Value result;
452     if (metadata.IsValid()) {
453         SLOGI("ConvertMetadataToJson without img");
454         result[METADATA_TITLE] = metadata.GetTitle();
455         result[METADATA_ARTIST] = metadata.GetArtist();
456         std::string mediaImage = "";
457         std::vector<uint8_t> outputData(BUFFER_MAX_SIZE);
458         int32_t ret = CompressToJPEG(metadata, outputData);
459         mediaImage = ((ret == true) && (!outputData.empty())) ? Base64Utils::Base64Encode(outputData) : "";
460         result[METADATA_IMAGE] = mediaImage;
461     } else {
462         result[METADATA_TITLE] = "";
463         result[METADATA_ARTIST] = "";
464         result[METADATA_IMAGE] = "";
465     }
466     return result;
467 }
468 
CompressToJPEG(const AVMetaData &metadata, std::vector<uint8_t> &outputData)469 bool MigrateAVSessionServer::CompressToJPEG(const AVMetaData &metadata, std::vector<uint8_t> &outputData)
470 {
471     std::shared_ptr<AVSessionPixelMap> innerPixelMap = metadata.GetMediaImage();
472     std::shared_ptr<Media::PixelMap> pixelMap;
473     if (innerPixelMap == nullptr) {
474         return false;
475     } else {
476         pixelMap = AVSessionPixelMapAdapter::ConvertFromInner(innerPixelMap);
477     }
478 
479     Media::ImagePacker imagePacker;
480     Media::PackOption option;
481     option.format = "image/jpeg";
482     option.quality = DEFAULT_QUALITY;
483     uint32_t maxSize = outputData.size();
484     uint32_t ret = imagePacker.StartPacking(outputData.data(), maxSize, option);
485     if (ret != 0) {
486         SLOGI("Failed to start packing");
487         return false;
488     }
489     if (pixelMap == nullptr) {
490         SLOGE("CompressToJPEG with pixel get null");
491         return false;
492     }
493     ret = imagePacker.AddImage(*pixelMap);
494     if (ret != 0) {
495         SLOGI("Failed to add image");
496         return false;
497     }
498     int64_t packedSize = 0;
499     ret = imagePacker.FinalizePacking(packedSize);
500     if (ret != 0) {
501         SLOGI("Failed to finalize packing");
502         return false;
503     }
504 
505     outputData.resize(packedSize);
506     return true;
507 }
508 
ConvertMetadataInfoToStr( const std::string playerId, int32_t controlCommand, const AVMetaData &metadata)509 std::string MigrateAVSessionServer::ConvertMetadataInfoToStr(
510     const std::string playerId, int32_t controlCommand, const AVMetaData &metadata)
511 {
512     SLOGI("ConvertMetadataInfoToStr");
513     Json::Value metaDataJson = ConvertMetadataToJson(metadata);
514     metaDataJson[PLAYER_ID] = playerId;
515     metaDataJson[MEDIA_INFO] = controlCommand;
516     Json::FastWriter writer;
517     std::string msg = writer.write(metaDataJson);
518     char header[] = {MSG_HEAD_MODE, SYNC_CONTROLLER, '\0'};
519     return std::string(header) + msg;
520 }
521 
SendSpecialKeepaliveData()522 void MigrateAVSessionServer::SendSpecialKeepaliveData()
523 {
524     std::thread([this]() {
525         std::this_thread::sleep_for(std::chrono::milliseconds(HEART_BEAT_TIME));
526         if (this->isSoftbusConnecting_) {
527             char header[] = {MSG_HEAD_MODE, SYNC_HEARTBEAT, '\0'};
528             std::string data = std::string(header);
529             SendByteToAll(data);
530             SendSpecialKeepaliveData();
531             SLOGI("send special mediamession data to proxy connection");
532         } else {
533             SLOGI("send special mediamession data to proxy exit");
534         }
535     }).detach();
536 }
537 
SendCommandProc(const std::string &command, sptr<AVControllerItem> controller)538 void MigrateAVSessionServer::SendCommandProc(const std::string &command, sptr<AVControllerItem> controller)
539 {
540     if (command == EVENT_COMMAND_UNLOCK_LYRIC || command == EVENT_COMMAND_SHOW_LYRIC ||
541        command == EVENT_COMMAND_HIDE_LYRIC) {
542     } else {
543         SLOGW("command is not support: %{public}s", command.c_str());
544     }
545 }
546 
MediaButtonEventProc(const std::string &command, sptr<AVControllerItem> controller)547 void MigrateAVSessionServer::MediaButtonEventProc(const std::string &command, sptr<AVControllerItem> controller)
548 {
549     std::shared_ptr<MMI::KeyEvent> keyEvent = MMI::KeyEvent::Create();
550     if (keyEvent == nullptr) {
551         SLOGE("MediaButtonEventProc with key event null");
552         return;
553     }
554     keyEvent->SetKeyCode(atoi(command.c_str()));
555     controller->SendAVKeyEvent(*keyEvent.get());
556 }
557 
CommandWithExtrasProc(int mediaCommand, const std::string &extrasCommand, const std::string &extras, sptr<AVControllerItem> controller)558 void MigrateAVSessionServer::CommandWithExtrasProc(int mediaCommand, const std::string &extrasCommand,
559     const std::string &extras, sptr<AVControllerItem> controller)
560 {
561     SLOGI("CommandWithExtrasProc mediaCommand is: %{public}d", mediaCommand);
562     switch (mediaCommand) {
563         case SYNC_MEDIASESSION_CALLBACK_ON_PLAY_FROM_SEARCH:
564             break;
565         case SYNC_MEDIASESSION_CALLBACK_ON_PLAY_FROM_MEDIAID:
566             break;
567         case SYNC_MEDIASESSION_CALLBACK_ON_CUSTOMACTION:
568             break;
569         default:
570             SLOGW("mediaCommand is not support: %{public}d", mediaCommand);
571             break;
572     }
573 }
574 
PlaybackCommandDataProc(int mediaCommand, const std::string &command, sptr<AVControllerItem> controller)575 void MigrateAVSessionServer::PlaybackCommandDataProc(int mediaCommand, const std::string &command,
576     sptr<AVControllerItem> controller)
577 {
578     SLOGI("PlaybackComandDataProc Command is: %{public}d", mediaCommand);
579     AVControlCommand cmd;
580     switch (mediaCommand) {
581         case SYNC_MEDIASESSION_CALLBACK_ON_PLAY:
582             cmd.SetCommand(AVControlCommand::SESSION_CMD_PLAY);
583             controller->SendControlCommand(cmd);
584             break;
585         case SYNC_MEDIASESSION_CALLBACK_ON_PAUSE:
586             cmd.SetCommand(AVControlCommand::SESSION_CMD_PAUSE);
587             controller->SendControlCommand(cmd);
588             break;
589         case SYNC_MEDIASESSION_CALLBACK_ON_STOP:
590             cmd.SetCommand(AVControlCommand::SESSION_CMD_STOP);
591             controller->SendControlCommand(cmd);
592             break;
593         case SYNC_MEDIASESSION_CALLBACK_ON_SKIP_TO_PREVIOUS:
594             cmd.SetCommand(AVControlCommand::SESSION_CMD_PLAY_PREVIOUS);
595             controller->SendControlCommand(cmd);
596             break;
597         case SYNC_MEDIASESSION_CALLBACK_ON_SKIP_TO_NEXT:
598             cmd.SetCommand(AVControlCommand::SESSION_CMD_PLAY_NEXT);
599             controller->SendControlCommand(cmd);
600             break;
601         case SYNC_MEDIASESSION_CALLBACK_ON_SET_RATING:
602             break;
603         case SYNC_CONTROLLER_CALLBACK_ON_AUDIOINFO_CHANGED:
604             break;
605         default:
606             SLOGI("mediaCommand is not support: %{public}s", command.c_str());
607             break;
608     }
609 }
610 
OnMetaDataChange(const std::string & playerId, const AVMetaData &data)611 void MigrateAVSessionServer::OnMetaDataChange(const std::string & playerId, const AVMetaData &data)
612 {
613     std::string metaDataStr = ConvertMetadataInfoToStr(playerId, SYNC_CONTROLLER_CALLBACK_ON_METADATA_CHANNGED, data);
614     SLOGI("MigrateAVSessionServer OnMetaDataChange: %{public}s", metaDataStr.c_str());
615 
616     SendByte(deviceId_, metaDataStr);
617 }
618 // LCOV_EXCL_STOP
619 
OnPlaybackStateChanged(const std::string &playerId, const AVPlaybackState &state)620 void MigrateAVSessionServer::OnPlaybackStateChanged(const std::string &playerId, const AVPlaybackState &state)
621 {
622     Json::Value value;
623     value[PLAYER_ID] = playerId;
624     value[MEDIA_INFO] = SYNC_CONTROLLER_CALLBACK_ON_PLAYBACKSTATE_CHANGED;
625     value[CALLBACK_INFO] = RebuildPlayState(state);
626     char header[] = {MSG_HEAD_MODE, SYNC_CONTROLLER, '\0'};
627     Json::FastWriter writer;
628     std::string msg = writer.write(value);
629     std::string result = std::string(header) + msg;
630     SendByte(deviceId_, result);
631 }
632 
633 // LCOV_EXCL_START
OnSessionDestroy()634 void AVControllerObserver::OnSessionDestroy()
635 {
636     SLOGI("OnSessionDestroy");
637 }
638 
OnPlaybackStateChange(const AVPlaybackState &state)639 void AVControllerObserver::OnPlaybackStateChange(const AVPlaybackState &state)
640 {
641     std::shared_ptr<MigrateAVSessionServer> server = migrateServer_.lock();
642     if (server != nullptr && state.GetState() != AVPlaybackState::PLAYBACK_STATE_INITIAL) {
643         server->OnPlaybackStateChanged(playerId_, state);
644     }
645 }
646 
OnMetaDataChange(const AVMetaData &data)647 void AVControllerObserver::OnMetaDataChange(const AVMetaData &data)
648 {
649     SLOGI("OnMetaDataChange");
650     std::shared_ptr<MigrateAVSessionServer> server = migrateServer_.lock();
651     if (server != nullptr) {
652         server->OnMetaDataChange(playerId_, data);
653     }
654 }
655 
Init(std::weak_ptr<MigrateAVSessionServer> migrateServer)656 void AVControllerObserver::Init(std::weak_ptr<MigrateAVSessionServer> migrateServer)
657 {
658     migrateServer_ = migrateServer;
659 }
660 // LCOV_EXCL_STOP
661 } // namespace OHOS::AVSession