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