1 /*
2 * Copyright (C) 2021 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 "player_server.h"
17 #include <map>
18 #include <unistd.h>
19 #include <unordered_set>
20 #include "media_log.h"
21 #include "media_errors.h"
22 #include "engine_factory_repo.h"
23 #include "player_server_state.h"
24 #include "media_dfx.h"
25 #include "media_utils.h"
26 #include "ipc_skeleton.h"
27 #include "media_permission.h"
28 #include "accesstoken_kit.h"
29 #include "av_common.h"
30 #include "parameter.h"
31 #include "parameters.h"
32 #include "qos.h"
33 #include "player_server_event_receiver.h"
34 #include "common/media_source.h"
35 #include "audio_info.h"
36
37 using namespace OHOS::QOS;
38
39 namespace {
40 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN_PLAYER, "PlayerServer"};
41 constexpr int32_t MAX_SUBTITLE_TRACK_NUN = 8;
42 }
43
44 namespace OHOS {
45 namespace Media {
46 using namespace OHOS::HiviewDFX;
47 using namespace OHOS::Media::Plugins;
48 const std::string START_TAG = "PlayerCreate->Start";
49 const std::string STOP_TAG = "PlayerStop->Destroy";
50 static const std::unordered_map<int32_t, std::string> STATUS_TO_STATUS_DESCRIPTION_TABLE = {
51 {PLAYER_STATE_ERROR, "PLAYER_STATE_ERROR"},
52 {PLAYER_IDLE, "PLAYER_IDLE"},
53 {PLAYER_INITIALIZED, "PLAYER_INITIALIZED"},
54 {PLAYER_PREPARING, "PLAYER_PREPARING"},
55 {PLAYER_PREPARED, "PLAYER_PREPARED"},
56 {PLAYER_STARTED, "PLAYER_STARTED"},
57 {PLAYER_PAUSED, "PLAYER_PAUSED"},
58 {PLAYER_STOPPED, "PLAYER_STOPPED"},
59 {PLAYER_PLAYBACK_COMPLETE, "PLAYER_PLAYBACK_COMPLETE"},
60 };
61 #ifdef SUPPORT_VIDEO
62 class VideoPlayerManager : public NoCopyable {
63 public:
64 static VideoPlayerManager &GetInstance();
65 int32_t RegisterVideoPlayer(PlayerServer *player);
66 void UnRegisterVideoPlayer(PlayerServer *player);
67 private:
68 VideoPlayerManager() = default;
69 ~VideoPlayerManager() = default;
70 std::unordered_set<PlayerServer *> videoPlayerList;
71 std::mutex mutex_;
72 };
73
GetInstance()74 VideoPlayerManager &VideoPlayerManager::GetInstance()
75 {
76 static VideoPlayerManager instance;
77 return instance;
78 }
79
RegisterVideoPlayer(PlayerServer * player)80 int32_t VideoPlayerManager::RegisterVideoPlayer(PlayerServer *player)
81 {
82 std::lock_guard<std::mutex> lock(mutex_);
83 if (videoPlayerList.find(player) != videoPlayerList.end()) {
84 return MSERR_OK;
85 }
86 videoPlayerList.insert(player);
87 return MSERR_OK;
88 }
89
UnRegisterVideoPlayer(PlayerServer * player)90 void VideoPlayerManager::UnRegisterVideoPlayer(PlayerServer *player)
91 {
92 std::lock_guard<std::mutex> lock(mutex_);
93 if (videoPlayerList.erase(player) == 0) {
94 MEDIA_LOGI("0x%{public}06" PRIXPTR " Not in videoPlayer list", FAKE_POINTER(player));
95 }
96 }
97 #endif
Create()98 std::shared_ptr<IPlayerService> PlayerServer::Create()
99 {
100 std::shared_ptr<PlayerServer> server = std::make_shared<PlayerServer>();
101 CHECK_AND_RETURN_RET_LOG(server != nullptr, nullptr, "failed to new PlayerServer");
102 (void)server->Init();
103 return server;
104 }
105
PlayerServer()106 PlayerServer::PlayerServer()
107 {
108 MEDIA_LOGD("0x%{public}06" PRIXPTR " Instances create", FAKE_POINTER(this));
109 instanceId_ = HiviewDFX::HiTraceChain::GetId().GetChainId();
110 }
111
~PlayerServer()112 PlayerServer::~PlayerServer()
113 {
114 MEDIA_LOGD("0x%{public}06" PRIXPTR " Instances destroy", FAKE_POINTER(this));
115 #ifdef SUPPORT_VIDEO
116 VideoPlayerManager::GetInstance().UnRegisterVideoPlayer(this);
117 #endif
118 }
119
Init()120 int32_t PlayerServer::Init()
121 {
122 MediaTrace trace("PlayerServer::Init");
123
124 idleState_ = std::make_shared<IdleState>(*this);
125 initializedState_ = std::make_shared<InitializedState>(*this);
126 preparingState_ = std::make_shared<PreparingState>(*this);
127 preparedState_ = std::make_shared<PreparedState>(*this);
128 playingState_ = std::make_shared<PlayingState>(*this);
129 pausedState_ = std::make_shared<PausedState>(*this);
130 stoppedState_ = std::make_shared<StoppedState>(*this);
131 playbackCompletedState_ = std::make_shared<PlaybackCompletedState>(*this);
132 appTokenId_ = IPCSkeleton::GetCallingTokenID();
133 appUid_ = IPCSkeleton::GetCallingUid();
134 appPid_ = IPCSkeleton::GetCallingPid();
135 MEDIA_LOGD("Get app uid: %{public}d, app pid: %{public}d, app tokenId: %{private}u", appUid_, appPid_, appTokenId_);
136
137 PlayerServerStateMachine::Init(idleState_);
138
139 std::string bootState = system::GetParameter("bootevent.boot.completed", "false");
140 isBootCompleted_.store(bootState == "true");
141 if (isBootCompleted_.load() && appUid_ != 0) {
142 int32_t userId = -1;
143 AccountSA::OsAccountManager::GetOsAccountLocalIdFromUid(appUid_, userId);
144 userId_.store(userId);
145 std::weak_ptr<PlayerServer> server = std::static_pointer_cast<PlayerServer>(shared_from_this());
146 commonEventReceiver_ = std::make_shared<PlayerServerCommonEventReceiver>(server);
147 }
148 MEDIA_LOGI("0x%{public}06" PRIXPTR "Dump Info: lastOpStatus: %{public}s, lastErrMsg: %{public}s, "
149 "speedMode: %{public}d, looping: %{public}s, effectMode: %{public}d, leftVolume: %{public}f, "
150 "rightVolume: %{public}f", FAKE_POINTER(this), lastOpStatus_?"true":"false",
151 lastErrMsg_.c_str(), config_.speedMode, config_.looping?"true":"false", config_.effectMode,
152 config_.leftVolume, config_.rightVolume);
153 return MSERR_OK;
154 }
155
SetSource(const std::string & url)156 int32_t PlayerServer::SetSource(const std::string &url)
157 {
158 std::lock_guard<std::mutex> lock(mutex_);
159 MediaTrace trace("PlayerServer::SetSource url");
160 CHECK_AND_RETURN_RET_LOG(!url.empty(), MSERR_INVALID_VAL, "url is empty");
161 std::string appName = GetClientBundleName(appUid_);
162 std::string callerType = "player_framework";
163 std::string errmasg = "";
164 MEDIA_LOGW("0x%{public}06" PRIXPTR " KPI-TRACE: PlayerServer SetSource in(url)", FAKE_POINTER(this));
165 if (url.find("http") != std::string::npos) {
166 int32_t permissionResult = MediaPermission::CheckNetWorkPermission(appUid_, appPid_, appTokenId_);
167 if (permissionResult != Security::AccessToken::PERMISSION_GRANTED) {
168 MEDIA_LOGE("user do not have the right to access INTERNET");
169 OnErrorMessage(MSERR_USER_NO_PERMISSION, "user do not have the right to access INTERNET");
170 errmasg = "user do not have the right to access INTERNET";
171 FaultSourceEventWrite(appName, instanceId_, callerType, static_cast<int8_t>(SourceType::SOURCE_TYPE_URI),
172 url, errmasg);
173 return MSERR_INVALID_OPERATION;
174 }
175 }
176 config_.url = url;
177 int32_t ret = InitPlayEngine(url);
178 if (ret != MSERR_OK) {
179 errmasg = "SetSource Failed!";
180 FaultSourceEventWrite(appName, instanceId_, callerType, static_cast<int8_t>(SourceType::SOURCE_TYPE_URI), url,
181 errmasg);
182 }
183 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "SetSource Failed!");
184 return ret;
185 }
186
SetSource(const std::shared_ptr<IMediaDataSource> & dataSrc)187 int32_t PlayerServer::SetSource(const std::shared_ptr<IMediaDataSource> &dataSrc)
188 {
189 std::lock_guard<std::mutex> lock(mutex_);
190 MediaTrace trace("PlayerServer::SetSource dataSrc");
191 CHECK_AND_RETURN_RET_LOG(dataSrc != nullptr, MSERR_INVALID_VAL, "data source is nullptr");
192 MEDIA_LOGW("KPI-TRACE: PlayerServer SetSource in(dataSrc)");
193 dataSrc_ = dataSrc;
194 std::string url = "media data source";
195 config_.url = url;
196 std::string appName = GetClientBundleName(appUid_);
197 std::string callerType = "player_framework";
198 std::string errmasg = "";
199 int32_t ret = InitPlayEngine(url);
200 if (ret != MSERR_OK) {
201 errmasg = "SetSource Failed!";
202 FaultSourceEventWrite(appName, instanceId_, callerType, static_cast<int8_t>(SourceType::SOURCE_TYPE_STREAM),
203 url, errmasg);
204 }
205 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "InitPlayEngine Failed!");
206 int64_t size = 0;
207 (void)dataSrc_->GetSize(size);
208 if (size == -1) {
209 config_.looping = false;
210 config_.speedMode = SPEED_FORWARD_1_00_X;
211 isLiveStream_ = true;
212 }
213 return ret;
214 }
215
SetSource(int32_t fd,int64_t offset,int64_t size)216 int32_t PlayerServer::SetSource(int32_t fd, int64_t offset, int64_t size)
217 {
218 std::lock_guard<std::mutex> lock(mutex_);
219 MediaTrace trace("PlayerServer::SetSource fd");
220 MEDIA_LOGW("KPI-TRACE: PlayerServer SetSource in(fd), fd: %{public}d, offset: %{public}" PRId64
221 ", size: %{public}" PRId64, fd, offset, size);
222 int32_t ret;
223 std::string appName = GetClientBundleName(appUid_);
224 std::string callerType = "player_framework";
225 std::string errmasg = "";
226 if (uriHelper_ != nullptr) {
227 std::string uri = uriHelper_->FormattedUri();
228 MEDIA_LOGI("UriHelper already existed, uri: %{private}s", uri.c_str());
229 ret = InitPlayEngine(uri);
230 if (ret != MSERR_OK) {
231 errmasg = "SetSource Failed!";
232 FaultSourceEventWrite(appName, instanceId_, callerType, static_cast<int8_t>(SourceType::SOURCE_TYPE_FD),
233 uri, errmasg);
234 }
235 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "SetSource Failed!");
236 } else {
237 MEDIA_LOGI("UriHelper is nullptr, create a new instance.");
238 auto uriHelper = std::make_unique<UriHelper>(fd, offset, size);
239 CHECK_AND_RETURN_RET_LOG(uriHelper->AccessCheck(UriHelper::URI_READ),
240 MSERR_INVALID_VAL, "Failed to read the fd");
241 ret = InitPlayEngine(uriHelper->FormattedUri());
242 if (ret != MSERR_OK) {
243 errmasg = "SetSource Failed!";
244 FaultSourceEventWrite(appName, instanceId_, callerType, static_cast<int8_t>(SourceType::SOURCE_TYPE_FD),
245 uriHelper->FormattedUri(), errmasg);
246 }
247 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "SetSource Failed!");
248 uriHelper_ = std::move(uriHelper);
249 }
250 config_.url = "file descriptor source";
251
252 return ret;
253 }
254
InitPlayEngine(const std::string & url)255 int32_t PlayerServer::InitPlayEngine(const std::string &url)
256 {
257 MEDIA_LOGI("PlayEngine Init");
258 if (lastOpStatus_ != PLAYER_IDLE) {
259 MEDIA_LOGE("current state is: %{public}s, not support SetSource",
260 GetStatusDescription(lastOpStatus_).c_str());
261 return MSERR_INVALID_OPERATION;
262 }
263
264 int32_t ret = taskMgr_.Init();
265 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "task mgr init failed");
266 MEDIA_LOGI("current url is : %{private}s", url.c_str());
267 auto engineFactory = EngineFactoryRepo::Instance().GetEngineFactory(
268 IEngineFactory::Scene::SCENE_PLAYBACK, appUid_, url);
269 CHECK_AND_RETURN_RET_LOG(engineFactory != nullptr, MSERR_CREATE_PLAYER_ENGINE_FAILED,
270 "failed to get engine factory");
271 playerEngine_ = engineFactory->CreatePlayerEngine(appUid_, appPid_, appTokenId_);
272 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_CREATE_PLAYER_ENGINE_FAILED,
273 "failed to create player engine");
274 playerEngine_->SetInstancdId(instanceId_);
275 MEDIA_LOGI("InitPlayEngine::Setted InstanceId");
276 if (dataSrc_ != nullptr) {
277 ret = playerEngine_->SetSource(dataSrc_);
278 } else if (mediaSource_ != nullptr) {
279 ret = playerEngine_->SetMediaSource(mediaSource_, strategy_);
280 } else {
281 ret = playerEngine_->SetSource(url);
282 }
283 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "SetSource Failed!");
284 MEDIA_LOGI("player engine SetSource success");
285 std::shared_ptr<IPlayerEngineObs> obs = shared_from_this();
286 ret = playerEngine_->SetObs(obs);
287 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "SetObs Failed!");
288 ret = playerEngine_->SetMaxAmplitudeCbStatus(maxAmplitudeCbStatus_);
289 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "SetMaxAmplitudeCbStatus Failed!");
290
291 lastOpStatus_ = PLAYER_INITIALIZED;
292 ChangeState(initializedState_);
293
294 Format format;
295 OnInfo(INFO_TYPE_STATE_CHANGE, PLAYER_INITIALIZED, format);
296 return MSERR_OK;
297 }
298
AddSubSource(const std::string & url)299 int32_t PlayerServer::AddSubSource(const std::string &url)
300 {
301 std::lock_guard<std::mutex> lock(mutex_);
302 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr!");
303
304 if (subtitleTrackNum_ >= MAX_SUBTITLE_TRACK_NUN) {
305 MEDIA_LOGE("Can not add sub source, subtitle track num is %{public}u, exceed the max num.", subtitleTrackNum_);
306 return MSERR_INVALID_OPERATION;
307 }
308
309 MEDIA_LOGD("PlayerServer AddSubSource in(url).");
310 MediaTrace::TraceBegin("PlayerServer::AddSubSource", FAKE_POINTER(this));
311 (void)playerEngine_->AddSubSource(url);
312
313 return MSERR_OK;
314 }
315
AddSubSource(int32_t fd,int64_t offset,int64_t size)316 int32_t PlayerServer::AddSubSource(int32_t fd, int64_t offset, int64_t size)
317 {
318 std::lock_guard<std::mutex> lock(mutex_);
319 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
320
321 if (subtitleTrackNum_ >= MAX_SUBTITLE_TRACK_NUN) {
322 MEDIA_LOGE("Can not add sub source, subtitle track num is %{public}u, exceed the max num", subtitleTrackNum_);
323 return MSERR_INVALID_OPERATION;
324 }
325
326 auto uriHelper = std::make_shared<UriHelper>(fd, offset, size);
327 CHECK_AND_RETURN_RET_LOG(uriHelper->AccessCheck(UriHelper::URI_READ), MSERR_INVALID_VAL, "Failed to read the fd");
328
329 MEDIA_LOGD("PlayerServer AddSubSource in(fd)");
330 MediaTrace::TraceBegin("PlayerServer::AddSubSource", FAKE_POINTER(this));
331 (void)playerEngine_->AddSubSource(uriHelper->FormattedUri());
332 subUriHelpers_.emplace_back(uriHelper);
333
334 return MSERR_OK;
335 }
336
Prepare()337 int32_t PlayerServer::Prepare()
338 {
339 if (inReleasing_.load()) {
340 MEDIA_LOGE("Can not Prepare, now in releasing");
341 return MSERR_INVALID_OPERATION;
342 }
343 std::lock_guard<std::mutex> lock(mutex_);
344 MEDIA_LOGD("KPI-TRACE: PlayerServer Prepare in");
345
346 if (lastOpStatus_ == PLAYER_INITIALIZED || lastOpStatus_ == PLAYER_STOPPED) {
347 return OnPrepare(false);
348 }
349 MEDIA_LOGE("Can not Prepare, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
350 return MSERR_INVALID_OPERATION;
351 }
352
SetRenderFirstFrame(bool display)353 int32_t PlayerServer::SetRenderFirstFrame(bool display)
354 {
355 std::lock_guard<std::mutex> lock(mutex_);
356 if (lastOpStatus_ != PLAYER_INITIALIZED) {
357 MEDIA_LOGE("Can not SetRenderFirstFrame, currentState is not PLAYER_INITIALIZED");
358 return MSERR_INVALID_OPERATION;
359 }
360 MEDIA_LOGD("PlayerServer SetRenderFirstFrame in, display %{public}d", display);
361
362 if (isLiveStream_) {
363 MEDIA_LOGE("Can not SetRenderFirstFrame, it is live-stream");
364 return MSERR_OK;
365 }
366
367 if (playerEngine_ != nullptr) {
368 int32_t ret = playerEngine_->SetRenderFirstFrame(display);
369 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "SetRenderFirstFrame Failed!");
370 }
371 return MSERR_OK;
372 }
373
SetPlayRange(int64_t start,int64_t end)374 int32_t PlayerServer::SetPlayRange(int64_t start, int64_t end)
375 {
376 std::lock_guard<std::mutex> lock(mutex_);
377 if (lastOpStatus_ != PLAYER_INITIALIZED
378 && lastOpStatus_ != PLAYER_PAUSED
379 && lastOpStatus_ != PLAYER_PLAYBACK_COMPLETE) {
380 MEDIA_LOGE("Can not SetPlayRange, currentState is %{public}s",
381 GetStatusDescription(lastOpStatus_).c_str());
382 return MSERR_INVALID_OPERATION;
383 }
384
385 if (isLiveStream_) {
386 MEDIA_LOGE("Can not SetPlayRange, it is live-stream");
387 return MSERR_OK;
388 }
389
390 if (playerEngine_ != nullptr) {
391 int32_t ret = playerEngine_->SetPlayRange(start, end);
392 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "SetPlayRange Failed!");
393 }
394 return MSERR_OK;
395 }
396
SetPlayRangeWithMode(int64_t start,int64_t end,PlayerSeekMode mode)397 int32_t PlayerServer::SetPlayRangeWithMode(int64_t start, int64_t end, PlayerSeekMode mode)
398 {
399 std::lock_guard<std::mutex> lock(mutex_);
400 if (lastOpStatus_ != PLAYER_INITIALIZED
401 && lastOpStatus_ != PLAYER_PREPARED
402 && lastOpStatus_ != PLAYER_PAUSED
403 && lastOpStatus_ != PLAYER_STOPPED
404 && lastOpStatus_ != PLAYER_PLAYBACK_COMPLETE) {
405 MEDIA_LOGE("Can not SetPlayRangeWithMode, currentState is %{public}s",
406 GetStatusDescription(lastOpStatus_).c_str());
407 return MSERR_INVALID_OPERATION;
408 }
409 if (isLiveStream_) {
410 MEDIA_LOGE("Can not SetPlayRangeWithMode, it is live-stream");
411 return MSERR_INVALID_OPERATION;
412 }
413 auto setPlayRangeTask = std::make_shared<TaskHandler<void>>([this, start, end, mode]() {
414 MediaTrace::TraceBegin("PlayerServer::SetPlayRange", FAKE_POINTER(this));
415 auto currState = std::static_pointer_cast<BaseState>(GetCurrState());
416 (void)currState->SetPlayRangeWithMode(start, end, mode);
417 });
418 int ret = taskMgr_.LaunchTask(setPlayRangeTask, PlayerServerTaskType::STATE_CHANGE, "set playRange");
419 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "SetPlayRangeWithMode failed");
420 return MSERR_OK;
421 }
422
HandleSetPlayRange(int64_t start,int64_t end,PlayerSeekMode mode)423 int32_t PlayerServer::HandleSetPlayRange(int64_t start, int64_t end, PlayerSeekMode mode)
424 {
425 MEDIA_LOGI("KPI-TRACE: PlayerServer HandleSetPlayRange in");
426 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_INVALID_OPERATION, "playerEngine_ is nullptr");
427 int32_t ret = playerEngine_->SetPlayRangeWithMode(start, end, mode);
428 taskMgr_.MarkTaskDone("HandleSetPlayRange done");
429 MediaTrace::TraceEnd("PlayerServer::SetPlayRange", FAKE_POINTER(this));
430 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine SetPlayRangeWithMode Failed!");
431 return MSERR_OK;
432 }
433
PrepareAsync()434 int32_t PlayerServer::PrepareAsync()
435 {
436 if (inReleasing_.load()) {
437 MEDIA_LOGE("Can not Prepare, now in releasing");
438 return MSERR_INVALID_OPERATION;
439 }
440 std::lock_guard<std::mutex> lock(mutex_);
441 MEDIA_LOGD("KPI-TRACE: PlayerServer PrepareAsync in");
442
443 if (lastOpStatus_ == PLAYER_INITIALIZED || lastOpStatus_ == PLAYER_STOPPED) {
444 return OnPrepare(false);
445 }
446 MEDIA_LOGE("Can not Prepare, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
447 return MSERR_INVALID_OPERATION;
448 }
449
OnPrepare(bool sync)450 int32_t PlayerServer::OnPrepare(bool sync)
451 {
452 MEDIA_LOGD("KPI-TRACE: PlayerServer OnPrepare in");
453 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
454
455 int32_t ret = MSERR_OK;
456 lastOpStatus_ = PLAYER_PREPARED;
457 isInterruptNeeded_ = false;
458 playerEngine_->SetInterruptState(false);
459 auto preparedTask = std::make_shared<TaskHandler<int32_t>>([this]() {
460 MediaTrace::TraceBegin("PlayerServer::PrepareAsync", FAKE_POINTER(this));
461 #ifdef SUPPORT_VIDEO
462 {
463 std::lock_guard<std::mutex> lock(surfaceMutex_);
464 if (surface_ != nullptr) {
465 int32_t res = playerEngine_->SetVideoSurface(surface_);
466 CHECK_AND_RETURN_RET_LOG(res == MSERR_OK,
467 static_cast<int32_t>(MSERR_INVALID_OPERATION), "Engine SetVideoSurface Failed!");
468 }
469 }
470 #endif
471 auto currState = std::static_pointer_cast<BaseState>(GetCurrState());
472 return currState->Prepare();
473 });
474
475 ret = taskMgr_.LaunchTask(preparedTask, PlayerServerTaskType::STATE_CHANGE, "prepare");
476 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "Prepare launch task failed");
477
478 if (sync) {
479 (void)preparedTask->GetResult(); // wait HandlePrpare
480 }
481 MEDIA_LOGD("KPI-TRACE: PlayerServer OnPrepare out");
482 return MSERR_OK;
483 }
484
HandlePrepare()485 int32_t PlayerServer::HandlePrepare()
486 {
487 MEDIA_LOGI("KPI-TRACE: PlayerServer HandlePrepare in");
488 int32_t ret = playerEngine_->PrepareAsync();
489 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Server Prepare Failed!");
490 CHECK_AND_RETURN_RET_LOG(!isInterruptNeeded_, MSERR_OK, "Cancel prepare");
491
492 if (config_.leftVolume < 1.0f) {
493 (void)playerEngine_->SetVolume(config_.leftVolume, config_.rightVolume);
494 }
495 if (config_.looping) {
496 (void)playerEngine_->SetLooping(config_.looping);
497 }
498 if (config_.speedMode != SPEED_FORWARD_1_00_X) {
499 MediaTrace::TraceBegin("PlayerServer::SetPlaybackSpeed", FAKE_POINTER(this));
500 auto rateTask = std::make_shared<TaskHandler<void>>([this]() {
501 int ret = playerEngine_->SetPlaybackSpeed(config_.speedMode);
502 CHECK_AND_RETURN_LOG(ret == MSERR_OK, "Engine SetPlaybackSpeed Failed!");
503 });
504 auto cancelTask = std::make_shared<TaskHandler<void>>([this]() {
505 MEDIA_LOGI("Interrupted speed action");
506 taskMgr_.MarkTaskDone("interrupted speed done");
507 });
508
509 (void)taskMgr_.SpeedTask(rateTask, cancelTask, "prepare-speed", config_.speedMode);
510 }
511
512 if (config_.effectMode != OHOS::AudioStandard::AudioEffectMode::EFFECT_DEFAULT) {
513 MediaTrace::TraceBegin("PlayerServer::SetAudioEffectMode", FAKE_POINTER(this));
514 auto effectTask = std::make_shared<TaskHandler<void>>([this]() {
515 int ret = playerEngine_->SetAudioEffectMode(config_.effectMode);
516 taskMgr_.MarkTaskDone("SetAudioEffectMode done");
517 CHECK_AND_RETURN_LOG(ret == MSERR_OK, "Engine SetAudioEffectMode Failed!");
518 });
519 (void)taskMgr_.LaunchTask(effectTask, PlayerServerTaskType::STATE_CHANGE, "SetAudioEffectMode", nullptr);
520 }
521
522 return MSERR_OK;
523 }
524
Play()525 int32_t PlayerServer::Play()
526 {
527 std::lock_guard<std::mutex> lock(mutex_);
528 MEDIA_LOGD("PlayerServer Play in");
529 if (lastOpStatus_ == PLAYER_PREPARED || lastOpStatus_ == PLAYER_PLAYBACK_COMPLETE ||
530 lastOpStatus_ == PLAYER_PAUSED) {
531 return OnPlay();
532 }
533 MEDIA_LOGE("Can not Play, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
534 return MSERR_INVALID_OPERATION;
535 }
536
OnPlay()537 int32_t PlayerServer::OnPlay()
538 {
539 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
540 if (lastOpStatus_ == PLAYER_PLAYBACK_COMPLETE && dataSrc_ != nullptr) {
541 int64_t size = 0;
542 (void)dataSrc_->GetSize(size);
543 if (size == -1) {
544 MEDIA_LOGE("Can not play in complete status, it is live-stream");
545 OnErrorMessage(MSERR_EXT_API9_UNSUPPORT_CAPABILITY, "Can not play in complete status, it is live-stream");
546 return MSERR_INVALID_OPERATION;
547 }
548 }
549
550 auto playingTask = std::make_shared<TaskHandler<void>>([this]() {
551 MediaTrace::TraceBegin("PlayerServer::Play", FAKE_POINTER(this));
552 auto currState = std::static_pointer_cast<BaseState>(GetCurrState());
553 (void)currState->Play();
554 });
555 MEDIA_LOGD("PlayerServer OnPlay in");
556 int ret = taskMgr_.LaunchTask(playingTask, PlayerServerTaskType::STATE_CHANGE, "play");
557 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "Play failed");
558
559 lastOpStatus_ = PLAYER_STARTED;
560 return MSERR_OK;
561 }
562
HandlePlay()563 int32_t PlayerServer::HandlePlay()
564 {
565 ExitSeekContinous(true);
566 int32_t ret = playerEngine_->Play();
567 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine Play Failed!");
568
569 return MSERR_OK;
570 }
571
BackGroundChangeState(PlayerStates state,bool isBackGroundCb)572 int32_t PlayerServer::BackGroundChangeState(PlayerStates state, bool isBackGroundCb)
573 {
574 backgroundState_ = state;
575 MEDIA_LOGD("PlayerServer::BackGroundChangeState is called");
576 isBackgroundCb_ = isBackGroundCb;
577 if (state == PLAYER_PAUSED) {
578 isBackgroundChanged_ = true;
579 return PlayerServer::Pause();
580 }
581 if (state == PLAYER_STARTED) {
582 isBackgroundChanged_ = true;
583 return PlayerServer::Play();
584 }
585 return MSERR_INVALID_OPERATION;
586 }
587
Pause()588 int32_t PlayerServer::Pause()
589 {
590 std::lock_guard<std::mutex> lock(mutex_);
591 MEDIA_LOGI("0x%{public}06" PRIXPTR " PlayerServer Pause in", FAKE_POINTER(this));
592 if (lastOpStatus_ == PLAYER_PAUSED) {
593 MEDIA_LOGE("Can not Pause, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
594 return MSERR_OK;
595 }
596 if (lastOpStatus_ != PLAYER_STARTED) {
597 MEDIA_LOGE("Can not Pause, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
598 return MSERR_INVALID_OPERATION;
599 }
600 return OnPause(false);
601 }
602
OnPause(bool isSystemOperation)603 int32_t PlayerServer::OnPause(bool isSystemOperation)
604 {
605 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
606 MEDIA_LOGI("0x%{public}06" PRIXPTR " PlayerServer OnPause in", FAKE_POINTER(this));
607
608 auto pauseTask = std::make_shared<TaskHandler<void>>([this, isSystemOperation]() {
609 MediaTrace::TraceBegin("PlayerServer::Pause", FAKE_POINTER(this));
610 auto currState = std::static_pointer_cast<BaseState>(GetCurrState());
611 (void)currState->Pause(isSystemOperation);
612 });
613
614 int ret = taskMgr_.LaunchTask(pauseTask, PlayerServerTaskType::STATE_CHANGE, "pause");
615 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "Pause failed");
616
617 lastOpStatus_ = PLAYER_PAUSED;
618 return MSERR_OK;
619 }
620
HandlePause(bool isSystemOperation)621 int32_t PlayerServer::HandlePause(bool isSystemOperation)
622 {
623 MEDIA_LOGI("KPI-TRACE: PlayerServer HandlePause in");
624 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_INVALID_OPERATION, "playerEngine_ is nullptr");
625 int32_t ret = playerEngine_->Pause(isSystemOperation);
626 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine Pause Failed!");
627
628 return MSERR_OK;
629 }
630
HandlePauseDemuxer()631 int32_t PlayerServer::HandlePauseDemuxer()
632 {
633 MEDIA_LOGI("KPI-TRACE: PlayerServer HandlePauseDemuxer in");
634 MediaTrace::TraceBegin("PlayerServer::HandlePauseDemuxer", FAKE_POINTER(this));
635 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_INVALID_OPERATION, "playerEngine_ is nullptr");
636 int32_t ret = playerEngine_->PauseDemuxer();
637 taskMgr_.MarkTaskDone("PauseDemuxer done");
638 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine PauseDemuxer Failed!");
639 return MSERR_OK;
640 }
641
HandleResumeDemuxer()642 int32_t PlayerServer::HandleResumeDemuxer()
643 {
644 MEDIA_LOGI("KPI-TRACE: PlayerServer HandleResumeDemuxer in");
645 MediaTrace::TraceBegin("PlayerServer::HandleResumeDemuxer", FAKE_POINTER(this));
646 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_INVALID_OPERATION, "playerEngine_ is nullptr");
647 int32_t ret = playerEngine_->ResumeDemuxer();
648 taskMgr_.MarkTaskDone("ResumeDemuxer done");
649 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine ResumeDemuxer Failed!");
650 return MSERR_OK;
651 }
652
Stop()653 int32_t PlayerServer::Stop()
654 {
655 std::lock_guard<std::mutex> lock(mutex_);
656
657 if (lastOpStatus_ == PLAYER_PREPARED || lastOpStatus_ == PLAYER_STARTED ||
658 lastOpStatus_ == PLAYER_PLAYBACK_COMPLETE || lastOpStatus_ == PLAYER_PAUSED) {
659 MediaTrace::TraceBegin("PlayerServer::Stop", FAKE_POINTER(this));
660 disableStoppedCb_ = false;
661 return OnStop(false);
662 }
663 MEDIA_LOGE("Can not Stop, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
664 return MSERR_INVALID_OPERATION;
665 }
666
OnStop(bool sync)667 int32_t PlayerServer::OnStop(bool sync)
668 {
669 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
670 isInterruptNeeded_ = true;
671 playerEngine_->SetInterruptState(true);
672 taskMgr_.ClearAllTask();
673 auto stopTask = std::make_shared<TaskHandler<void>>([this]() {
674 auto currState = std::static_pointer_cast<BaseState>(GetCurrState());
675 (void)currState->Stop();
676 });
677
678 (void)taskMgr_.LaunchTask(stopTask, PlayerServerTaskType::STATE_CHANGE, "stop");
679 if (sync) {
680 (void)stopTask->GetResult(); // wait HandleStop
681 }
682 lastOpStatus_ = PLAYER_STOPPED;
683 MEDIA_LOGD("PlayerServer OnStop out");
684 return MSERR_OK;
685 }
686
HandleStop()687 int32_t PlayerServer::HandleStop()
688 {
689 ExitSeekContinous(false);
690 int32_t ret = playerEngine_->Stop();
691 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine Stop Failed!");
692
693 return MSERR_OK;
694 }
695
Reset()696 int32_t PlayerServer::Reset()
697 {
698 std::lock_guard<std::mutex> lock(mutex_);
699 MediaTrace trace("PlayerServer::Reset");
700 if (lastOpStatus_ == PLAYER_IDLE) {
701 MEDIA_LOGE("Can not Reset, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
702 return MSERR_INVALID_OPERATION;
703 }
704 return OnReset();
705 }
706
OnReset()707 int32_t PlayerServer::OnReset()
708 {
709 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
710 disableStoppedCb_ = true;
711 if (lastOpStatus_ == PLAYER_PREPARED || lastOpStatus_ == PLAYER_STARTED ||
712 lastOpStatus_ == PLAYER_PLAYBACK_COMPLETE || lastOpStatus_ == PLAYER_PAUSED) {
713 (void)OnStop(true);
714 } else if (lastOpStatus_ == PLAYER_STATE_ERROR && playerEngine_ != nullptr) {
715 isInterruptNeeded_ = true;
716 MEDIA_LOGW("error state interrupt");
717 playerEngine_->SetInterruptState(true);
718 }
719
720 MEDIA_LOGD("PlayerServer OnReset in");
721 taskMgr_.ClearAllTask();
722 auto idleTask = std::make_shared<TaskHandler<void>>([this]() {
723 ChangeState(idleState_);
724 });
725 (void)taskMgr_.LaunchTask(idleTask, PlayerServerTaskType::STATE_CHANGE, "reset");
726 (void)idleTask->GetResult();
727 (void)taskMgr_.Reset();
728 lastOpStatus_ = PLAYER_IDLE;
729 isLiveStream_ = false;
730 subtitleTrackNum_ = 0;
731
732 return MSERR_OK;
733 }
734
HandleReset()735 int32_t PlayerServer::HandleReset()
736 {
737 (void)playerEngine_->Reset();
738 std::thread([playerEngine = std::move(playerEngine_)]() mutable -> void {
739 std::unique_ptr<IPlayerEngine> engine = std::move(playerEngine);
740 }).detach();
741 dataSrc_ = nullptr;
742 config_.looping = false;
743 uriHelper_ = nullptr;
744 mediaSource_ = nullptr;
745 {
746 decltype(subUriHelpers_) temp;
747 temp.swap(subUriHelpers_);
748 }
749 lastErrMsg_.clear();
750 errorCbOnce_ = false;
751 disableNextSeekDone_ = false;
752 Format format;
753 OnInfo(INFO_TYPE_STATE_CHANGE, PLAYER_IDLE, format);
754 return MSERR_OK;
755 }
756
Release()757 int32_t PlayerServer::Release()
758 {
759 std::lock_guard<std::mutex> lock(mutex_);
760 MediaTrace trace("PlayerServer::Release");
761 inReleasing_ = true;
762 {
763 std::lock_guard<std::mutex> lockCb(mutexCb_);
764 playerCb_ = nullptr;
765 }
766 MEDIA_LOGD("PlayerServer Release in");
767 if (lastOpStatus_ != PLAYER_IDLE) {
768 (void)OnReset();
769 }
770 #ifdef SUPPORT_VIDEO
771 if (surface_ != nullptr) {
772 surface_ = nullptr;
773 }
774 #endif
775 return MSERR_OK;
776 }
777
SetVolume(float leftVolume,float rightVolume)778 int32_t PlayerServer::SetVolume(float leftVolume, float rightVolume)
779 {
780 std::lock_guard<std::mutex> lock(mutex_);
781 if (lastOpStatus_ == PLAYER_STATE_ERROR) {
782 MEDIA_LOGE("Can not SetVolume, currentState is PLAYER_STATE_ERROR");
783 return MSERR_INVALID_OPERATION;
784 }
785 MEDIA_LOGD("PlayerServer SetVolume in leftVolume %{public}f %{public}f", leftVolume, rightVolume);
786 constexpr float maxVolume = 1.0f;
787 if ((leftVolume < 0) || (leftVolume > maxVolume) || (rightVolume < 0) || (rightVolume > maxVolume)) {
788 MEDIA_LOGE("SetVolume failed, the volume should be set to a value ranging from 0 to 5");
789 return MSERR_INVALID_OPERATION;
790 }
791
792 config_.leftVolume = leftVolume;
793 config_.rightVolume = rightVolume;
794 if (IsEngineStarted()) {
795 auto task = std::make_shared<TaskHandler<void>>([this]() {
796 (void)playerEngine_->SetVolume(config_.leftVolume, config_.rightVolume);
797 taskMgr_.MarkTaskDone("volume done");
798 });
799 (void)taskMgr_.LaunchTask(task, PlayerServerTaskType::STATE_CHANGE, "volume");
800 } else {
801 MEDIA_LOGI("Waiting for the engine state is <prepared> to take effect");
802 }
803
804 Format format;
805 (void)format.PutFloatValue(PlayerKeys::PLAYER_VOLUME_LEVEL, leftVolume);
806 MEDIA_LOGI("SetVolume callback");
807 OnInfoNoChangeStatus(INFO_TYPE_VOLUME_CHANGE, 0, format);
808 return MSERR_OK;
809 }
810
IsEngineStarted()811 bool PlayerServer::IsEngineStarted()
812 {
813 if (playerEngine_ != nullptr) {
814 if (GetCurrState() == preparedState_ || GetCurrState() == playingState_ ||
815 GetCurrState() == pausedState_ || GetCurrState() == playbackCompletedState_) {
816 return true;
817 }
818 }
819 return false;
820 }
821
IsValidSeekMode(PlayerSeekMode mode)822 bool PlayerServer::IsValidSeekMode(PlayerSeekMode mode)
823 {
824 switch (mode) {
825 case SEEK_PREVIOUS_SYNC:
826 case SEEK_NEXT_SYNC:
827 case SEEK_CLOSEST_SYNC:
828 case SEEK_CLOSEST:
829 case SEEK_CONTINOUS:
830 break;
831 default:
832 MEDIA_LOGE("Unknown seek mode %{public}d", mode);
833 return false;
834 }
835 return true;
836 }
837
Seek(int32_t mSeconds,PlayerSeekMode mode)838 int32_t PlayerServer::Seek(int32_t mSeconds, PlayerSeekMode mode)
839 {
840 std::lock_guard<std::mutex> lock(mutex_);
841 int32_t checkRet = CheckSeek(mSeconds, mode);
842 CHECK_AND_RETURN_RET_LOG(checkRet == MSERR_OK, checkRet, "check seek faild");
843
844 MEDIA_LOGD("seek position %{public}d, seek mode is %{public}d", mSeconds, mode);
845 mSeconds = std::max(0, mSeconds);
846
847 if (mode == SEEK_CONTINOUS) {
848 return SeekContinous(mSeconds);
849 }
850 auto seekTask = std::make_shared<TaskHandler<void>>([this, mSeconds, mode]() {
851 MediaTrace::TraceBegin("PlayerServer::Seek", FAKE_POINTER(this));
852 MEDIA_LOGI("PlayerServer::Seek start");
853 auto currState = std::static_pointer_cast<BaseState>(GetCurrState());
854 (void)currState->Seek(mSeconds, mode);
855 MEDIA_LOGI("PlayerServer::Seek end");
856 });
857
858 auto cancelTask = std::make_shared<TaskHandler<void>>([this, mSeconds]() {
859 MEDIA_LOGI("Interrupted seek action");
860 Format format;
861 OnInfoNoChangeStatus(INFO_TYPE_SEEKDONE, mSeconds, format);
862 taskMgr_.MarkTaskDone("interrupted seek done");
863 });
864
865 int32_t ret = taskMgr_.SeekTask(seekTask, cancelTask, "seek", mode, mSeconds);
866 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "Seek failed");
867
868 MEDIA_LOGI("Queue seekTask end, position %{public}d, seek mode is %{public}d", mSeconds, mode);
869 return MSERR_OK;
870 }
871
HandleSeek(int32_t mSeconds,PlayerSeekMode mode)872 int32_t PlayerServer::HandleSeek(int32_t mSeconds, PlayerSeekMode mode)
873 {
874 MEDIA_LOGI("KPI-TRACE: PlayerServer HandleSeek in, mSeconds: %{public}d, mSeconds: %{public}d, "
875 "instanceId: %{public}" PRIu64 "", mSeconds, mode, instanceId_);
876 ExitSeekContinous(false);
877 int32_t ret = playerEngine_->Seek(mSeconds, mode);
878 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine Seek Failed!");
879 MEDIA_LOGI("PlayerServer HandleSeek end");
880 return MSERR_OK;
881 }
882
GetCurrentTime(int32_t & currentTime)883 int32_t PlayerServer::GetCurrentTime(int32_t ¤tTime)
884 {
885 // delete lock, cannot be called concurrently with Reset or Release
886 currentTime = -1;
887 if (lastOpStatus_ == PLAYER_IDLE || lastOpStatus_ == PLAYER_STATE_ERROR) {
888 MEDIA_LOGE("Can not GetCurrentTime, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
889 return MSERR_INVALID_OPERATION;
890 }
891 if (isLiveStream_ && dataSrc_ == nullptr) {
892 MEDIA_LOGD("It is live-stream");
893 return MSERR_OK;
894 }
895
896 MEDIA_LOGD("PlayerServer GetCurrentTime in, currentState is %{public}s",
897 GetStatusDescription(lastOpStatus_).c_str());
898 if (lastOpStatus_ != PLAYER_PREPARED && lastOpStatus_ != PLAYER_STARTED && lastOpStatus_ != PLAYER_PAUSED &&
899 lastOpStatus_ != PLAYER_PLAYBACK_COMPLETE) {
900 currentTime = 0;
901 MEDIA_LOGD("get position at state: %{public}s, return 0", GetStatusDescription(lastOpStatus_).c_str());
902 return MSERR_OK;
903 }
904
905 if (playerEngine_ != nullptr) {
906 int32_t ret = playerEngine_->GetCurrentTime(currentTime);
907 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine GetCurrentTime Failed!");
908 }
909 return MSERR_OK;
910 }
911
GetVideoTrackInfo(std::vector<Format> & videoTrack)912 int32_t PlayerServer::GetVideoTrackInfo(std::vector<Format> &videoTrack)
913 {
914 std::lock_guard<std::mutex> lock(mutex_);
915 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
916
917 if (lastOpStatus_ != PLAYER_PREPARED && lastOpStatus_ != PLAYER_PAUSED &&
918 lastOpStatus_ != PLAYER_STARTED && lastOpStatus_ != PLAYER_PLAYBACK_COMPLETE) {
919 MEDIA_LOGE("Can not get track info, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
920 return MSERR_INVALID_OPERATION;
921 }
922 MEDIA_LOGD("PlayerServer GetVideoTrackInfo in");
923 int32_t ret = playerEngine_->GetVideoTrackInfo(videoTrack);
924 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine GetVideoTrackInfo Failed!");
925 return MSERR_OK;
926 }
927
GetPlaybackInfo(Format & playbackInfo)928 int32_t PlayerServer::GetPlaybackInfo(Format &playbackInfo)
929 {
930 std::lock_guard<std::mutex> lock(mutex_);
931 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
932
933 if (lastOpStatus_ != PLAYER_PREPARED && lastOpStatus_ != PLAYER_PAUSED &&
934 lastOpStatus_ != PLAYER_STARTED && lastOpStatus_ != PLAYER_PLAYBACK_COMPLETE) {
935 MEDIA_LOGE("Can not get track info, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
936 return MSERR_INVALID_OPERATION;
937 }
938 MEDIA_LOGD("PlayerServer GetPlaybackInfo in");
939 int32_t ret = playerEngine_->GetPlaybackInfo(playbackInfo);
940 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine GetPlaybackInfo Failed!");
941 return MSERR_OK;
942 }
943
GetAudioTrackInfo(std::vector<Format> & audioTrack)944 int32_t PlayerServer::GetAudioTrackInfo(std::vector<Format> &audioTrack)
945 {
946 std::lock_guard<std::mutex> lock(mutex_);
947 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
948
949 if (lastOpStatus_ != PLAYER_PREPARED && lastOpStatus_ != PLAYER_PAUSED &&
950 lastOpStatus_ != PLAYER_STARTED && lastOpStatus_ != PLAYER_PLAYBACK_COMPLETE) {
951 MEDIA_LOGE("Can not get track info, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
952 return MSERR_INVALID_OPERATION;
953 }
954 MEDIA_LOGD("PlayerServer GetAudioTrackInfo in");
955 int32_t ret = playerEngine_->GetAudioTrackInfo(audioTrack);
956 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine GetAudioTrackInfo Failed!");
957 return MSERR_OK;
958 }
959
GetSubtitleTrackInfo(std::vector<Format> & subtitleTrack)960 int32_t PlayerServer::GetSubtitleTrackInfo(std::vector<Format> &subtitleTrack)
961 {
962 std::lock_guard<std::mutex> lock(mutex_);
963 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
964
965 if (lastOpStatus_ != PLAYER_PREPARED && lastOpStatus_ != PLAYER_PAUSED &&
966 lastOpStatus_ != PLAYER_STARTED && lastOpStatus_ != PLAYER_PLAYBACK_COMPLETE) {
967 MEDIA_LOGE("Can not get track info, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
968 return MSERR_INVALID_OPERATION;
969 }
970 MEDIA_LOGD("PlayerServer GetSubtitleTrackInfo in");
971 int32_t ret = playerEngine_->GetSubtitleTrackInfo(subtitleTrack);
972 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine GetSubtitleTrackInfo Failed!");
973 return MSERR_OK;
974 }
975
GetVideoWidth()976 int32_t PlayerServer::GetVideoWidth()
977 {
978 std::lock_guard<std::mutex> lock(mutex_);
979 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
980
981 if (lastOpStatus_ != PLAYER_PREPARED && lastOpStatus_ != PLAYER_PAUSED &&
982 lastOpStatus_ != PLAYER_STARTED && lastOpStatus_ != PLAYER_STOPPED &&
983 lastOpStatus_ != PLAYER_PLAYBACK_COMPLETE) {
984 MEDIA_LOGE("Can not get track info, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
985 return MSERR_INVALID_OPERATION;
986 }
987 MEDIA_LOGD("PlayerServer GetVideoWidth in");
988 return playerEngine_->GetVideoWidth();
989 }
990
GetVideoHeight()991 int32_t PlayerServer::GetVideoHeight()
992 {
993 std::lock_guard<std::mutex> lock(mutex_);
994 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
995
996 if (lastOpStatus_ != PLAYER_PREPARED && lastOpStatus_ != PLAYER_PAUSED &&
997 lastOpStatus_ != PLAYER_STARTED && lastOpStatus_ != PLAYER_STOPPED &&
998 lastOpStatus_ != PLAYER_PLAYBACK_COMPLETE) {
999 MEDIA_LOGE("Can not get track info, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
1000 return MSERR_INVALID_OPERATION;
1001 }
1002 MEDIA_LOGD("PlayerServer GetVideoHeight in");
1003 return playerEngine_->GetVideoHeight();
1004 }
1005
GetDuration(int32_t & duration)1006 int32_t PlayerServer::GetDuration(int32_t &duration)
1007 {
1008 // delete lock, cannot be called concurrently with Reset or Release
1009 if (lastOpStatus_ == PLAYER_IDLE || lastOpStatus_ == PLAYER_INITIALIZED || lastOpStatus_ == PLAYER_STATE_ERROR) {
1010 MEDIA_LOGE("Can not GetDuration, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
1011 return MSERR_INVALID_OPERATION;
1012 }
1013
1014 MEDIA_LOGD("PlayerServer GetDuration in");
1015 duration = -1;
1016 if (playerEngine_ != nullptr) {
1017 int ret = playerEngine_->GetDuration(duration);
1018 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine GetDuration Failed!");
1019 }
1020 MEDIA_LOGD("PlayerServer GetDuration %{public}d", duration);
1021 return MSERR_OK;
1022 }
1023
ClearConfigInfo()1024 void PlayerServer::ClearConfigInfo()
1025 {
1026 std::lock_guard<std::mutex> lock(mutex_);
1027
1028 config_.looping = false;
1029 config_.leftVolume = INVALID_VALUE;
1030 config_.rightVolume = INVALID_VALUE;
1031 config_.speedMode = SPEED_FORWARD_1_00_X;
1032 config_.url = "";
1033 }
1034
SetPlaybackSpeed(PlaybackRateMode mode)1035 int32_t PlayerServer::SetPlaybackSpeed(PlaybackRateMode mode)
1036 {
1037 std::lock_guard<std::mutex> lock(mutex_);
1038
1039 if ((lastOpStatus_ != PLAYER_STARTED) && (lastOpStatus_ != PLAYER_PREPARED) &&
1040 (lastOpStatus_ != PLAYER_PAUSED) && (lastOpStatus_ != PLAYER_PLAYBACK_COMPLETE)) {
1041 MEDIA_LOGE("Can not SetPlaybackSpeed, currentState is %{public}s",
1042 GetStatusDescription(lastOpStatus_).c_str());
1043 return MSERR_INVALID_OPERATION;
1044 }
1045 MEDIA_LOGD("PlayerServer SetPlaybackSpeed in, mode %{public}d", mode);
1046 if (isLiveStream_) {
1047 MEDIA_LOGE("Can not SetPlaybackSpeed, it is live-stream");
1048 OnErrorMessage(MSERR_EXT_API9_UNSUPPORT_CAPABILITY, "Can not SetPlaybackSpeed, it is live-stream");
1049 return MSERR_INVALID_OPERATION;
1050 }
1051
1052 auto rateTask = std::make_shared<TaskHandler<void>>([this, mode]() {
1053 MediaTrace::TraceBegin("PlayerServer::SetPlaybackSpeed", FAKE_POINTER(this));
1054 auto currState = std::static_pointer_cast<BaseState>(GetCurrState());
1055 (void)currState->SetPlaybackSpeed(mode);
1056 });
1057
1058 auto cancelTask = std::make_shared<TaskHandler<void>>([this, mode]() {
1059 MEDIA_LOGI("Interrupted speed action");
1060 Format format;
1061 OnInfoNoChangeStatus(INFO_TYPE_SPEEDDONE, mode, format);
1062 taskMgr_.MarkTaskDone("interrupted speed done");
1063 });
1064
1065 int ret = taskMgr_.SpeedTask(rateTask, cancelTask, "speed", config_.speedMode);
1066 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "SetPlaybackSpeed failed");
1067
1068 return MSERR_OK;
1069 }
1070
HandleSetPlaybackSpeed(PlaybackRateMode mode)1071 int32_t PlayerServer::HandleSetPlaybackSpeed(PlaybackRateMode mode)
1072 {
1073 if (config_.speedMode == mode) {
1074 MEDIA_LOGD("The speed mode is same, mode = %{public}d", mode);
1075 Format format;
1076 OnInfoNoChangeStatus(INFO_TYPE_SPEEDDONE, mode, format);
1077 taskMgr_.MarkTaskDone("set speed mode is same");
1078 MediaTrace::TraceEnd("PlayerServer::SetPlaybackSpeed", FAKE_POINTER(this));
1079 return MSERR_OK;
1080 }
1081
1082 if (playerEngine_ != nullptr) {
1083 int ret = playerEngine_->SetPlaybackSpeed(mode);
1084 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine SetPlaybackSpeed Failed!");
1085 }
1086 config_.speedMode = mode;
1087 return MSERR_OK;
1088 }
1089
SetMediaSource(const std::shared_ptr<AVMediaSource> & mediaSource,AVPlayStrategy strategy)1090 int32_t PlayerServer::SetMediaSource(const std::shared_ptr<AVMediaSource> &mediaSource, AVPlayStrategy strategy)
1091 {
1092 std::lock_guard<std::mutex> lock(mutex_);
1093 MediaTrace trace("PlayerServer::SetMediaSource");
1094 CHECK_AND_RETURN_RET_LOG(mediaSource != nullptr, MSERR_INVALID_VAL, "mediaSource is nullptr");
1095
1096 mediaSource_ = mediaSource;
1097 strategy_ = strategy;
1098
1099 std::string uri = mediaSource_->url;
1100 std::string mimeType = mediaSource_->GetMimeType();
1101 size_t pos1 = uri.find("?");
1102 size_t pos2 = uri.find("offset=");
1103 size_t pos3 = uri.find("&");
1104 if (mimeType == AVMimeType::APPLICATION_M3U8 && pos1 != std::string::npos && pos2 != std::string::npos &&
1105 pos3 != std::string::npos) {
1106 std::string fdStr = uri.substr(strlen("fd://"), pos1 - strlen("fd://"));
1107 std::string offsetStr = uri.substr(pos2 + strlen("offset="), pos3 - pos2 - strlen("offset="));
1108 std::string sizeStr = uri.substr(pos3 + sizeof("&size"));
1109 int32_t fd = stoi(fdStr);
1110 int32_t offset = stoi(offsetStr);
1111 int32_t size = stoi(sizeStr);
1112
1113 auto uriHelper = std::make_unique<UriHelper>(fd, offset, size);
1114 CHECK_AND_RETURN_RET_LOG(uriHelper->AccessCheck(UriHelper::URI_READ), MSERR_INVALID_VAL, "Failed ro read fd.");
1115 uriHelper_ = std::move(uriHelper);
1116 mediaSource_->url = uriHelper_->FormattedUri();
1117 }
1118
1119 int32_t ret = InitPlayEngine(mediaSource->url);
1120 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "SetMediaSource Failed!");
1121
1122 config_.url = mediaSource_->url;
1123 config_.header = mediaSource_->header;
1124 config_.strategy_ = strategy;
1125
1126 return MSERR_OK;
1127 }
1128
HandleEos()1129 void PlayerServer::HandleEos()
1130 {
1131 if (config_.looping.load()) {
1132 auto seekTask = std::make_shared<TaskHandler<void>>([this]() {
1133 MediaTrace::TraceBegin("PlayerServer::Seek", FAKE_POINTER(this));
1134 disableNextSeekDone_ = true;
1135 auto currState = std::static_pointer_cast<BaseState>(GetCurrState());
1136 if (playerEngine_ != nullptr) {
1137 int64_t startTime = playerEngine_->GetPlayRangeStartTime();
1138 int64_t endTime = playerEngine_->GetPlayRangeEndTime();
1139 PlayerSeekMode seekMode = static_cast<PlayerSeekMode>(playerEngine_->GetPlayRangeSeekMode());
1140 int32_t seekTime = (startTime != -1 && endTime != -1) ? startTime : 0;
1141 (void)currState->Seek(seekTime, seekMode);
1142 } else {
1143 (void)currState->Seek(0, SEEK_PREVIOUS_SYNC);
1144 }
1145 });
1146
1147 auto cancelTask = std::make_shared<TaskHandler<void>>([this]() {
1148 MEDIA_LOGI("Interrupted seek action");
1149 taskMgr_.MarkTaskDone("interrupted seek done");
1150 disableNextSeekDone_ = false;
1151 });
1152
1153 int32_t ret = taskMgr_.SeekTask(seekTask, cancelTask, "eos seek", SEEK_PREVIOUS_SYNC, 0);
1154 CHECK_AND_RETURN_LOG(ret == MSERR_OK, "Seek failed");
1155 }
1156 }
1157
PreparedHandleEos()1158 void PlayerServer::PreparedHandleEos()
1159 {
1160 MEDIA_LOGI("PlayerServer PreparedHandleEos in");
1161 if (!config_.looping.load()) {
1162 lastOpStatus_ = PLAYER_PLAYBACK_COMPLETE;
1163 ChangeState(playbackCompletedState_);
1164 (void)taskMgr_.MarkTaskDone("play->completed done");
1165 }
1166 }
1167
HandleInterruptEvent(const Format & infoBody)1168 void PlayerServer::HandleInterruptEvent(const Format &infoBody)
1169 {
1170 MEDIA_LOGI("0x%{public}06" PRIXPTR " HandleInterruptEvent in ", FAKE_POINTER(this));
1171 int32_t hintType = -1;
1172 int32_t forceType = -1;
1173 int32_t eventType = -1;
1174 (void)infoBody.GetIntValue(PlayerKeys::AUDIO_INTERRUPT_TYPE, eventType);
1175 (void)infoBody.GetIntValue(PlayerKeys::AUDIO_INTERRUPT_FORCE, forceType);
1176 (void)infoBody.GetIntValue(PlayerKeys::AUDIO_INTERRUPT_HINT, hintType);
1177 if (forceType == OHOS::AudioStandard::INTERRUPT_FORCE) {
1178 if (hintType == OHOS::AudioStandard::INTERRUPT_HINT_PAUSE ||
1179 hintType == OHOS::AudioStandard::INTERRUPT_HINT_STOP) {
1180 interruptEventState_ = PLAYER_IDLE;
1181 }
1182 }
1183 }
1184
HandleAudioDeviceChangeEvent(const Format & infoBody)1185 void PlayerServer::HandleAudioDeviceChangeEvent(const Format &infoBody)
1186 {
1187 MEDIA_LOGI("0x%{public}06" PRIXPTR " HandleAudioDeviceChangeEvent in ", FAKE_POINTER(this));
1188 if (!deviceChangeCallbackflag_) {
1189 audioDeviceChangeState_ = PLAYER_PAUSED;
1190 (void)BackGroundChangeState(PLAYER_PAUSED, true);
1191 }
1192 }
1193
GetPlaybackSpeed(PlaybackRateMode & mode)1194 int32_t PlayerServer::GetPlaybackSpeed(PlaybackRateMode &mode)
1195 {
1196 std::lock_guard<std::mutex> lock(mutex_);
1197
1198 if (lastOpStatus_ == PLAYER_STATE_ERROR) {
1199 MEDIA_LOGE("Can not GetDuration, currentState is PLAYER_STATE_ERROR");
1200 return MSERR_INVALID_OPERATION;
1201 }
1202 MEDIA_LOGD("PlayerServer GetPlaybackSpeed in");
1203
1204 mode = config_.speedMode;
1205 return MSERR_OK;
1206 }
1207
SelectBitRate(uint32_t bitRate)1208 int32_t PlayerServer::SelectBitRate(uint32_t bitRate)
1209 {
1210 std::unique_lock<std::mutex> lock(mutex_);
1211 if (playerEngine_ != nullptr) {
1212 int ret = playerEngine_->SelectBitRate(bitRate);
1213 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine SelectBitRate Failed!");
1214 }
1215 return MSERR_OK;
1216 }
1217
1218 #ifdef SUPPORT_VIDEO
SetVideoSurface(sptr<Surface> surface)1219 int32_t PlayerServer::SetVideoSurface(sptr<Surface> surface)
1220 {
1221 std::lock_guard<std::mutex> lock(mutex_);
1222 CHECK_AND_RETURN_RET_LOG(VideoPlayerManager::GetInstance().RegisterVideoPlayer(this) == MSERR_OK,
1223 MSERR_DATA_SOURCE_OBTAIN_MEM_ERROR, "video player is no more than 13");
1224 CHECK_AND_RETURN_RET_LOG(surface != nullptr, MSERR_INVALID_VAL, "surface is nullptr");
1225
1226 bool setSurfaceFirst = lastOpStatus_ == PLAYER_INITIALIZED;
1227 bool switchSurface = lastOpStatus_ == PLAYER_PREPARED ||
1228 lastOpStatus_ == PLAYER_STARTED ||
1229 lastOpStatus_ == PLAYER_PAUSED ||
1230 lastOpStatus_ == PLAYER_STOPPED ||
1231 lastOpStatus_ == PLAYER_PLAYBACK_COMPLETE;
1232
1233 if (setSurfaceFirst) {
1234 MEDIA_LOGI("set surface first in %{public}s state", GetStatusDescription(lastOpStatus_).c_str());
1235 } else if (switchSurface) {
1236 MEDIA_LOGI("switch surface in %{public}s state", GetStatusDescription(lastOpStatus_).c_str());
1237 if (surface_ == nullptr) {
1238 MEDIA_LOGE("old surface is required before switching surface");
1239 return MSERR_INVALID_OPERATION;
1240 }
1241 } else {
1242 MEDIA_LOGE("current state: %{public}s, can not SetVideoSurface", GetStatusDescription(lastOpStatus_).c_str());
1243 return MSERR_INVALID_OPERATION;
1244 }
1245 MEDIA_LOGD("PlayerServer SetVideoSurface in");
1246 {
1247 std::lock_guard<std::mutex> surfaceLock(surfaceMutex_);
1248 surface_ = surface;
1249 }
1250 CHECK_AND_RETURN_RET_LOG(switchSurface || playerEngine_ != nullptr, MSERR_OK,
1251 "current state: %{public}s, playerEngine == nullptr: %{public}d, can not SetVideoSurface",
1252 GetStatusDescription(lastOpStatus_).c_str(), playerEngine_ == nullptr);
1253 auto task = std::make_shared<TaskHandler<void>>([this]() {
1254 std::lock_guard<std::mutex> surfaceLock(surfaceMutex_);
1255 (void)playerEngine_->SetVideoSurface(surface_);
1256 taskMgr_.MarkTaskDone("SetVideoSurface done");
1257 });
1258 int32_t ret = taskMgr_.SetVideoSurfaeTask(task, "SetVideoSurface");
1259 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "SetVideoSurface launch task failed");
1260 return MSERR_OK;
1261 }
1262 #endif
1263
SetDecryptConfig(const sptr<DrmStandard::IMediaKeySessionService> & keySessionProxy,bool svp)1264 int32_t PlayerServer::SetDecryptConfig(const sptr<DrmStandard::IMediaKeySessionService> &keySessionProxy,
1265 bool svp)
1266 {
1267 MEDIA_LOGI("PlayerServer SetDecryptConfig");
1268 #ifdef SUPPORT_AVPLAYER_DRM
1269 std::lock_guard<std::mutex> lock(mutex_);
1270 CHECK_AND_RETURN_RET_LOG(keySessionProxy != nullptr, MSERR_INVALID_VAL, "keySessionProxy is nullptr");
1271
1272 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_INVALID_VAL, "playerEngine_ is nullptr");
1273 int32_t res = playerEngine_->SetDecryptConfig(keySessionProxy, svp);
1274 CHECK_AND_RETURN_RET_LOG(res == MSERR_OK,
1275 static_cast<int32_t>(MSERR_INVALID_OPERATION), "Engine SetDecryptConfig Failed!");
1276 MEDIA_LOGI("PlayerServer SetDecryptConfig out");
1277 return MSERR_OK;
1278 #else
1279 (void)keySessionProxy;
1280 (void)svp;
1281 return 0;
1282 #endif
1283 }
1284
IsPlaying()1285 bool PlayerServer::IsPlaying()
1286 {
1287 std::lock_guard<std::mutex> lock(mutex_);
1288 if (lastOpStatus_ == PLAYER_STATE_ERROR) {
1289 MEDIA_LOGE("0x%{public}06" PRIXPTR " Can not judge IsPlaying, currentState is PLAYER_STATE_ERROR",
1290 FAKE_POINTER(this));
1291 return false;
1292 }
1293
1294 return lastOpStatus_ == PLAYER_STARTED;
1295 }
1296
IsPrepared()1297 bool PlayerServer::IsPrepared()
1298 {
1299 std::lock_guard<std::mutex> lock(mutex_);
1300 if (lastOpStatus_ == PLAYER_STATE_ERROR) {
1301 MEDIA_LOGE("Can not judge IsPrepared, currentState is PLAYER_STATE_ERROR");
1302 return false;
1303 }
1304
1305 return lastOpStatus_ == PLAYER_PREPARED;
1306 }
1307
IsCompleted()1308 bool PlayerServer::IsCompleted()
1309 {
1310 std::lock_guard<std::mutex> lock(mutex_);
1311 if (lastOpStatus_ == PLAYER_STATE_ERROR) {
1312 MEDIA_LOGE("Can not judge IsCompleted, currentState is PLAYER_STATE_ERROR");
1313 return false;
1314 }
1315
1316 return lastOpStatus_ == PLAYER_PLAYBACK_COMPLETE;
1317 }
1318
IsLooping()1319 bool PlayerServer::IsLooping()
1320 {
1321 std::lock_guard<std::mutex> lock(mutex_);
1322 if (lastOpStatus_ == PLAYER_STATE_ERROR) {
1323 MEDIA_LOGE("Can not judge IsLooping, currentState is PLAYER_STATE_ERROR");
1324 return false;
1325 }
1326
1327 return config_.looping;
1328 }
1329
SetLooping(bool loop)1330 int32_t PlayerServer::SetLooping(bool loop)
1331 {
1332 std::lock_guard<std::mutex> lock(mutex_);
1333 if (lastOpStatus_ == PLAYER_STATE_ERROR) {
1334 MEDIA_LOGE("Can not SetLooping, currentState is PLAYER_STATE_ERROR");
1335 return MSERR_INVALID_OPERATION;
1336 }
1337 MEDIA_LOGD("PlayerServer SetLooping in, loop %{public}d", loop);
1338
1339 if (isLiveStream_) {
1340 MEDIA_LOGE("Can not SetLooping, it is live-stream");
1341 OnErrorMessage(MSERR_EXT_API9_UNSUPPORT_CAPABILITY, "Can not SetLooping, it is live-stream");
1342 return MSERR_INVALID_OPERATION;
1343 }
1344
1345 if (lastOpStatus_ == PLAYER_IDLE || lastOpStatus_ == PLAYER_INITIALIZED || GetCurrState() == preparingState_) {
1346 MEDIA_LOGI("Waiting for the engine state is <prepared> to take effect");
1347 config_.looping = loop;
1348 return MSERR_OK;
1349 }
1350
1351 if (playerEngine_ != nullptr) {
1352 int32_t ret = playerEngine_->SetLooping(loop);
1353 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "SetLooping Failed!");
1354 }
1355 config_.looping = loop;
1356 return MSERR_OK;
1357 }
1358
SetParameter(const Format & param)1359 int32_t PlayerServer::SetParameter(const Format ¶m)
1360 {
1361 std::lock_guard<std::mutex> lock(mutex_);
1362 if (lastOpStatus_ == PLAYER_STATE_ERROR) {
1363 MEDIA_LOGE("Can not SetParameter, currentState is PLAYER_STATE_ERROR");
1364 return MSERR_INVALID_OPERATION;
1365 }
1366
1367 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
1368
1369 if (param.ContainKey(PlayerKeys::AUDIO_EFFECT_MODE)) {
1370 int32_t effectMode = OHOS::AudioStandard::AudioEffectMode::EFFECT_DEFAULT;
1371 CHECK_AND_RETURN_RET(param.GetIntValue(PlayerKeys::AUDIO_EFFECT_MODE, effectMode), MSERR_INVALID_VAL);
1372 return SetAudioEffectMode(effectMode);
1373 }
1374
1375 int32_t ret = playerEngine_->SetParameter(param);
1376 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "SetParameter Failed!");
1377
1378 if (param.ContainKey(PlayerKeys::CONTENT_TYPE)) {
1379 config_.effectMode = OHOS::AudioStandard::AudioEffectMode::EFFECT_DEFAULT;
1380 }
1381
1382 return MSERR_OK;
1383 }
1384
SetAudioEffectMode(const int32_t effectMode)1385 int32_t PlayerServer::SetAudioEffectMode(const int32_t effectMode)
1386 {
1387 MEDIA_LOGD("SetAudioEffectMode in");
1388 CHECK_AND_RETURN_RET(lastOpStatus_ == PLAYER_PREPARED || lastOpStatus_ == PLAYER_STARTED ||
1389 lastOpStatus_ == PLAYER_PLAYBACK_COMPLETE || lastOpStatus_ == PLAYER_PAUSED, MSERR_INVALID_OPERATION);
1390 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
1391 CHECK_AND_RETURN_RET_LOG(effectMode <= OHOS::AudioStandard::AudioEffectMode::EFFECT_DEFAULT &&
1392 effectMode >= OHOS::AudioStandard::AudioEffectMode::EFFECT_NONE, MSERR_INVALID_VAL,
1393 "Invalid effectMode parameter");
1394 int32_t ret = playerEngine_->SetAudioEffectMode(effectMode);
1395 if (ret == MSERR_OK) {
1396 config_.effectMode = effectMode;
1397 }
1398
1399 return ret;
1400 }
1401
SetPlayerCallback(const std::shared_ptr<PlayerCallback> & callback)1402 int32_t PlayerServer::SetPlayerCallback(const std::shared_ptr<PlayerCallback> &callback)
1403 {
1404 std::lock_guard<std::mutex> lock(mutex_);
1405 CHECK_AND_RETURN_RET_LOG(callback != nullptr, MSERR_INVALID_VAL, "callback is nullptr");
1406
1407 if (lastOpStatus_ != PLAYER_IDLE && lastOpStatus_ != PLAYER_INITIALIZED) {
1408 MEDIA_LOGE("Can not SetPlayerCallback, currentState is %{public}s",
1409 GetStatusDescription(lastOpStatus_).c_str());
1410 return MSERR_INVALID_OPERATION;
1411 }
1412
1413 {
1414 std::lock_guard<std::mutex> lockCb(mutexCb_);
1415 playerCb_ = callback;
1416 }
1417 return MSERR_OK;
1418 }
1419
SelectTrack(int32_t index,PlayerSwitchMode mode)1420 int32_t PlayerServer::SelectTrack(int32_t index, PlayerSwitchMode mode)
1421 {
1422 std::lock_guard<std::mutex> lock(mutex_);
1423
1424 CHECK_AND_RETURN_RET_LOG(lastOpStatus_ == PLAYER_PREPARED || lastOpStatus_ == PLAYER_STARTED ||
1425 lastOpStatus_ == PLAYER_PAUSED || lastOpStatus_ == PLAYER_PLAYBACK_COMPLETE, MSERR_INVALID_OPERATION,
1426 "invalid state %{public}s", GetStatusDescription(lastOpStatus_).c_str());
1427 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
1428
1429 auto task = std::make_shared<TaskHandler<void>>([this, index, mode]() {
1430 MediaTrace::TraceBegin("PlayerServer::track", FAKE_POINTER(this));
1431 CHECK_AND_RETURN(IsEngineStarted());
1432 int32_t ret = playerEngine_->SelectTrack(index, mode);
1433 taskMgr_.MarkTaskDone("SelectTrack done");
1434 CHECK_AND_RETURN_LOG(ret == MSERR_OK, "failed to SelectTrack");
1435 });
1436 int32_t ret = taskMgr_.LaunchTask(task, PlayerServerTaskType::STATE_CHANGE, "SelectTrack");
1437 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "SelectTrack launch task failed");
1438
1439 return MSERR_OK;
1440 }
1441
DeselectTrack(int32_t index)1442 int32_t PlayerServer::DeselectTrack(int32_t index)
1443 {
1444 std::lock_guard<std::mutex> lock(mutex_);
1445 CHECK_AND_RETURN_RET_LOG(lastOpStatus_ == PLAYER_PREPARED || lastOpStatus_ == PLAYER_STARTED ||
1446 lastOpStatus_ == PLAYER_PAUSED || lastOpStatus_ == PLAYER_PLAYBACK_COMPLETE, MSERR_INVALID_OPERATION,
1447 "invalid state %{public}s", GetStatusDescription(lastOpStatus_).c_str());
1448 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
1449
1450 auto task = std::make_shared<TaskHandler<void>>([this, index]() {
1451 MediaTrace::TraceBegin("PlayerServer::track", FAKE_POINTER(this));
1452 CHECK_AND_RETURN(IsEngineStarted());
1453 int32_t ret = playerEngine_->DeselectTrack(index);
1454 taskMgr_.MarkTaskDone("DeselectTrack done");
1455 CHECK_AND_RETURN_LOG(ret == MSERR_OK, "failed to DeselectTrack");
1456 });
1457 int32_t ret = taskMgr_.LaunchTask(task, PlayerServerTaskType::STATE_CHANGE, "DeselectTrack");
1458 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "DeselectTrack launch task failed");
1459
1460 return MSERR_OK;
1461 }
1462
GetCurrentTrack(int32_t trackType,int32_t & index)1463 int32_t PlayerServer::GetCurrentTrack(int32_t trackType, int32_t &index)
1464 {
1465 CHECK_AND_RETURN_RET_LOG(trackType >= Media::MediaType::MEDIA_TYPE_AUD &&
1466 trackType <= Media::MediaType::MEDIA_TYPE_SUBTITLE, MSERR_INVALID_VAL,
1467 "Invalid trackType %{public}d", trackType);
1468
1469 std::lock_guard<std::mutex> lock(mutex_);
1470 CHECK_AND_RETURN_RET_LOG(lastOpStatus_ == PLAYER_PREPARED || lastOpStatus_ == PLAYER_STARTED ||
1471 lastOpStatus_ == PLAYER_PAUSED || lastOpStatus_ == PLAYER_PLAYBACK_COMPLETE, MSERR_INVALID_OPERATION,
1472 "invalid state %{public}s", GetStatusDescription(lastOpStatus_).c_str());
1473 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
1474
1475 return playerEngine_->GetCurrentTrack(trackType, index);
1476 }
1477
FormatToString(std::string & dumpString,std::vector<Format> & videoTrack)1478 void PlayerServer::FormatToString(std::string &dumpString, std::vector<Format> &videoTrack)
1479 {
1480 for (auto iter = videoTrack.begin(); iter != videoTrack.end(); iter++) {
1481 dumpString += iter->Stringify();
1482 dumpString += '\n';
1483 }
1484 }
1485
DumpInfo(int32_t fd)1486 int32_t PlayerServer::DumpInfo(int32_t fd)
1487 {
1488 std::string dumpString;
1489 if (playerEngine_ == nullptr) {
1490 dumpString +=
1491 "The engine is not created, note: engine can't be created until set source.\n";
1492 }
1493 dumpString += "PlayerServer current state is: " + GetStatusDescription(lastOpStatus_) + "\n";
1494 if (lastErrMsg_.size() != 0) {
1495 dumpString += "PlayerServer last error is: " + lastErrMsg_ + "\n";
1496 }
1497 dumpString += "PlayerServer url is: " + config_.url + "\n";
1498 dumpString += "PlayerServer play back speed is: " + std::to_string(config_.speedMode) + "\n";
1499 std::string loopflag = config_.looping ? "" : "not ";
1500 dumpString += "PlayerServer current " + loopflag + "in looping mode\n";
1501 dumpString += "PlayerServer left volume and right volume is: " +
1502 std::to_string(config_.leftVolume) + ", " + std::to_string(config_.rightVolume) + "\n";
1503 dumpString += "PlayerServer audio effect mode is: " + std::to_string(config_.effectMode) + "\n";
1504 if (playerEngine_ != nullptr) {
1505 dumpString += "PlayerServer enable HEBC: " + std::to_string(playerEngine_->GetHEBCMode()) + "\n";
1506 playerEngine_->OnDumpInfo(fd);
1507 }
1508 dumpString += "PlayerServer client bundle name is: " + GetClientBundleName(appUid_) + "\n";
1509 dumpString += "PlayerServer instance id is: " + std::to_string(instanceId_) + "\n";
1510 std::vector<Format> videoTrack;
1511 (void)GetVideoTrackInfo(videoTrack);
1512 dumpString += "PlayerServer video tracks info: \n";
1513 FormatToString(dumpString, videoTrack);
1514
1515 std::vector<Format> audioTrack;
1516 (void)GetAudioTrackInfo(audioTrack);
1517 dumpString += "PlayerServer audio tracks info: \n";
1518 FormatToString(dumpString, audioTrack);
1519
1520 int32_t currentTime = -1;
1521 (void)GetCurrentTime(currentTime);
1522 dumpString += "PlayerServer current time is: " + std::to_string(currentTime) + "\n";
1523 write(fd, dumpString.c_str(), dumpString.size());
1524
1525 return MSERR_OK;
1526 }
1527
OnError(PlayerErrorType errorType,int32_t errorCode)1528 void PlayerServer::OnError(PlayerErrorType errorType, int32_t errorCode)
1529 {
1530 (void)errorType;
1531 auto errorMsg = MSErrorToExtErrorString(static_cast<MediaServiceErrCode>(errorCode));
1532 return OnErrorMessage(errorCode, errorMsg);
1533 }
1534
OnErrorMessage(int32_t errorCode,const std::string & errorMsg)1535 void PlayerServer::OnErrorMessage(int32_t errorCode, const std::string &errorMsg)
1536 {
1537 if (static_cast<MediaServiceExtErrCodeAPI9>(errorCode) == MSERR_EXT_API9_IO) {
1538 MEDIA_LOGD("0x%{public}06" PRIXPTR " PlayerServer OnErrorMessage Error in", FAKE_POINTER(this));
1539 auto pauseTask = std::make_shared<TaskHandler<void>>([this, errorCode, errorMsg]() {
1540 MediaTrace::TraceBegin("PlayerServer::PauseIoError", FAKE_POINTER(this));
1541 MEDIA_LOGI("PlayerServer::PauseIoError start");
1542 auto currState = std::static_pointer_cast<BaseState>(GetCurrState());
1543 (void)currState->Pause(true);
1544 OnErrorCb(errorCode, errorMsg);
1545 MEDIA_LOGI("PlayerServer::PauseIoError end");
1546 });
1547 taskMgr_.LaunchTask(pauseTask, PlayerServerTaskType::STATE_CHANGE, "pause");
1548 MEDIA_LOGI("0x%{public}06" PRIXPTR " PlayerServer OnErrorMessage IO Error out", FAKE_POINTER(this));
1549 return;
1550 } else if (errorCode == MSERR_DEMUXER_BUFFER_NO_MEMORY) {
1551 auto pauseTask = std::make_shared<TaskHandler<void>>([this, errorCode, errorMsg]() {
1552 MEDIA_LOGI("MSERR_DEMUXER_BUFFER_NO_MEMORY PauseDemuxer start");
1553 auto currState = std::static_pointer_cast<BaseState>(GetCurrState());
1554 (void)currState->PauseDemuxer();
1555 OnErrorCb(errorCode, errorMsg);
1556 MEDIA_LOGI("MSERR_DEMUXER_BUFFER_NO_MEMORY PauseDemuxer end");
1557 });
1558 taskMgr_.LaunchTask(pauseTask, PlayerServerTaskType::LIGHT_TASK, "PauseDemuxer");
1559 return;
1560 }
1561 OnErrorCb(errorCode, errorMsg);
1562 }
1563
OnErrorCb(int32_t errorCode,const std::string & errorMsg)1564 void PlayerServer::OnErrorCb(int32_t errorCode, const std::string &errorMsg)
1565 {
1566 std::lock_guard<std::mutex> lockCb(mutexCb_);
1567 lastErrMsg_ = errorMsg;
1568 FaultEventWrite(lastErrMsg_, "Player");
1569 if (playerCb_ != nullptr && !errorCbOnce_) {
1570 playerCb_->OnError(errorCode, errorMsg);
1571 errorCbOnce_ = true;
1572 }
1573 }
1574
OnInfo(PlayerOnInfoType type,int32_t extra,const Format & infoBody)1575 void PlayerServer::OnInfo(PlayerOnInfoType type, int32_t extra, const Format &infoBody)
1576 {
1577 std::lock_guard<std::mutex> lockCb(mutexCb_);
1578 int32_t ret = HandleMessage(type, extra, infoBody);
1579 InnerOnInfo(type, extra, infoBody, ret);
1580 }
1581
InnerOnInfo(PlayerOnInfoType type,int32_t extra,const Format & infoBody,const int32_t ret)1582 void PlayerServer::InnerOnInfo(PlayerOnInfoType type, int32_t extra, const Format &infoBody, const int32_t ret)
1583 {
1584 if (type == INFO_TYPE_IS_LIVE_STREAM) {
1585 isLiveStream_ = true;
1586 } else if (type == INFO_TYPE_TRACK_NUM_UPDATE) {
1587 subtitleTrackNum_ = static_cast<uint32_t>(extra);
1588 return;
1589 }
1590 CHECK_AND_RETURN_LOG(CheckState(type, extra), "OnInfo check state failed");
1591 if (type == INFO_TYPE_DEFAULTTRACK || type == INFO_TYPE_TRACK_DONE || type == INFO_TYPE_ADD_SUBTITLE_DONE) {
1592 return;
1593 }
1594 if (playerCb_ != nullptr && type == INFO_TYPE_ERROR_MSG) {
1595 int32_t errorCode = extra;
1596 Format newInfo = infoBody;
1597 auto errorMsg = MSErrorToString(static_cast<MediaServiceErrCode>(errorCode));
1598 newInfo.PutIntValue(std::string(PlayerKeys::PLAYER_ERROR_TYPE), errorCode);
1599 newInfo.PutStringValue(std::string(PlayerKeys::PLAYER_ERROR_MSG), errorMsg);
1600 playerCb_->OnInfo(type, extra, newInfo);
1601 return;
1602 }
1603 if (type == INFO_TYPE_BUFFERING_UPDATE) {
1604 OnBufferingUpdate(type, extra, infoBody);
1605 }
1606 if (playerCb_ != nullptr && ret == MSERR_OK) {
1607 bool isBackgroudPause = (extra == backgroundState_ || extra == interruptEventState_ ||
1608 extra == audioDeviceChangeState_);
1609 if (isBackgroundChanged_ && type == INFO_TYPE_STATE_CHANGE && isBackgroudPause) {
1610 MEDIA_LOGI("Background change state to %{public}d, Status reporting %{public}d", extra, isBackgroundCb_);
1611 if (isBackgroundCb_) {
1612 Format newInfo = infoBody;
1613 newInfo.PutIntValue(PlayerKeys::PLAYER_STATE_CHANGED_REASON, StateChangeReason::BACKGROUND);
1614 playerCb_->OnInfo(type, extra, newInfo);
1615 isBackgroundCb_ = false;
1616 }
1617 isBackgroundChanged_ = false;
1618 interruptEventState_ = PLAYER_IDLE;
1619 audioDeviceChangeState_ = PLAYER_IDLE;
1620 } else {
1621 playerCb_->OnInfo(type, extra, infoBody);
1622 }
1623 } else {
1624 MEDIA_LOGD("0x%{public}06" PRIXPTR " playerCb_ != nullptr %{public}d, ret %{public}d",
1625 FAKE_POINTER(this), playerCb_ != nullptr, ret);
1626 }
1627 }
1628
OnSystemOperation(PlayerOnSystemOperationType type,PlayerOperationReason reason)1629 void PlayerServer::OnSystemOperation(PlayerOnSystemOperationType type, PlayerOperationReason reason)
1630 {
1631 std::lock_guard<std::mutex> lock(mutex_);
1632 MEDIA_LOGI("PlayerServer OnSystemOperation start, type: %{public}d, reason: %{public}d", static_cast<int32_t>(type),
1633 static_cast<int32_t>(reason));
1634 switch (type) {
1635 case OPERATION_TYPE_PAUSE:
1636 if (lastOpStatus_ == PLAYER_STARTED) {
1637 (void)OnPause(true);
1638 }
1639 break;
1640 default:
1641 MEDIA_LOGI("Can not OnSystemOperation, currentState is %{public}s",
1642 GetStatusDescription(lastOpStatus_).c_str());
1643 break;
1644 }
1645 }
1646
OnBufferingUpdate(PlayerOnInfoType type,int32_t extra,const Format & infoBody)1647 void PlayerServer::OnBufferingUpdate(PlayerOnInfoType type, int32_t extra, const Format &infoBody)
1648 {
1649 Format newInfo = infoBody;
1650 int info = -1;
1651 infoBody.GetIntValue(std::string(PlayerKeys::PLAYER_BUFFERING_START), info);
1652 if (info == 1) {
1653 OnNotifyBufferingStart();
1654 return;
1655 }
1656 infoBody.GetIntValue(std::string(PlayerKeys::PLAYER_BUFFERING_END), info);
1657 if (info == 1) {
1658 OnNotifyBufferingEnd();
1659 return;
1660 }
1661 }
1662
OnNotifyBufferingStart()1663 void PlayerServer::OnNotifyBufferingStart()
1664 {
1665 MEDIA_LOGD("0x%{public}06" PRIXPTR " PlayerServer OnNotifyBufferingStart in", FAKE_POINTER(this));
1666 auto pauseTask = std::make_shared<TaskHandler<void>>([this]() {
1667 MediaTrace::TraceBegin("PlayerServer::PauseDemuxer", FAKE_POINTER(this));
1668 MEDIA_LOGI("PauseDemuxer start");
1669 auto currState = std::static_pointer_cast<BaseState>(GetCurrState());
1670 (void)currState->PauseDemuxer();
1671 MEDIA_LOGI("PauseDemuxer end");
1672 });
1673 taskMgr_.LaunchTask(pauseTask, PlayerServerTaskType::LIGHT_TASK, "PauseDemuxer");
1674 MEDIA_LOGI("0x%{public}06" PRIXPTR " PlayerServer OnNotifyBufferingStart out", FAKE_POINTER(this));
1675 return;
1676 }
1677
OnNotifyBufferingEnd()1678 void PlayerServer::OnNotifyBufferingEnd()
1679 {
1680 MEDIA_LOGD("0x%{public}06" PRIXPTR " PlayerServer OnNotifyBufferingEnd in", FAKE_POINTER(this));
1681 auto playingTask = std::make_shared<TaskHandler<void>>([this]() {
1682 MediaTrace::TraceBegin("PlayerServer::ResumeDemuxer", FAKE_POINTER(this));
1683 MEDIA_LOGI("ResumeDemuxer start");
1684 auto currState = std::static_pointer_cast<BaseState>(GetCurrState());
1685 (void)currState->ResumeDemuxer();
1686 MEDIA_LOGI("ResumeDemuxer end");
1687 });
1688 taskMgr_.LaunchTask(playingTask, PlayerServerTaskType::LIGHT_TASK, "ResumeDemuxer");
1689 MEDIA_LOGI("0x%{public}06" PRIXPTR " PlayerServer OnNotifyBufferingEnd out", FAKE_POINTER(this));
1690 return;
1691 }
1692
1693
OnInfoNoChangeStatus(PlayerOnInfoType type,int32_t extra,const Format & infoBody)1694 void PlayerServer::OnInfoNoChangeStatus(PlayerOnInfoType type, int32_t extra, const Format &infoBody)
1695 {
1696 std::lock_guard<std::mutex> lockCb(mutexCb_);
1697
1698 if (playerCb_ != nullptr) {
1699 playerCb_->OnInfo(type, extra, infoBody);
1700 }
1701 }
1702
GetStatusDescription(int32_t status)1703 const std::string &PlayerServer::GetStatusDescription(int32_t status)
1704 {
1705 static const std::string ILLEGAL_STATE = "PLAYER_STATUS_ILLEGAL";
1706 if (status < PLAYER_STATE_ERROR || status > PLAYER_PLAYBACK_COMPLETE) {
1707 return ILLEGAL_STATE;
1708 }
1709
1710 return STATUS_TO_STATUS_DESCRIPTION_TABLE.find(status)->second;
1711 }
1712
GetStateName() const1713 std::string PlayerServerState::GetStateName() const
1714 {
1715 return name_;
1716 }
1717
HandleMessage(PlayerOnInfoType type,int32_t extra,const Format & infoBody)1718 int32_t PlayerServerStateMachine::HandleMessage(PlayerOnInfoType type, int32_t extra, const Format &infoBody)
1719 {
1720 if (currState_ != nullptr) {
1721 return currState_->OnMessageReceived(type, extra, infoBody);
1722 }
1723 return MSERR_OK;
1724 }
1725
Init(const std::shared_ptr<PlayerServerState> & state)1726 void PlayerServerStateMachine::Init(const std::shared_ptr<PlayerServerState> &state)
1727 {
1728 currState_ = state;
1729 }
1730
ChangeState(const std::shared_ptr<PlayerServerState> & state)1731 void PlayerServerStateMachine::ChangeState(const std::shared_ptr<PlayerServerState> &state)
1732 {
1733 {
1734 // Resolve the deadlock between reset and state callback
1735 std::unique_lock<std::recursive_mutex> lock(recMutex_);
1736
1737 if (state == nullptr || (state == currState_)) {
1738 return;
1739 }
1740
1741 if (currState_) {
1742 MEDIA_LOGD("exit state %{public}s", currState_->name_.c_str());
1743 currState_->StateExit();
1744 }
1745 MEDIA_LOGI("instance: 0x%{public}06" PRIXPTR " change state to %{public}s",
1746 FAKE_POINTER(this), state->name_.c_str());
1747 currState_ = state;
1748 }
1749 state->StateEnter();
1750 }
1751
GetCurrState()1752 std::shared_ptr<PlayerServerState> PlayerServerStateMachine::GetCurrState()
1753 {
1754 std::unique_lock<std::recursive_mutex> lock(recMutex_);
1755 return currState_;
1756 }
1757
OnCommonEventReceived(const std::string & event)1758 void PlayerServer::OnCommonEventReceived(const std::string &event)
1759 {
1760 MEDIA_LOGI("instance: 0x%{public}06" PRIXPTR " receive event %{public}s",
1761 FAKE_POINTER(this), event.c_str());
1762 if (event == EventFwk::CommonEventSupport::COMMON_EVENT_USER_BACKGROUND) {
1763 std::weak_ptr<PlayerServer> server = std::static_pointer_cast<PlayerServer>(shared_from_this());
1764 auto pauseTask = std::make_shared<TaskHandler<void>>([server]() {
1765 std::shared_ptr<PlayerServer> spServer = server.lock();
1766 if (spServer != nullptr) {
1767 spServer->taskMgr_.MarkTaskDone("receiveccommonevent done");
1768 (void)spServer->OnSystemOperation(OPERATION_TYPE_PAUSE, OPERATION_REASON_USER_BACKGROUND);
1769 }
1770 });
1771 taskMgr_.LaunchTask(pauseTask, PlayerServerTaskType::STATE_CHANGE, "receiveccommonevent");
1772 }
1773 }
1774
GetUserId()1775 int32_t PlayerServer::GetUserId()
1776 {
1777 return userId_.load();
1778 }
1779
GetCommonEventReceiver()1780 std::shared_ptr<CommonEventReceiver> PlayerServer::GetCommonEventReceiver()
1781 {
1782 return commonEventReceiver_;
1783 }
1784
IsBootCompleted()1785 bool PlayerServer::IsBootCompleted()
1786 {
1787 return isBootCompleted_.load();
1788 }
1789
SetMediaMuted(OHOS::Media::MediaType mediaType,bool isMuted)1790 int32_t PlayerServer::SetMediaMuted(OHOS::Media::MediaType mediaType, bool isMuted)
1791 {
1792 MediaTrace::TraceBegin("PlayerServer::SetMediaMuted", FAKE_POINTER(this));
1793 std::lock_guard<std::mutex> lock(mutex_);
1794 CHECK_AND_RETURN_RET(lastOpStatus_ == PLAYER_INITIALIZED || lastOpStatus_ == PLAYER_PREPARED ||
1795 lastOpStatus_ == PLAYER_STARTED || lastOpStatus_ == PLAYER_PLAYBACK_COMPLETE ||
1796 lastOpStatus_ == PLAYER_PAUSED || lastOpStatus_ == PLAYER_STOPPED,
1797 MSERR_INVALID_STATE);
1798 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
1799 return playerEngine_->SetMediaMuted(mediaType, isMuted);
1800 }
1801
SetPlaybackStrategy(AVPlayStrategy playbackStrategy)1802 int32_t PlayerServer::SetPlaybackStrategy(AVPlayStrategy playbackStrategy)
1803 {
1804 MediaTrace::TraceBegin("PlayerServer::SetPlaybackStrategy", FAKE_POINTER(this));
1805 std::lock_guard<std::mutex> lock(mutex_);
1806 bool isValidState = lastOpStatus_ == PLAYER_INITIALIZED || lastOpStatus_ == PLAYER_STOPPED;
1807 CHECK_AND_RETURN_RET_LOG(isValidState, MSERR_INVALID_STATE,
1808 "can not set playback strategy, current state is %{public}d", static_cast<int32_t>(lastOpStatus_.load()));
1809 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
1810 return playerEngine_->SetPlaybackStrategy(playbackStrategy);
1811 }
1812
CheckSeek(int32_t mSeconds,PlayerSeekMode mode)1813 int32_t PlayerServer::CheckSeek(int32_t mSeconds, PlayerSeekMode mode)
1814 {
1815 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
1816
1817 MEDIA_LOGI("KPI-TRACE: PlayerServer Seek in");
1818 if (lastOpStatus_ != PLAYER_PREPARED && lastOpStatus_ != PLAYER_PAUSED &&
1819 lastOpStatus_ != PLAYER_STARTED && lastOpStatus_ != PLAYER_PLAYBACK_COMPLETE) {
1820 MEDIA_LOGE("Can not Seek, currentState is %{public}s", GetStatusDescription(lastOpStatus_).c_str());
1821 return MSERR_INVALID_OPERATION;
1822 }
1823
1824 if (IsValidSeekMode(mode) != true) {
1825 MEDIA_LOGE("Seek failed, inValid mode");
1826 return MSERR_INVALID_VAL;
1827 }
1828
1829 if (isLiveStream_) {
1830 MEDIA_LOGE("Can not Seek, it is live-stream");
1831 OnErrorMessage(MSERR_EXT_API9_UNSUPPORT_CAPABILITY, "Can not Seek, it is live-stream");
1832 return MSERR_INVALID_OPERATION;
1833 }
1834 return MSERR_OK;
1835 }
1836
SeekContinous(int32_t mSeconds)1837 int32_t PlayerServer::SeekContinous(int32_t mSeconds)
1838 {
1839 if (lastOpStatus_ == PLAYER_STARTED) {
1840 OnPause(true);
1841 }
1842 {
1843 std::lock_guard<std::mutex> lock(seekContinousMutex_);
1844 if (!isInSeekContinous_.load()) {
1845 UpdateContinousBatchNo();
1846 isInSeekContinous_.store(true);
1847 }
1848 }
1849 int64_t seekContinousBatchNo = seekContinousBatchNo_.load();
1850
1851 auto seekContinousTask = std::make_shared<TaskHandler<void>>([this, mSeconds, seekContinousBatchNo]() {
1852 MediaTrace::TraceBegin("PlayerServer::SeekContinous", FAKE_POINTER(this));
1853 MEDIA_LOGI("PlayerServer::Seek start");
1854 auto currState = std::static_pointer_cast<BaseState>(GetCurrState());
1855 (void)currState->SeekContinous(mSeconds, seekContinousBatchNo);
1856 MEDIA_LOGI("PlayerServer::SeekContinous end");
1857 taskMgr_.MarkTaskDone("seek continous done");
1858 });
1859
1860 int32_t ret = taskMgr_.SeekContinousTask(seekContinousTask, "seek continous");
1861 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "SeekContinous failed");
1862
1863 MEDIA_LOGI("Queue seekTask end, position %{public}d", mSeconds);
1864 return MSERR_OK;
1865 }
1866
HandleSeekContinous(int32_t mSeconds,int64_t batchNo)1867 int32_t PlayerServer::HandleSeekContinous(int32_t mSeconds, int64_t batchNo)
1868 {
1869 MEDIA_LOGI("KPI-TRACE: PlayerServer HandleSeek in, mSeconds: %{public}d, "
1870 "instanceId: %{public}" PRIu64 "", mSeconds, instanceId_);
1871 int32_t ret = playerEngine_->SeekContinous(mSeconds, batchNo);
1872 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine Seek Failed!");
1873 MEDIA_LOGI("PlayerServer HandleSeek end");
1874 return MSERR_OK;
1875 }
1876
ExitSeekContinous(bool align)1877 int32_t PlayerServer::ExitSeekContinous(bool align)
1878 {
1879 {
1880 std::lock_guard<std::mutex> lock(seekContinousMutex_);
1881 if (!isInSeekContinous_.load()) {
1882 return MSERR_OK;
1883 }
1884 UpdateContinousBatchNo();
1885 isInSeekContinous_.store(false);
1886 }
1887 CHECK_AND_RETURN_RET_LOG(playerEngine_ != nullptr, MSERR_NO_MEMORY, "playerEngine_ is nullptr");
1888 return playerEngine_->ExitSeekContinous(align, seekContinousBatchNo_.load());
1889 }
1890
SetDeviceChangeCbStatus(bool status)1891 int32_t PlayerServer::SetDeviceChangeCbStatus(bool status)
1892 {
1893 deviceChangeCallbackflag_ = status;
1894 MEDIA_LOGI("Set DeviceChangeFlag success, status = %{public}d", deviceChangeCallbackflag_);
1895 return MSERR_OK;
1896 }
1897
UpdateContinousBatchNo()1898 void PlayerServer::UpdateContinousBatchNo()
1899 {
1900 seekContinousBatchNo_++;
1901 }
1902
CheckState(PlayerOnInfoType type,int32_t extra)1903 bool PlayerServer::CheckState(PlayerOnInfoType type, int32_t extra)
1904 {
1905 auto currState = std::static_pointer_cast<BaseState>(GetCurrState());
1906 bool isCompletedInfo = type == INFO_TYPE_STATE_CHANGE && extra == PlayerStates::PLAYER_PLAYBACK_COMPLETE;
1907 bool isEosInfo = type == INFO_TYPE_EOS;
1908 CHECK_AND_RETURN_RET_LOG(currState != stoppedState_ || !(isCompletedInfo || isEosInfo), false,
1909 "do not report completed or eos in stopped state");
1910
1911 bool isErrorInfo = type == INFO_TYPE_STATE_CHANGE && extra == PlayerStates::PLAYER_STATE_ERROR;
1912 CHECK_AND_RETURN_RET_LOG(currState != idleState_ || !isErrorInfo, false, "do not report error in idle state");
1913
1914 bool isPreparedInfo = type == INFO_TYPE_STATE_CHANGE && extra == PlayerStates::PLAYER_PREPARED;
1915 CHECK_AND_RETURN_RET_LOG(currState != idleState_ || !isPreparedInfo, false,
1916 "do not report prepared in idle state");
1917 return true;
1918 }
1919
SetMaxAmplitudeCbStatus(bool status)1920 int32_t PlayerServer::SetMaxAmplitudeCbStatus(bool status)
1921 {
1922 maxAmplitudeCbStatus_ = status;
1923 return MSERR_OK;
1924 }
1925 } // namespace Media
1926 } // namespace OHOS
1927