1 /*
2 * Copyright (c) 2024 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 "OHAVSession.h"
17 #include "avmeta_data.h"
18 #include "avsession_manager.h"
19
20 namespace OHOS::AVSession {
~OHAVSession()21 OHAVSession::~OHAVSession()
22 {
23 }
24
OHAVSession()25 OHAVSession::OHAVSession()
26 {
27 }
28
OHAVSession(AVSession_Type sessionType,const char * sessionTag,const char * bundleName,const char * abilityName)29 OHAVSession::OHAVSession(AVSession_Type sessionType, const char* sessionTag,
30 const char* bundleName, const char* abilityName)
31 {
32 AppExecFwk::ElementName elementName;
33 elementName.SetBundleName(bundleName);
34 elementName.SetAbilityName(abilityName);
35 avSession_ = AVSessionManager::GetInstance().CreateSession(sessionTag, sessionType, elementName);
36 }
37
IsAVSessionNull()38 bool OHAVSession::IsAVSessionNull()
39 {
40 return avSession_ == nullptr;
41 }
42
GetEncodeErrcode(int32_t ret)43 AVSession_ErrCode OHAVSession::GetEncodeErrcode(int32_t ret)
44 {
45 auto it = errcodes.find(ret);
46 if (it != errcodes.end()) {
47 return it->second;
48 }
49 return AV_SESSION_ERR_SERVICE_EXCEPTION;
50 }
51
Activate()52 AVSession_ErrCode OHAVSession::Activate()
53 {
54 int32_t ret = avSession_->Activate();
55 return GetEncodeErrcode(ret);
56 }
57
58
Deactivate()59 AVSession_ErrCode OHAVSession::Deactivate()
60 {
61 int32_t ret = avSession_->Deactivate();
62 return GetEncodeErrcode(ret);
63 }
64
GetSessionType()65 std::string OHAVSession::GetSessionType()
66 {
67 std::string sessionType = avSession_->GetSessionType();
68 return sessionType;
69 }
70
GetSessionId()71 const std::string& OHAVSession::GetSessionId()
72 {
73 if (sessionId_.empty()) {
74 sessionId_ = avSession_->GetSessionId();
75 }
76 return sessionId_;
77 }
78
SetAVMetaData(OH_AVMetadata * metadata)79 AVSession_ErrCode OHAVSession::SetAVMetaData(OH_AVMetadata* metadata)
80 {
81 AVMetaData* avMetaData = reinterpret_cast<AVMetaData*>(metadata);
82 int32_t ret = avSession_->SetAVMetaData(*avMetaData);
83 return GetEncodeErrcode(ret);
84 }
85
SetPlaybackState(AVSession_PlaybackState playbackState)86 AVSession_ErrCode OHAVSession::SetPlaybackState(AVSession_PlaybackState playbackState)
87 {
88 AVPlaybackState avPlaybackState;
89 avPlaybackState.SetState(playbackState);
90 int32_t ret = avSession_->SetAVPlaybackState(avPlaybackState);
91 return GetEncodeErrcode(ret);
92 }
93
SetPlaybackPosition(AVSession_PlaybackPosition * playbackPosition)94 AVSession_ErrCode OHAVSession::SetPlaybackPosition(AVSession_PlaybackPosition* playbackPosition)
95 {
96 AVPlaybackState avPlaybackState;
97 AVPlaybackState::Position pos = {playbackPosition->elapsedTime, playbackPosition->updateTime};
98 avPlaybackState.SetPosition(pos);
99 int32_t ret = avSession_->SetAVPlaybackState(avPlaybackState);
100 return GetEncodeErrcode(ret);
101 }
102
SetFavorite(bool favorite)103 AVSession_ErrCode OHAVSession::SetFavorite(bool favorite)
104 {
105 AVPlaybackState avPlaybackState;
106 avPlaybackState.SetFavorite(favorite);
107 int32_t ret = avSession_->SetAVPlaybackState(avPlaybackState);
108 return GetEncodeErrcode(ret);
109 }
110
SetLoopMode(AVSession_LoopMode loopMode)111 AVSession_ErrCode OHAVSession::SetLoopMode(AVSession_LoopMode loopMode)
112 {
113 AVPlaybackState avPlaybackState;
114 avPlaybackState.SetLoopMode(loopMode);
115 int32_t ret = avSession_->SetAVPlaybackState(avPlaybackState);
116 return GetEncodeErrcode(ret);
117 }
118
RegisterCommandCallback(AVSession_ControlCommand command,OH_AVSessionCallback_OnCommand callback,void * userData)119 AVSession_ErrCode OHAVSession::RegisterCommandCallback(AVSession_ControlCommand command,
120 OH_AVSessionCallback_OnCommand callback, void* userData)
121 {
122 int32_t ret = 0;
123 std::lock_guard<std::mutex> lockGuard(lock_);
124 if (ohAVSessionCallbackImpl_ == nullptr) {
125 ohAVSessionCallbackImpl_ = std::make_shared<OHAVSessionCallbackImpl>();
126 ret = avSession_->RegisterCallback(ohAVSessionCallbackImpl_);
127 }
128 ret = avSession_->AddSupportCommand(static_cast<int32_t>(command));
129 if (static_cast<AVSession_ErrCode>(ret) != AV_SESSION_ERR_SUCCESS) {
130 return GetEncodeErrcode(ret);
131 }
132 switch (command) {
133 case CONTROL_CMD_PLAY:
134 ohAVSessionCallbackImpl_->SetPlayCallback((OH_AVSession*)this, command, callback, userData);
135 break;
136 case CONTROL_CMD_PAUSE:
137 ohAVSessionCallbackImpl_->SetPauseCallback((OH_AVSession*)this, command, callback, userData);
138 break;
139 case CONTROL_CMD_STOP:
140 ohAVSessionCallbackImpl_->SetStopCallback((OH_AVSession*)this, command, callback, userData);
141 break;
142 case CONTROL_CMD_PLAY_NEXT:
143 ohAVSessionCallbackImpl_->SetPlayNextCallback((OH_AVSession*)this, command, callback, userData);
144 break;
145 case CONTROL_CMD_PLAY_PREVIOUS:
146 ohAVSessionCallbackImpl_->SetPlayPreviousCallback((OH_AVSession*)this, command, callback, userData);
147 break;
148 default:
149 break;
150 }
151 return GetEncodeErrcode(ret);
152 }
153
UnregisterCommandCallback(AVSession_ControlCommand command,OH_AVSessionCallback_OnCommand callback)154 AVSession_ErrCode OHAVSession::UnregisterCommandCallback(AVSession_ControlCommand command,
155 OH_AVSessionCallback_OnCommand callback)
156 {
157 if (ohAVSessionCallbackImpl_ == nullptr) {
158 return AV_SESSION_ERR_SUCCESS;
159 }
160 std::lock_guard<std::mutex> lockGuard(lock_);
161 int32_t ret = avSession_->DeleteSupportCommand(static_cast<int32_t>(command));
162 if (static_cast<AVSession_ErrCode>(ret) != AV_SESSION_ERR_SUCCESS) {
163 return GetEncodeErrcode(ret);
164 }
165 switch (command) {
166 case CONTROL_CMD_PLAY:
167 ohAVSessionCallbackImpl_->UnSetPlayCallback((OH_AVSession*)this, command, callback);
168 break;
169 case CONTROL_CMD_PAUSE:
170 ohAVSessionCallbackImpl_->UnSetPauseCallback((OH_AVSession*)this, command, callback);
171 break;
172 case CONTROL_CMD_STOP:
173 ohAVSessionCallbackImpl_->UnSetStopCallback((OH_AVSession*)this, command, callback);
174 break;
175 case CONTROL_CMD_PLAY_NEXT:
176 ohAVSessionCallbackImpl_->UnSetPlayNextCallback((OH_AVSession*)this, command, callback);
177 break;
178 case CONTROL_CMD_PLAY_PREVIOUS:
179 ohAVSessionCallbackImpl_->UnSetPlayPreviousCallback((OH_AVSession*)this, command, callback);
180 break;
181 default:
182 break;
183 }
184 return AV_SESSION_ERR_SUCCESS;
185 }
186
CheckAndRegister()187 AVSession_ErrCode OHAVSession::CheckAndRegister()
188 {
189 if (ohAVSessionCallbackImpl_ == nullptr) {
190 ohAVSessionCallbackImpl_ = std::make_shared<OHAVSessionCallbackImpl>();
191 AVSession_ErrCode ret = static_cast<AVSession_ErrCode>(
192 avSession_->RegisterCallback(ohAVSessionCallbackImpl_));
193 CHECK_AND_RETURN_RET_LOG(ret == AV_SESSION_ERR_SUCCESS, AV_SESSION_ERR_SERVICE_EXCEPTION,
194 "RegisterCallback failed");
195 }
196 return AV_SESSION_ERR_SUCCESS;
197 }
198
RegisterForwardCallback(OH_AVSessionCallback_OnFastForward callback,void * userData)199 AVSession_ErrCode OHAVSession::RegisterForwardCallback(OH_AVSessionCallback_OnFastForward callback, void* userData)
200 {
201 std::lock_guard<std::mutex> lockGuard(lock_);
202 CheckAndRegister();
203 int32_t ret = avSession_->AddSupportCommand(static_cast<int32_t>(AVControlCommand::SESSION_CMD_FAST_FORWARD));
204 if (static_cast<AVSession_ErrCode>(ret) != AV_SESSION_ERR_SUCCESS) {
205 return GetEncodeErrcode(ret);
206 }
207 ohAVSessionCallbackImpl_->RegisterForwardCallback((OH_AVSession*)this, callback, userData);
208 return AV_SESSION_ERR_SUCCESS;
209 }
210
UnregisterForwardCallback(OH_AVSessionCallback_OnFastForward callback)211 AVSession_ErrCode OHAVSession::UnregisterForwardCallback(OH_AVSessionCallback_OnFastForward callback)
212 {
213 if (ohAVSessionCallbackImpl_ == nullptr) {
214 return AV_SESSION_ERR_SUCCESS;
215 }
216 std::lock_guard<std::mutex> lockGuard(lock_);
217 int32_t ret = avSession_->DeleteSupportCommand(static_cast<int32_t>(AVControlCommand::SESSION_CMD_FAST_FORWARD));
218 if (static_cast<AVSession_ErrCode>(ret) != AV_SESSION_ERR_SUCCESS) {
219 return GetEncodeErrcode(ret);
220 }
221 ohAVSessionCallbackImpl_->UnregisterForwardCallback((OH_AVSession*)this, callback);
222 return AV_SESSION_ERR_SUCCESS;
223 }
224
RegisterRewindCallback(OH_AVSessionCallback_OnRewind callback,void * userData)225 AVSession_ErrCode OHAVSession::RegisterRewindCallback(OH_AVSessionCallback_OnRewind callback, void* userData)
226 {
227 std::lock_guard<std::mutex> lockGuard(lock_);
228 CheckAndRegister();
229 int32_t ret = avSession_->AddSupportCommand(static_cast<int32_t>(AVControlCommand::SESSION_CMD_REWIND));
230 if (static_cast<AVSession_ErrCode>(ret) != AV_SESSION_ERR_SUCCESS) {
231 return GetEncodeErrcode(ret);
232 }
233 ohAVSessionCallbackImpl_->RegisterRewindCallback((OH_AVSession*)this, callback, userData);
234 return AV_SESSION_ERR_SUCCESS;
235 }
236
UnregisterRewindCallback(OH_AVSessionCallback_OnRewind callback)237 AVSession_ErrCode OHAVSession::UnregisterRewindCallback(OH_AVSessionCallback_OnRewind callback)
238 {
239 if (ohAVSessionCallbackImpl_ == nullptr) {
240 return AV_SESSION_ERR_SUCCESS;
241 }
242 std::lock_guard<std::mutex> lockGuard(lock_);
243 int32_t ret = avSession_->DeleteSupportCommand(static_cast<int32_t>(AVControlCommand::SESSION_CMD_REWIND));
244 if (static_cast<AVSession_ErrCode>(ret) != AV_SESSION_ERR_SUCCESS) {
245 return GetEncodeErrcode(ret);
246 }
247 ohAVSessionCallbackImpl_->UnregisterRewindCallback((OH_AVSession*)this, callback);
248 return AV_SESSION_ERR_SUCCESS;
249 }
250
RegisterSeekCallback(OH_AVSessionCallback_OnSeek callback,void * userData)251 AVSession_ErrCode OHAVSession::RegisterSeekCallback(OH_AVSessionCallback_OnSeek callback, void* userData)
252 {
253 std::lock_guard<std::mutex> lockGuard(lock_);
254 CheckAndRegister();
255 int32_t ret = avSession_->AddSupportCommand(static_cast<int32_t>(AVControlCommand::SESSION_CMD_SEEK));
256 if (static_cast<AVSession_ErrCode>(ret) != AV_SESSION_ERR_SUCCESS) {
257 return GetEncodeErrcode(ret);
258 }
259 ohAVSessionCallbackImpl_->RegisterSeekCallback((OH_AVSession*)this, callback, userData);
260 return AV_SESSION_ERR_SUCCESS;
261 }
262
UnregisterSeekCallback(OH_AVSessionCallback_OnSeek callback)263 AVSession_ErrCode OHAVSession::UnregisterSeekCallback(OH_AVSessionCallback_OnSeek callback)
264 {
265 if (ohAVSessionCallbackImpl_ == nullptr) {
266 return AV_SESSION_ERR_SUCCESS;
267 }
268 std::lock_guard<std::mutex> lockGuard(lock_);
269 int32_t ret = avSession_->DeleteSupportCommand(static_cast<int32_t>(AVControlCommand::SESSION_CMD_SEEK));
270 if (static_cast<AVSession_ErrCode>(ret) != AV_SESSION_ERR_SUCCESS) {
271 return GetEncodeErrcode(ret);
272 }
273 ohAVSessionCallbackImpl_->UnregisterSeekCallback((OH_AVSession*)this, callback);
274 return AV_SESSION_ERR_SUCCESS;
275 }
276
RegisterSetLoopModeCallback(OH_AVSessionCallback_OnSetLoopMode callback,void * userData)277 AVSession_ErrCode OHAVSession::RegisterSetLoopModeCallback(OH_AVSessionCallback_OnSetLoopMode callback, void* userData)
278 {
279 std::lock_guard<std::mutex> lockGuard(lock_);
280 CheckAndRegister();
281 int32_t ret = avSession_->AddSupportCommand(static_cast<int32_t>(AVControlCommand::SESSION_CMD_SET_LOOP_MODE));
282 if (static_cast<AVSession_ErrCode>(ret) != AV_SESSION_ERR_SUCCESS) {
283 return GetEncodeErrcode(ret);
284 }
285 ohAVSessionCallbackImpl_->RegisterSetLoopModeCallback((OH_AVSession*)this, callback, userData);
286 return AV_SESSION_ERR_SUCCESS;
287 }
288
UnregisterSetLoopModeCallback(OH_AVSessionCallback_OnSetLoopMode callback)289 AVSession_ErrCode OHAVSession::UnregisterSetLoopModeCallback(OH_AVSessionCallback_OnSetLoopMode callback)
290 {
291 if (ohAVSessionCallbackImpl_ == nullptr) {
292 return AV_SESSION_ERR_SUCCESS;
293 }
294 std::lock_guard<std::mutex> lockGuard(lock_);
295 int32_t ret = avSession_->DeleteSupportCommand(static_cast<int32_t>(AVControlCommand::SESSION_CMD_SET_LOOP_MODE));
296 if (static_cast<AVSession_ErrCode>(ret) != AV_SESSION_ERR_SUCCESS) {
297 return GetEncodeErrcode(ret);
298 }
299 ohAVSessionCallbackImpl_->UnregisterSetLoopModeCallback((OH_AVSession*)this, callback);
300 return AV_SESSION_ERR_SUCCESS;
301 }
302
RegisterToggleFavoriteCallback(OH_AVSessionCallback_OnToggleFavorite callback,void * userData)303 AVSession_ErrCode OHAVSession::RegisterToggleFavoriteCallback(OH_AVSessionCallback_OnToggleFavorite callback,
304 void* userData)
305 {
306 std::lock_guard<std::mutex> lockGuard(lock_);
307 CheckAndRegister();
308 int32_t ret = avSession_->AddSupportCommand(static_cast<int32_t>(AVControlCommand::SESSION_CMD_TOGGLE_FAVORITE));
309 if (static_cast<AVSession_ErrCode>(ret) != AV_SESSION_ERR_SUCCESS) {
310 return GetEncodeErrcode(ret);
311 }
312 ohAVSessionCallbackImpl_->RegisterToggleFavoriteCallback((OH_AVSession*)this, callback, userData);
313 return AV_SESSION_ERR_SUCCESS;
314 }
315
UnregisterToggleFavoriteCallback(OH_AVSessionCallback_OnToggleFavorite callback)316 AVSession_ErrCode OHAVSession::UnregisterToggleFavoriteCallback(OH_AVSessionCallback_OnToggleFavorite callback)
317 {
318 if (ohAVSessionCallbackImpl_ == nullptr) {
319 return AV_SESSION_ERR_SUCCESS;
320 }
321 std::lock_guard<std::mutex> lockGuard(lock_);
322 int32_t ret = avSession_->DeleteSupportCommand(static_cast<int32_t>(AVControlCommand::SESSION_CMD_TOGGLE_FAVORITE));
323 if (static_cast<AVSession_ErrCode>(ret) != AV_SESSION_ERR_SUCCESS) {
324 return GetEncodeErrcode(ret);
325 }
326 ohAVSessionCallbackImpl_->UnregisterToggleFavoriteCallback((OH_AVSession*)this, callback);
327 return AV_SESSION_ERR_SUCCESS;
328 }
329
Destroy()330 AVSession_ErrCode OHAVSession::Destroy()
331 {
332 avSession_->Destroy();
333 return AV_SESSION_ERR_SUCCESS;
334 }
335 }
336
OH_AVSession_Create(AVSession_Type sessionType,const char * sessionTag,const char * bundleName,const char * abilityName,OH_AVSession ** avsession)337 AVSession_ErrCode OH_AVSession_Create(AVSession_Type sessionType, const char* sessionTag,
338 const char* bundleName, const char* abilityName, OH_AVSession** avsession)
339 {
340 CHECK_AND_RETURN_RET_LOG(sessionTag != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "sessionTag is null");
341 CHECK_AND_RETURN_RET_LOG(bundleName != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "bundleName is null");
342 CHECK_AND_RETURN_RET_LOG(abilityName != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "abilityName is null");
343 CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "avsession is null");
344
345 switch (sessionType) {
346 case SESSION_TYPE_AUDIO:
347 case SESSION_TYPE_VIDEO:
348 case SESSION_TYPE_VOICE_CALL:
349 case SESSION_TYPE_VIDEO_CALL:
350 break;
351 default:
352 SLOGE("Invalid session type: %{public}d", sessionType);
353 return AV_SESSION_ERR_INVALID_PARAMETER;
354 }
355
356 OHOS::AVSession::OHAVSession *oh_avsession = new OHOS::AVSession::OHAVSession(sessionType, sessionTag,
357 bundleName, abilityName);
358 if (oh_avsession->IsAVSessionNull()) {
359 delete oh_avsession;
360 oh_avsession = nullptr;
361 return AV_SESSION_ERR_SERVICE_EXCEPTION;
362 }
363 *avsession = (OH_AVSession*)oh_avsession;
364 return AV_SESSION_ERR_SUCCESS;
365 }
366
OH_AVSession_Destroy(OH_AVSession * avsession)367 AVSession_ErrCode OH_AVSession_Destroy(OH_AVSession* avsession)
368 {
369 CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
370
371 OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
372 oh_avsession->Destroy();
373 if (oh_avsession != nullptr) {
374 delete oh_avsession;
375 oh_avsession = nullptr;
376 }
377 return AV_SESSION_ERR_SUCCESS;
378 }
379
OH_AVSession_Activate(OH_AVSession * avsession)380 AVSession_ErrCode OH_AVSession_Activate(OH_AVSession* avsession)
381 {
382 CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
383
384 OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
385 return oh_avsession->Activate();
386 }
387
OH_AVSession_Deactivate(OH_AVSession * avsession)388 AVSession_ErrCode OH_AVSession_Deactivate(OH_AVSession* avsession)
389 {
390 CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
391
392 OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
393 return oh_avsession->Deactivate();
394 }
395
OH_AVSession_GetSessionType(OH_AVSession * avsession,AVSession_Type * sessionType)396 AVSession_ErrCode OH_AVSession_GetSessionType(OH_AVSession* avsession, AVSession_Type* sessionType)
397 {
398 CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
399 CHECK_AND_RETURN_RET_LOG(sessionType != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "sessionType is null");
400
401 OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
402 std::string str = oh_avsession->GetSessionType();
403 auto it = oh_avsession->avsessionTypes.find(str);
404 if (it == oh_avsession->avsessionTypes.end()) {
405 return AV_SESSION_ERR_SERVICE_EXCEPTION;
406 }
407 *sessionType = it->second;
408 return AV_SESSION_ERR_SUCCESS;
409 }
410
OH_AVSession_GetSessionId(OH_AVSession * avsession,const char ** sessionId)411 AVSession_ErrCode OH_AVSession_GetSessionId(OH_AVSession* avsession, const char** sessionId)
412 {
413 CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
414 CHECK_AND_RETURN_RET_LOG(sessionId != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "sessionId is null");
415
416 OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
417 *sessionId = oh_avsession->GetSessionId().c_str();
418 return AV_SESSION_ERR_SUCCESS;
419 }
420
OH_AVSession_SetAVMetadata(OH_AVSession * avsession,OH_AVMetadata * metadata)421 AVSession_ErrCode OH_AVSession_SetAVMetadata(OH_AVSession* avsession, OH_AVMetadata* metadata)
422 {
423 CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
424 CHECK_AND_RETURN_RET_LOG(metadata != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVMetadata is null");
425
426 OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
427 return oh_avsession->SetAVMetaData(metadata);
428 }
429
OH_AVSession_SetPlaybackState(OH_AVSession * avsession,AVSession_PlaybackState playbackState)430 AVSession_ErrCode OH_AVSession_SetPlaybackState(OH_AVSession* avsession, AVSession_PlaybackState playbackState)
431 {
432 CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
433
434 switch (playbackState) {
435 case PLAYBACK_STATE_INITIAL:
436 case PLAYBACK_STATE_PREPARING:
437 case PLAYBACK_STATE_PLAYING:
438 case PLAYBACK_STATE_PAUSED:
439 case PLAYBACK_STATE_FAST_FORWARDING:
440 case PLAYBACK_STATE_REWINDED:
441 case PLAYBACK_STATE_STOPPED:
442 case PLAYBACK_STATE_COMPLETED:
443 case PLAYBACK_STATE_RELEASED:
444 case PLAYBACK_STATE_ERROR:
445 case PLAYBACK_STATE_IDLE:
446 case PLAYBACK_STATE_BUFFERING:
447 break;
448 default:
449 SLOGE("Invalid playback state: %{public}d", playbackState);
450 return AV_SESSION_ERR_INVALID_PARAMETER;
451 }
452
453 OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
454 return oh_avsession->SetPlaybackState(playbackState);
455 }
456
OH_AVSession_SetPlaybackPosition(OH_AVSession * avsession,AVSession_PlaybackPosition * playbackPosition)457 AVSession_ErrCode OH_AVSession_SetPlaybackPosition(OH_AVSession* avsession,
458 AVSession_PlaybackPosition* playbackPosition)
459 {
460 CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
461 CHECK_AND_RETURN_RET_LOG(playbackPosition != nullptr, AV_SESSION_ERR_INVALID_PARAMETER,
462 "playbackPosition is null");
463
464 OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
465 return oh_avsession->SetPlaybackPosition(playbackPosition);
466 }
467
OH_AVSession_SetFavorite(OH_AVSession * avsession,bool favorite)468 AVSession_ErrCode OH_AVSession_SetFavorite(OH_AVSession* avsession, bool favorite)
469 {
470 CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
471
472 OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
473 return oh_avsession->SetFavorite(favorite);
474 }
475
OH_AVSession_SetLoopMode(OH_AVSession * avsession,AVSession_LoopMode loopMode)476 AVSession_ErrCode OH_AVSession_SetLoopMode(OH_AVSession* avsession, AVSession_LoopMode loopMode)
477 {
478 CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
479
480 switch (loopMode) {
481 case LOOP_MODE_SEQUENCE:
482 case LOOP_MODE_SINGLE:
483 case LOOP_MODE_LIST:
484 case LOOP_MODE_SHUFFLE:
485 case LOOP_MODE_CUSTOM:
486 break;
487 default:
488 SLOGE("Invalid loop mode: %{public}d", loopMode);
489 return AV_SESSION_ERR_INVALID_PARAMETER;
490 }
491
492 OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
493 return oh_avsession->SetLoopMode(loopMode);
494 }
495
OH_AVSession_RegisterCommandCallback(OH_AVSession * avsession,AVSession_ControlCommand command,OH_AVSessionCallback_OnCommand callback,void * userData)496 AVSession_ErrCode OH_AVSession_RegisterCommandCallback(OH_AVSession* avsession,
497 AVSession_ControlCommand command, OH_AVSessionCallback_OnCommand callback, void* userData)
498 {
499 CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
500 CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "callback is null");
501
502 switch (command) {
503 case CONTROL_CMD_PLAY:
504 case CONTROL_CMD_PAUSE:
505 case CONTROL_CMD_STOP:
506 case CONTROL_CMD_PLAY_NEXT:
507 case CONTROL_CMD_PLAY_PREVIOUS:
508 break;
509 default:
510 SLOGE("Invalid command: %{public}d", command);
511 return AV_SESSION_ERR_CODE_COMMAND_INVALID;
512 }
513
514 OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
515 return oh_avsession->RegisterCommandCallback(command, callback, userData);
516 }
517
OH_AVSession_UnregisterCommandCallback(OH_AVSession * avsession,AVSession_ControlCommand command,OH_AVSessionCallback_OnCommand callback)518 AVSession_ErrCode OH_AVSession_UnregisterCommandCallback(OH_AVSession* avsession,
519 AVSession_ControlCommand command, OH_AVSessionCallback_OnCommand callback)
520 {
521 CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
522 CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "callback is null");
523
524 switch (command) {
525 case CONTROL_CMD_PLAY:
526 case CONTROL_CMD_PAUSE:
527 case CONTROL_CMD_STOP:
528 case CONTROL_CMD_PLAY_NEXT:
529 case CONTROL_CMD_PLAY_PREVIOUS:
530 break;
531 default:
532 SLOGE("Invalid command: %{public}d", command);
533 return AV_SESSION_ERR_CODE_COMMAND_INVALID;
534 }
535
536 OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
537 return oh_avsession->UnregisterCommandCallback(command, callback);
538 }
539
OH_AVSession_RegisterForwardCallback(OH_AVSession * avsession,OH_AVSessionCallback_OnFastForward callback,void * userData)540 AVSession_ErrCode OH_AVSession_RegisterForwardCallback(OH_AVSession* avsession,
541 OH_AVSessionCallback_OnFastForward callback, void* userData)
542 {
543 CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
544 CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "callback is null");
545
546 OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
547 return oh_avsession->RegisterForwardCallback(callback, userData);
548 }
549
OH_AVSession_UnregisterForwardCallback(OH_AVSession * avsession,OH_AVSessionCallback_OnFastForward callback)550 AVSession_ErrCode OH_AVSession_UnregisterForwardCallback(OH_AVSession* avsession,
551 OH_AVSessionCallback_OnFastForward callback)
552 {
553 CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
554 CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "callback is null");
555
556 OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
557 return oh_avsession->UnregisterForwardCallback(callback);
558 }
559
OH_AVSession_RegisterRewindCallback(OH_AVSession * avsession,OH_AVSessionCallback_OnRewind callback,void * userData)560 AVSession_ErrCode OH_AVSession_RegisterRewindCallback(OH_AVSession* avsession,
561 OH_AVSessionCallback_OnRewind callback, void* userData)
562 {
563 CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
564 CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "callback is null");
565
566 OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
567 return oh_avsession->RegisterRewindCallback(callback, userData);
568 }
569
OH_AVSession_UnregisterRewindCallback(OH_AVSession * avsession,OH_AVSessionCallback_OnRewind callback)570 AVSession_ErrCode OH_AVSession_UnregisterRewindCallback(OH_AVSession* avsession,
571 OH_AVSessionCallback_OnRewind callback)
572 {
573 CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
574 CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "callback is null");
575
576 OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
577 return oh_avsession->UnregisterRewindCallback(callback);
578 }
579
OH_AVSession_RegisterSeekCallback(OH_AVSession * avsession,OH_AVSessionCallback_OnSeek callback,void * userData)580 AVSession_ErrCode OH_AVSession_RegisterSeekCallback(OH_AVSession* avsession,
581 OH_AVSessionCallback_OnSeek callback, void* userData)
582 {
583 CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
584 CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "callback is null");
585
586 OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
587 return oh_avsession->RegisterSeekCallback(callback, userData);
588 }
589
OH_AVSession_UnregisterSeekCallback(OH_AVSession * avsession,OH_AVSessionCallback_OnSeek callback)590 AVSession_ErrCode OH_AVSession_UnregisterSeekCallback(OH_AVSession* avsession,
591 OH_AVSessionCallback_OnSeek callback)
592 {
593 CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
594 CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "callback is null");
595
596 OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
597 return oh_avsession->UnregisterSeekCallback(callback);
598 }
599
OH_AVSession_RegisterSetLoopModeCallback(OH_AVSession * avsession,OH_AVSessionCallback_OnSetLoopMode callback,void * userData)600 AVSession_ErrCode OH_AVSession_RegisterSetLoopModeCallback(OH_AVSession* avsession,
601 OH_AVSessionCallback_OnSetLoopMode callback, void* userData)
602 {
603 CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
604 CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "callback is null");
605
606 OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
607 return oh_avsession->RegisterSetLoopModeCallback(callback, userData);
608 }
609
OH_AVSession_UnregisterSetLoopModeCallback(OH_AVSession * avsession,OH_AVSessionCallback_OnSetLoopMode callback)610 AVSession_ErrCode OH_AVSession_UnregisterSetLoopModeCallback(OH_AVSession* avsession,
611 OH_AVSessionCallback_OnSetLoopMode callback)
612 {
613 CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
614 CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "callback is null");
615
616 OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
617 return oh_avsession->UnregisterSetLoopModeCallback(callback);
618 }
619
OH_AVSession_RegisterToggleFavoriteCallback(OH_AVSession * avsession,OH_AVSessionCallback_OnToggleFavorite callback,void * userData)620 AVSession_ErrCode OH_AVSession_RegisterToggleFavoriteCallback(OH_AVSession* avsession,
621 OH_AVSessionCallback_OnToggleFavorite callback, void* userData)
622 {
623 CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
624 CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "callback is null");
625
626 OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
627 return oh_avsession->RegisterToggleFavoriteCallback(callback, userData);
628 }
629
OH_AVSession_UnregisterToggleFavoriteCallback(OH_AVSession * avsession,OH_AVSessionCallback_OnToggleFavorite callback)630 AVSession_ErrCode OH_AVSession_UnregisterToggleFavoriteCallback(OH_AVSession* avsession,
631 OH_AVSessionCallback_OnToggleFavorite callback)
632 {
633 CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
634 CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "callback is null");
635
636 OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
637 return oh_avsession->UnregisterToggleFavoriteCallback(callback);
638 }