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