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