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         return AV_SESSION_ERR_SERVICE_EXCEPTION;
361     }
362     *avsession = (OH_AVSession*)oh_avsession;
363     return AV_SESSION_ERR_SUCCESS;
364 }
365 
OH_AVSession_Destroy(OH_AVSession * avsession)366 AVSession_ErrCode OH_AVSession_Destroy(OH_AVSession* avsession)
367 {
368     CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
369 
370     OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
371     oh_avsession->Destroy();
372     if (oh_avsession != nullptr) {
373         delete oh_avsession;
374     }
375     return AV_SESSION_ERR_SUCCESS;
376 }
377 
OH_AVSession_Activate(OH_AVSession * avsession)378 AVSession_ErrCode OH_AVSession_Activate(OH_AVSession* avsession)
379 {
380     CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
381 
382     OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
383     return oh_avsession->Activate();
384 }
385 
OH_AVSession_Deactivate(OH_AVSession * avsession)386 AVSession_ErrCode OH_AVSession_Deactivate(OH_AVSession* avsession)
387 {
388     CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
389 
390     OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
391     return oh_avsession->Deactivate();
392 }
393 
OH_AVSession_GetSessionType(OH_AVSession * avsession,AVSession_Type * sessionType)394 AVSession_ErrCode OH_AVSession_GetSessionType(OH_AVSession* avsession, AVSession_Type* sessionType)
395 {
396     CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
397     CHECK_AND_RETURN_RET_LOG(sessionType != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "sessionType is null");
398 
399     OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
400     std::string str = oh_avsession->GetSessionType();
401     auto it = oh_avsession->avsessionTypes.find(str);
402     if (it == oh_avsession->avsessionTypes.end()) {
403         return AV_SESSION_ERR_SERVICE_EXCEPTION;
404     }
405     *sessionType = it->second;
406     return AV_SESSION_ERR_SUCCESS;
407 }
408 
OH_AVSession_GetSessionId(OH_AVSession * avsession,const char ** sessionId)409 AVSession_ErrCode OH_AVSession_GetSessionId(OH_AVSession* avsession, const char** sessionId)
410 {
411     CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
412     CHECK_AND_RETURN_RET_LOG(sessionId != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "sessionId is null");
413 
414     OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
415     *sessionId = oh_avsession->GetSessionId().c_str();
416     return AV_SESSION_ERR_SUCCESS;
417 }
418 
OH_AVSession_SetAVMetadata(OH_AVSession * avsession,OH_AVMetadata * metadata)419 AVSession_ErrCode OH_AVSession_SetAVMetadata(OH_AVSession* avsession, OH_AVMetadata* metadata)
420 {
421     CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
422     CHECK_AND_RETURN_RET_LOG(metadata != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVMetadata is null");
423 
424     OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
425     return oh_avsession->SetAVMetaData(metadata);
426 }
427 
OH_AVSession_SetPlaybackState(OH_AVSession * avsession,AVSession_PlaybackState playbackState)428 AVSession_ErrCode OH_AVSession_SetPlaybackState(OH_AVSession* avsession, AVSession_PlaybackState playbackState)
429 {
430     CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
431 
432     switch (playbackState) {
433         case PLAYBACK_STATE_INITIAL:
434         case PLAYBACK_STATE_PREPARING:
435         case PLAYBACK_STATE_PLAYING:
436         case PLAYBACK_STATE_PAUSED:
437         case PLAYBACK_STATE_FAST_FORWARDING:
438         case PLAYBACK_STATE_REWINDED:
439         case PLAYBACK_STATE_STOPPED:
440         case PLAYBACK_STATE_COMPLETED:
441         case PLAYBACK_STATE_RELEASED:
442         case PLAYBACK_STATE_ERROR:
443         case PLAYBACK_STATE_IDLE:
444         case PLAYBACK_STATE_BUFFERING:
445             break;
446         default:
447             SLOGE("Invalid playback state: %{public}d", playbackState);
448             return AV_SESSION_ERR_INVALID_PARAMETER;
449     }
450 
451     OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
452     return oh_avsession->SetPlaybackState(playbackState);
453 }
454 
OH_AVSession_SetPlaybackPosition(OH_AVSession * avsession,AVSession_PlaybackPosition * playbackPosition)455 AVSession_ErrCode OH_AVSession_SetPlaybackPosition(OH_AVSession* avsession,
456     AVSession_PlaybackPosition* playbackPosition)
457 {
458     CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
459     CHECK_AND_RETURN_RET_LOG(playbackPosition != nullptr, AV_SESSION_ERR_INVALID_PARAMETER,
460         "playbackPosition is null");
461 
462     OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
463     return oh_avsession->SetPlaybackPosition(playbackPosition);
464 }
465 
OH_AVSession_SetFavorite(OH_AVSession * avsession,bool favorite)466 AVSession_ErrCode OH_AVSession_SetFavorite(OH_AVSession* avsession, bool favorite)
467 {
468     CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
469 
470     OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
471     return oh_avsession->SetFavorite(favorite);
472 }
473 
OH_AVSession_SetLoopMode(OH_AVSession * avsession,AVSession_LoopMode loopMode)474 AVSession_ErrCode OH_AVSession_SetLoopMode(OH_AVSession* avsession, AVSession_LoopMode loopMode)
475 {
476     CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
477 
478     switch (loopMode) {
479         case LOOP_MODE_SEQUENCE:
480         case LOOP_MODE_SINGLE:
481         case LOOP_MODE_LIST:
482         case LOOP_MODE_SHUFFLE:
483         case LOOP_MODE_CUSTOM:
484             break;
485         default:
486             SLOGE("Invalid loop mode: %{public}d", loopMode);
487             return AV_SESSION_ERR_INVALID_PARAMETER;
488     }
489 
490     OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
491     return oh_avsession->SetLoopMode(loopMode);
492 }
493 
OH_AVSession_RegisterCommandCallback(OH_AVSession * avsession,AVSession_ControlCommand command,OH_AVSessionCallback_OnCommand callback,void * userData)494 AVSession_ErrCode OH_AVSession_RegisterCommandCallback(OH_AVSession* avsession,
495     AVSession_ControlCommand command, OH_AVSessionCallback_OnCommand callback, void* userData)
496 {
497     CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
498     CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "callback is null");
499 
500     switch (command) {
501         case CONTROL_CMD_PLAY:
502         case CONTROL_CMD_PAUSE:
503         case CONTROL_CMD_STOP:
504         case CONTROL_CMD_PLAY_NEXT:
505         case CONTROL_CMD_PLAY_PREVIOUS:
506             break;
507         default:
508             SLOGE("Invalid command: %{public}d", command);
509             return AV_SESSION_ERR_CODE_COMMAND_INVALID;
510     }
511 
512     OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
513     return  oh_avsession->RegisterCommandCallback(command, callback, userData);
514 }
515 
OH_AVSession_UnregisterCommandCallback(OH_AVSession * avsession,AVSession_ControlCommand command,OH_AVSessionCallback_OnCommand callback)516 AVSession_ErrCode OH_AVSession_UnregisterCommandCallback(OH_AVSession* avsession,
517     AVSession_ControlCommand command, OH_AVSessionCallback_OnCommand callback)
518 {
519     CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
520     CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "callback is null");
521 
522     switch (command) {
523         case CONTROL_CMD_PLAY:
524         case CONTROL_CMD_PAUSE:
525         case CONTROL_CMD_STOP:
526         case CONTROL_CMD_PLAY_NEXT:
527         case CONTROL_CMD_PLAY_PREVIOUS:
528             break;
529         default:
530             SLOGE("Invalid command: %{public}d", command);
531             return AV_SESSION_ERR_CODE_COMMAND_INVALID;
532     }
533 
534     OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
535     return oh_avsession->UnregisterCommandCallback(command, callback);
536 }
537 
OH_AVSession_RegisterForwardCallback(OH_AVSession * avsession,OH_AVSessionCallback_OnFastForward callback,void * userData)538 AVSession_ErrCode OH_AVSession_RegisterForwardCallback(OH_AVSession* avsession,
539     OH_AVSessionCallback_OnFastForward callback, void* userData)
540 {
541     CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
542     CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "callback is null");
543 
544     OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
545     return oh_avsession->RegisterForwardCallback(callback, userData);
546 }
547 
OH_AVSession_UnregisterForwardCallback(OH_AVSession * avsession,OH_AVSessionCallback_OnFastForward callback)548 AVSession_ErrCode OH_AVSession_UnregisterForwardCallback(OH_AVSession* avsession,
549     OH_AVSessionCallback_OnFastForward callback)
550 {
551     CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
552     CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "callback is null");
553 
554     OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
555     return oh_avsession->UnregisterForwardCallback(callback);
556 }
557 
OH_AVSession_RegisterRewindCallback(OH_AVSession * avsession,OH_AVSessionCallback_OnRewind callback,void * userData)558 AVSession_ErrCode OH_AVSession_RegisterRewindCallback(OH_AVSession* avsession,
559     OH_AVSessionCallback_OnRewind callback, void* userData)
560 {
561     CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
562     CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "callback is null");
563 
564     OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
565     return oh_avsession->RegisterRewindCallback(callback, userData);
566 }
567 
OH_AVSession_UnregisterRewindCallback(OH_AVSession * avsession,OH_AVSessionCallback_OnRewind callback)568 AVSession_ErrCode OH_AVSession_UnregisterRewindCallback(OH_AVSession* avsession,
569     OH_AVSessionCallback_OnRewind callback)
570 {
571     CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
572     CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "callback is null");
573 
574     OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
575     return oh_avsession->UnregisterRewindCallback(callback);
576 }
577 
OH_AVSession_RegisterSeekCallback(OH_AVSession * avsession,OH_AVSessionCallback_OnSeek callback,void * userData)578 AVSession_ErrCode OH_AVSession_RegisterSeekCallback(OH_AVSession* avsession,
579     OH_AVSessionCallback_OnSeek callback, void* userData)
580 {
581     CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
582     CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "callback is null");
583 
584     OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
585     return oh_avsession->RegisterSeekCallback(callback, userData);
586 }
587 
OH_AVSession_UnregisterSeekCallback(OH_AVSession * avsession,OH_AVSessionCallback_OnSeek callback)588 AVSession_ErrCode OH_AVSession_UnregisterSeekCallback(OH_AVSession* avsession,
589     OH_AVSessionCallback_OnSeek callback)
590 {
591     CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
592     CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "callback is null");
593 
594     OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
595     return oh_avsession->UnregisterSeekCallback(callback);
596 }
597 
OH_AVSession_RegisterSetLoopModeCallback(OH_AVSession * avsession,OH_AVSessionCallback_OnSetLoopMode callback,void * userData)598 AVSession_ErrCode OH_AVSession_RegisterSetLoopModeCallback(OH_AVSession* avsession,
599     OH_AVSessionCallback_OnSetLoopMode callback, void* userData)
600 {
601     CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
602     CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "callback is null");
603 
604     OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
605     return oh_avsession->RegisterSetLoopModeCallback(callback, userData);
606 }
607 
OH_AVSession_UnregisterSetLoopModeCallback(OH_AVSession * avsession,OH_AVSessionCallback_OnSetLoopMode callback)608 AVSession_ErrCode OH_AVSession_UnregisterSetLoopModeCallback(OH_AVSession* avsession,
609     OH_AVSessionCallback_OnSetLoopMode callback)
610 {
611     CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
612     CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "callback is null");
613 
614     OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
615     return oh_avsession->UnregisterSetLoopModeCallback(callback);
616 }
617 
OH_AVSession_RegisterToggleFavoriteCallback(OH_AVSession * avsession,OH_AVSessionCallback_OnToggleFavorite callback,void * userData)618 AVSession_ErrCode OH_AVSession_RegisterToggleFavoriteCallback(OH_AVSession* avsession,
619     OH_AVSessionCallback_OnToggleFavorite callback, void* userData)
620 {
621     CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
622     CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "callback is null");
623 
624     OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
625     return oh_avsession->RegisterToggleFavoriteCallback(callback, userData);
626 }
627 
OH_AVSession_UnregisterToggleFavoriteCallback(OH_AVSession * avsession,OH_AVSessionCallback_OnToggleFavorite callback)628 AVSession_ErrCode OH_AVSession_UnregisterToggleFavoriteCallback(OH_AVSession* avsession,
629     OH_AVSessionCallback_OnToggleFavorite callback)
630 {
631     CHECK_AND_RETURN_RET_LOG(avsession != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "AVSession is null");
632     CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_SESSION_ERR_INVALID_PARAMETER, "callback is null");
633 
634     OHOS::AVSession::OHAVSession *oh_avsession = (OHOS::AVSession::OHAVSession *)avsession;
635     return oh_avsession->UnregisterToggleFavoriteCallback(callback);
636 }