1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "cj_audio_haptic_player.h"
16
17 #include "audio_haptic_log.h"
18
19 namespace {
20
21 const std::string AUDIO_INTERRUPT_CALLBACK_NAME = "audioInterrupt";
22 const std::string END_OF_STREAM_CALLBACK_NAME = "endOfStream";
23
24 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN_AUDIO_NAPI, "CjAudioHapticPlayer"};
25 }
26
27 namespace OHOS {
28 namespace Media {
29
30
CjAudioHapticPlayerCallback()31 CjAudioHapticPlayerCallback::CjAudioHapticPlayerCallback() {}
32
~CjAudioHapticPlayerCallback()33 CjAudioHapticPlayerCallback::~CjAudioHapticPlayerCallback() {}
34
SaveCallbackReference(const std::string & callbackName,int64_t callbackId)35 void CjAudioHapticPlayerCallback::SaveCallbackReference(const std::string &callbackName, int64_t callbackId)
36 {
37 std::lock_guard<std::mutex> lock(cbMutex_);
38 if (callbackName == AUDIO_INTERRUPT_CALLBACK_NAME) {
39 auto cb = reinterpret_cast<void(*)(int32_t, int32_t, int32_t)>(callbackId);
40 audioInterruptCb_ = CJLambda::Create(cb);
41 }
42 if (callbackName == END_OF_STREAM_CALLBACK_NAME) {
43 auto cb = reinterpret_cast<void(*)()>(callbackId);
44 endOfStreamCb_ = CJLambda::Create(cb);
45 }
46 }
47
RemoveCallbackReference(const std::string & callbackName)48 void CjAudioHapticPlayerCallback::RemoveCallbackReference(const std::string &callbackName)
49 {
50 std::lock_guard<std::mutex> lock(cbMutex_);
51
52 if (callbackName == AUDIO_INTERRUPT_CALLBACK_NAME) {
53 audioInterruptCb_ = nullptr;
54 } else if (callbackName == END_OF_STREAM_CALLBACK_NAME) {
55 endOfStreamCb_ = nullptr;
56 } else {
57 MEDIA_LOGE("RemoveCallbackReference: Unknown callback type: %{public}s", callbackName.c_str());
58 }
59 }
60
OnInterrupt(const AudioStandard::InterruptEvent & interruptEvent)61 void CjAudioHapticPlayerCallback::OnInterrupt(const AudioStandard::InterruptEvent &interruptEvent)
62 {
63 std::lock_guard<std::mutex> lock(cbMutex_);
64 MEDIA_LOGI("OnInterrupt: hintType: %{public}d ", interruptEvent.hintType);
65 CHECK_AND_RETURN_LOG(audioInterruptCb_ != nullptr, "Cannot find the reference of interrupt callback");
66 audioInterruptCb_(interruptEvent.eventType, interruptEvent.forceType, interruptEvent.hintType);
67 return;
68 }
69
OnEndOfStream(void)70 void CjAudioHapticPlayerCallback::OnEndOfStream(void)
71 {
72 std::lock_guard<std::mutex> lock(cbMutex_);
73 CHECK_AND_RETURN_LOG(endOfStreamCb_ != nullptr, "Cannot find the reference of endOfStream callback");
74
75 endOfStreamCb_();
76 return;
77 }
78
OnError(int32_t errorCode)79 void CjAudioHapticPlayerCallback::OnError(int32_t errorCode)
80 {
81 MEDIA_LOGI("OnError from audio haptic player. errorCode %{public}d", errorCode);
82 }
83
CjAudioHapticPlayer(std::shared_ptr<AudioHapticPlayer> audioHapticPlayer)84 CjAudioHapticPlayer::CjAudioHapticPlayer(std::shared_ptr<AudioHapticPlayer> audioHapticPlayer)
85 {
86 audioHapticPlayer_ = audioHapticPlayer;
87 }
88
89 CjAudioHapticPlayer::~CjAudioHapticPlayer() = default;
90
IsMuted(int32_t type,bool & ret)91 int32_t CjAudioHapticPlayer::IsMuted(int32_t type, bool &ret)
92 {
93 if (!IsLegalAudioHapticType(type)) {
94 return ERR_INVALID_ARG;
95 }
96
97 ret = audioHapticPlayer_->IsMuted(static_cast<AudioHapticType>(type));
98 return SUCCESS;
99 }
100
IsLegalAudioHapticType(int32_t audioHapticType)101 bool CjAudioHapticPlayer::IsLegalAudioHapticType(int32_t audioHapticType)
102 {
103 switch (audioHapticType) {
104 case AUDIO_HAPTIC_TYPE_AUDIO:
105 case AUDIO_HAPTIC_TYPE_HAPTIC:
106 return true;
107 default:
108 break;
109 }
110 MEDIA_LOGE("IsLegalAudioHapticType: audioHapticType %{public}d is invalid", audioHapticType);
111 return false;
112 }
113
Start()114 int32_t CjAudioHapticPlayer::Start()
115 {
116 return audioHapticPlayer_->Start();
117 }
118
Stop()119 int32_t CjAudioHapticPlayer::Stop()
120 {
121 return audioHapticPlayer_->Stop();
122 }
123
Release()124 int32_t CjAudioHapticPlayer::Release()
125 {
126 return audioHapticPlayer_->Release();
127 }
128
On(const char * type,int64_t callbackId)129 int32_t CjAudioHapticPlayer::On(const char* type, int64_t callbackId)
130 {
131 if (!cjCallback) {
132 cjCallback = std::make_shared<CjAudioHapticPlayerCallback>();
133 if (!cjCallback) {
134 return -1;
135 }
136 int32_t ret = audioHapticPlayer_->SetAudioHapticPlayerCallback(cjCallback);
137 if (ret != SUCCESS) {
138 return ret;
139 }
140 }
141 cjCallback->SaveCallbackReference(type, callbackId);
142 return SUCCESS;
143 }
144
Off(const char * type)145 int32_t CjAudioHapticPlayer::Off(const char* type)
146 {
147 cjCallback->RemoveCallbackReference(type);
148 return SUCCESS;
149 }
150
151 } // namespace Media
152 } // namespace OHOS