From 3133280996546a198580c0769b37a1a8c1fc72bb Mon Sep 17 00:00:00 2001 From: wangtao Date: Tue, 22 Nov 2022 14:20:22 +0800 Subject: [PATCH] refactor callback mode to handle event Signed-off-by: wangtao Change-Id: I27356d9c21356f9179fd6e377d4b337888003cc1 --- ...renderer_period_position_callback_napi.cpp | 4 + .../native/audiostream/include/audio_stream.h | 11 +- .../client/include/audio_service_client.h | 68 +++- .../client/src/audio_service_client.cpp | 332 +++++++++++++++--- .../audio_service/client/src/audio_stream.cpp | 36 +- 5 files changed, 353 insertions(+), 98 deletions(-) diff --git a/frameworks/js/napi/audio_renderer/src/renderer_period_position_callback_napi.cpp b/frameworks/js/napi/audio_renderer/src/renderer_period_position_callback_napi.cpp index b4a28d4abb..145642b516 100644 --- a/frameworks/js/napi/audio_renderer/src/renderer_period_position_callback_napi.cpp +++ b/frameworks/js/napi/audio_renderer/src/renderer_period_position_callback_napi.cpp @@ -72,6 +72,10 @@ void RendererPeriodPositionCallbackNapi::OnJsRendererPeriodPositionCallback( std::unique_ptr &jsCb) { uv_loop_s *loop = nullptr; + if (env_ == nullptr) { + AUDIO_ERR_LOG("RendererPeriodPositionCallbackNapi: OnJsRendererPeriodPositionCallback: env_ is null"); + return; + } napi_get_uv_event_loop(env_, &loop); if (loop == nullptr) { return; diff --git a/frameworks/native/audiostream/include/audio_stream.h b/frameworks/native/audiostream/include/audio_stream.h index 6c381f6694..216cd2c8fc 100644 --- a/frameworks/native/audiostream/include/audio_stream.h +++ b/frameworks/native/audiostream/include/audio_stream.h @@ -29,7 +29,7 @@ namespace AudioStandard { static constexpr int32_t MAX_WRITECB_NUM_BUFFERS = 1; static constexpr int32_t MAX_READCB_NUM_BUFFERS = 3; -class AudioStream : public AppExecFwk::EventHandler, public AudioServiceClient { +class AudioStream : public AudioServiceClient { public: AudioStream(AudioStreamType eStreamType, AudioMode eMode, int32_t appUid); virtual ~AudioStream(); @@ -69,8 +69,6 @@ public: int32_t Enqueue(const BufferDesc &bufDesc); int32_t Clear(); void SubmitAllFreeBuffers(); - void SendWriteBufferRequestEvent(); - void HandleWriteRequestEvent(); int32_t SetLowPowerVolume(float volume); float GetLowPowerVolume(); @@ -93,12 +91,8 @@ public: // Recording related APIs int32_t Read(uint8_t &buffer, size_t userSize, bool isBlockingRead); -protected: - virtual void ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) override; + private: - enum { - WRITE_BUFFER_REQUEST = 0, - }; AudioStreamType eStreamType_; AudioMode eMode_; State state_; @@ -131,7 +125,6 @@ private: std::mutex bufferQueueLock_; std::condition_variable bufferQueueCV_; - std::shared_ptr writeCallback_; }; } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_service/client/include/audio_service_client.h b/services/audio_service/client/include/audio_service_client.h index 2eb55ae7f8..a9ef90537e 100644 --- a/services/audio_service/client/include/audio_service_client.h +++ b/services/audio_service/client/include/audio_service_client.h @@ -37,6 +37,8 @@ #include "audio_policy_manager.h" #include "audio_renderer.h" #include "audio_system_manager.h" +#include "event_handler.h" +#include "event_runner.h" namespace OHOS { namespace AudioStandard { @@ -124,7 +126,7 @@ public: virtual void OnEventCb(AudioServiceEventTypes error) const = 0; }; -class AudioServiceClient : public AudioTimer { +class AudioServiceClient : public AudioTimer, public AppExecFwk::EventHandler { public: static constexpr char PA_RUNTIME_DIR[] = "/data/data/.pulse_dir/runtime"; static constexpr char PA_STATE_DIR[] = "/data/data/.pulse_dir/state"; @@ -504,10 +506,15 @@ public: float GetSingleStreamVol(); // Audio timer callback - virtual void OnTimeOut(); + virtual void OnTimeOut() override; void SetClientID(int32_t clientPid, int32_t clientUid); + void SendWriteBufferRequestEvent(); + void HandleWriteRequestEvent(); + int32_t SetRendererWriteCallback(const std::shared_ptr &callback); +protected: + virtual void ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) override; private: pa_threaded_mainloop *mainLoop; pa_mainloop_api *api; @@ -557,10 +564,9 @@ private: AudioRendererRate renderRate; AudioRenderMode renderMode_; - std::weak_ptr writeCallback_; AudioCaptureMode captureMode_; std::weak_ptr readCallback_; - + std::shared_ptr writeCallback_; int64_t mWriteCbStamp = 0; // used to measure callback duration uint32_t mFrameSize = 0; bool mMarkReached = false; @@ -671,6 +677,60 @@ private: static void GetSinkInputInfoCb(pa_context *c, const pa_sink_input_info *i, int eol, void *userdata); static void SetPaVolume(const AudioServiceClient &client); + + // OnRenderMarkReach SetRenderMarkReached UnsetRenderMarkReach by eventHandler + void SendRenderMarkReachedRequestEvent(uint64_t mFrameMarkPosition); + void HandleRenderMarkReachedEvent(uint64_t mFrameMarkPosition); + void SendSetRenderMarkReachedRequestEvent(const std::shared_ptr &callback); + void HandleSetRenderMarkReachedEvent(const std::shared_ptr &callback); + void SendUnsetRenderMarkReachedRequestEvent(); + void HandleUnsetRenderMarkReachedEvent(); + + // OnRenderPeriodReach SetRenderPeriodReach UnsetRenderPeriodReach by eventHandler + void SendRenderPeriodReachedRequestEvent(uint64_t mFramePeriodNumber); + void HandleRenderPeriodReachedEvent(uint64_t mFramePeriodNumber); + void SendSetRenderPeriodReachedRequestEvent(const std::shared_ptr &callback); + void HandleSetRenderPeriodReachedEvent(const std::shared_ptr &callback); + void SendUnsetRenderPeriodReachedRequestEvent(); + void HandleUnsetRenderPeriodReachedEvent(); + + // OnCapturerMarkReach SetCapturerMarkReach UnsetCapturerMarkReach by eventHandler + void SendCapturerMarkReachedRequestEvent(uint64_t mFrameMarkPosition); + void HandleCapturerMarkReachedEvent(uint64_t mFrameMarkPosition); + void SendSetCapturerMarkReachedRequestEvent(const std::shared_ptr &callback); + void HandleSetCapturerMarkReachedEvent(const std::shared_ptr &callback); + void SendUnsetCapturerMarkReachedRequestEvent(); + void HandleUnsetCapturerMarkReachedEvent(); + + // OnCapturerPeriodReach SetCapturerPeriodReach UnsetCapturerPeriodReach by eventHandler + void SendCapturerPeriodReachedRequestEvent(uint64_t mFramePeriodNumber); + void HandleCapturerPeriodReachedEvent(uint64_t mFramePeriodNumber); + void SendSetCapturerPeriodReachedRequestEvent( + const std::shared_ptr &callback); + void HandleSetCapturerPeriodReachedEvent( + const std::shared_ptr &callback); + void SendUnsetCapturerPeriodReachedRequestEvent(); + void HandleUnsetCapturerPeriodReachedEvent(); + + enum { + WRITE_BUFFER_REQUEST = 0, + + RENDERER_MARK_REACHED_REQUEST = 1, + SET_RENDERER_MARK_REACHED_REQUEST = 2, + UNSET_RENDERER_MARK_REACHED_REQUEST = 3, + + RENDERER_PERIOD_REACHED_REQUEST = 4, + SET_RENDERER_PERIOD_REACHED_REQUEST = 5, + UNSET_RENDERER_PERIOD_REACHED_REQUEST = 6, + + CAPTURER_PERIOD_REACHED_REQUEST = 7, + SET_CAPTURER_PERIOD_REACHED_REQUEST = 8, + UNSET_CAPTURER_PERIOD_REACHED_REQUEST = 9, + + CAPTURER_MARK_REACHED_REQUEST = 10, + SET_CAPTURER_MARK_REACHED_REQUEST = 11, + UNSET_CAPTURER_MARK_REACHED_REQUEST = 12, + }; }; } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_service/client/src/audio_service_client.cpp b/services/audio_service/client/src/audio_service_client.cpp index d2c8f25684..c186ebd84c 100644 --- a/services/audio_service/client/src/audio_service_client.cpp +++ b/services/audio_service/client/src/audio_service_client.cpp @@ -25,6 +25,7 @@ #include "securec.h" #include "system_ability_definition.h" #include "unistd.h" +#include "audio_errors.h" using namespace std; @@ -299,17 +300,6 @@ AudioCaptureMode AudioServiceClient::GetAudioCaptureMode() return captureMode_; } -int32_t AudioServiceClient::SaveWriteCallback(const std::weak_ptr &callback) -{ - if (callback.lock() == nullptr) { - AUDIO_ERR_LOG("AudioServiceClient::SaveWriteCallback callback == nullptr"); - return AUDIO_CLIENT_INIT_ERR; - } - writeCallback_ = callback; - - return AUDIO_CLIENT_SUCCESS; -} - int32_t AudioServiceClient::SaveReadCallback(const std::weak_ptr &callback) { if (callback.lock() == nullptr) { @@ -449,6 +439,7 @@ void AudioServiceClient::PAContextStateCb(pa_context *context, void *userdata) } AudioServiceClient::AudioServiceClient() + : AppExecFwk::EventHandler(AppExecFwk::EventRunner::Create("AudioServiceClientRunner")) { isMainLoopStarted = false; isContextConnected = false; @@ -1312,13 +1303,12 @@ void AudioServiceClient::HandleRenderPositionCallbacks(size_t bytesWritten) { std::lock_guard lock(rendererMarkReachedMutex_); - if (!mMarkReached && mRenderPositionCb) { + if (!mMarkReached) { AUDIO_DEBUG_LOG("frame mark position: %{public}" PRIu64 ", Total frames written: %{public}" PRIu64, static_cast(mFrameMarkPosition), static_cast(writtenFrameNumber)); if (writtenFrameNumber >= mFrameMarkPosition) { AUDIO_DEBUG_LOG("audio service client OnMarkReached"); - mPositionCBThreads.emplace_back(std::make_unique(&RendererPositionCallback::OnMarkReached, - mRenderPositionCb, mFrameMarkPosition)); + SendRenderMarkReachedRequestEvent(mFrameMarkPosition); mMarkReached = true; } } @@ -1326,17 +1316,14 @@ void AudioServiceClient::HandleRenderPositionCallbacks(size_t bytesWritten) { std::lock_guard lock(rendererPeriodReachedMutex_); - if (mRenderPeriodPositionCb) { - mFramePeriodWritten += (bytesWritten / mFrameSize); - AUDIO_DEBUG_LOG("frame period number: %{public}" PRIu64 ", Total frames written: %{public}" PRIu64, - static_cast(mFramePeriodNumber), static_cast(writtenFrameNumber)); - if (mFramePeriodWritten >= mFramePeriodNumber) { - mFramePeriodWritten %= mFramePeriodNumber; - AUDIO_DEBUG_LOG("OnPeriodReached, remaining frames: %{public}" PRIu64, - static_cast(mFramePeriodWritten)); - mPeriodPositionCBThreads.emplace_back(std::make_unique( - &RendererPeriodPositionCallback::OnPeriodReached, mRenderPeriodPositionCb, mFramePeriodNumber)); - } + mFramePeriodWritten += (bytesWritten / mFrameSize); + AUDIO_DEBUG_LOG("frame period number: %{public}" PRIu64 ", Total frames written: %{public}" PRIu64, + static_cast(mFramePeriodNumber), static_cast(writtenFrameNumber)); + if (mFramePeriodWritten >= mFramePeriodNumber) { + mFramePeriodWritten %= mFramePeriodNumber; + AUDIO_DEBUG_LOG("OnPeriodReached, remaining frames: %{public}" PRIu64, + static_cast(mFramePeriodWritten)); + SendRenderPeriodReachedRequestEvent(mFramePeriodNumber); } } } @@ -1586,13 +1573,12 @@ void AudioServiceClient::HandleCapturePositionCallbacks(size_t bytesRead) AUDIO_DEBUG_LOG("frame size: %{public}d", mFrameSize); { std::lock_guard lock(capturerMarkReachedMutex_); - if (!mMarkReached && mCapturePositionCb) { + if (!mMarkReached) { AUDIO_DEBUG_LOG("frame mark position: %{public}" PRIu64 ", Total frames read: %{public}" PRIu64, static_cast(mFrameMarkPosition), static_cast(readFrameNumber)); if (readFrameNumber >= mFrameMarkPosition) { AUDIO_DEBUG_LOG("audio service client capturer OnMarkReached"); - mPositionCBThreads.emplace_back(std::make_unique(&CapturerPositionCallback::OnMarkReached, - mCapturePositionCb, mFrameMarkPosition)); + SendCapturerMarkReachedRequestEvent(mFrameMarkPosition); mMarkReached = true; } } @@ -1600,17 +1586,14 @@ void AudioServiceClient::HandleCapturePositionCallbacks(size_t bytesRead) { std::lock_guard lock(capturerPeriodReachedMutex_); - if (mCapturePeriodPositionCb) { - mFramePeriodRead += (bytesRead / mFrameSize); - AUDIO_DEBUG_LOG("frame period number: %{public}" PRIu64 ", Total frames read: %{public}" PRIu64, - static_cast(mFramePeriodNumber), static_cast(readFrameNumber)); - if (mFramePeriodRead >= mFramePeriodNumber) { - mFramePeriodRead %= mFramePeriodNumber; - AUDIO_DEBUG_LOG("audio service client OnPeriodReached, remaining frames: %{public}" PRIu64, - static_cast(mFramePeriodRead)); - mPeriodPositionCBThreads.emplace_back(std::make_unique( - &CapturerPeriodPositionCallback::OnPeriodReached, mCapturePeriodPositionCb, mFramePeriodNumber)); - } + mFramePeriodRead += (bytesRead / mFrameSize); + AUDIO_DEBUG_LOG("frame period number: %{public}" PRIu64 ", Total frames read: %{public}" PRIu64, + static_cast(mFramePeriodNumber), static_cast(readFrameNumber)); + if (mFramePeriodRead >= mFramePeriodNumber) { + mFramePeriodRead %= mFramePeriodNumber; + AUDIO_DEBUG_LOG("audio service client OnPeriodReached, remaining frames: %{public}" PRIu64, + static_cast(mFramePeriodRead)); + SendCapturerPeriodReachedRequestEvent(mFramePeriodNumber); } } } @@ -1930,10 +1913,10 @@ void AudioServiceClient::RegisterAudioCapturerCallbacks(const AudioCapturerCallb void AudioServiceClient::SetRendererPositionCallback(int64_t markPosition, const std::shared_ptr &callback) { - AUDIO_INFO_LOG("Registering render frame position callback"); - AUDIO_INFO_LOG("mark position: %{public}" PRIu64, markPosition); + std::lock_guard lock(rendererMarkReachedMutex_); + AUDIO_INFO_LOG("Registering render frame position callback mark position: %{public}" PRIu64, markPosition); mFrameMarkPosition = markPosition; - mRenderPositionCb = callback; + SendSetRenderMarkReachedRequestEvent(callback); mMarkReached = false; } @@ -1941,7 +1924,7 @@ void AudioServiceClient::UnsetRendererPositionCallback() { AUDIO_INFO_LOG("Unregistering render frame position callback"); std::lock_guard lock(rendererMarkReachedMutex_); - mRenderPositionCb = nullptr; + SendUnsetRenderMarkReachedRequestEvent(); mMarkReached = false; mFrameMarkPosition = 0; } @@ -1949,6 +1932,7 @@ void AudioServiceClient::UnsetRendererPositionCallback() void AudioServiceClient::SetRendererPeriodPositionCallback(int64_t periodPosition, const std::shared_ptr &callback) { + std::lock_guard lock(rendererPeriodReachedMutex_); AUDIO_INFO_LOG("Registering render period position callback"); mFramePeriodNumber = periodPosition; if ((mFrameSize != 0) && (mFramePeriodNumber != 0)) { @@ -1957,14 +1941,14 @@ void AudioServiceClient::SetRendererPeriodPositionCallback(int64_t periodPositio AUDIO_ERR_LOG("AudioServiceClient::SetRendererPeriodPositionCallback failed"); return; } - mRenderPeriodPositionCb = callback; + SendSetRenderPeriodReachedRequestEvent(callback); } void AudioServiceClient::UnsetRendererPeriodPositionCallback() { AUDIO_INFO_LOG("Unregistering render period position callback"); std::lock_guard lock(rendererPeriodReachedMutex_); - mRenderPeriodPositionCb = nullptr; + SendUnsetRenderPeriodReachedRequestEvent(); mFramePeriodWritten = 0; mFramePeriodNumber = 0; } @@ -1972,10 +1956,10 @@ void AudioServiceClient::UnsetRendererPeriodPositionCallback() void AudioServiceClient::SetCapturerPositionCallback(int64_t markPosition, const std::shared_ptr &callback) { - AUDIO_INFO_LOG("Registering capture frame position callback"); - AUDIO_INFO_LOG("mark position: %{public}" PRIu64, markPosition); + std::lock_guard lock(capturerMarkReachedMutex_); + AUDIO_INFO_LOG("Registering capture frame position callback, mark position: %{public}" PRIu64, markPosition); mFrameMarkPosition = markPosition; - mCapturePositionCb = callback; + SendSetCapturerMarkReachedRequestEvent(callback); mMarkReached = false; } @@ -1983,7 +1967,7 @@ void AudioServiceClient::UnsetCapturerPositionCallback() { AUDIO_INFO_LOG("Unregistering capture frame position callback"); std::lock_guard lock(capturerMarkReachedMutex_); - mCapturePositionCb = nullptr; + SendUnsetCapturerMarkReachedRequestEvent(); mMarkReached = false; mFrameMarkPosition = 0; } @@ -1991,6 +1975,7 @@ void AudioServiceClient::UnsetCapturerPositionCallback() void AudioServiceClient::SetCapturerPeriodPositionCallback(int64_t periodPosition, const std::shared_ptr &callback) { + std::lock_guard lock(capturerPeriodReachedMutex_); AUDIO_INFO_LOG("Registering period position callback"); mFramePeriodNumber = periodPosition; if ((mFrameSize != 0) && (mFramePeriodNumber) != 0) { @@ -1999,14 +1984,14 @@ void AudioServiceClient::SetCapturerPeriodPositionCallback(int64_t periodPositio AUDIO_INFO_LOG("AudioServiceClient::SetCapturerPeriodPositionCallback failed"); return; } - mCapturePeriodPositionCb = callback; + SendSetCapturerPeriodReachedRequestEvent(callback); } void AudioServiceClient::UnsetCapturerPeriodPositionCallback() { AUDIO_INFO_LOG("Unregistering period position callback"); std::lock_guard lock(capturerPeriodReachedMutex_); - mCapturePeriodPositionCb = nullptr; + SendUnsetCapturerPeriodReachedRequestEvent(); mFramePeriodRead = 0; mFramePeriodNumber = 0; } @@ -2360,5 +2345,250 @@ float AudioServiceClient::GetSingleStreamVol() return vol; } + +// OnRenderMarkReach by eventHandler +void AudioServiceClient::SendRenderMarkReachedRequestEvent(uint64_t mFrameMarkPosition) +{ + SendEvent(AppExecFwk::InnerEvent::Get(RENDERER_MARK_REACHED_REQUEST, mFrameMarkPosition)); +} + +void AudioServiceClient::HandleRenderMarkReachedEvent(uint64_t mFrameMarkPosition) +{ + if (mRenderPositionCb) { + mRenderPositionCb->OnMarkReached(mFrameMarkPosition); + } +} + +// SetRenderMarkReached by eventHandler +void AudioServiceClient::SendSetRenderMarkReachedRequestEvent( + const std::shared_ptr &callback) +{ + SendEvent(AppExecFwk::InnerEvent::Get(SET_RENDERER_MARK_REACHED_REQUEST, callback)); +} + +void AudioServiceClient::HandleSetRenderMarkReachedEvent(const std::shared_ptr &callback) +{ + mRenderPositionCb = callback; +} + +// UnsetRenderMarkReach by eventHandler +void AudioServiceClient::SendUnsetRenderMarkReachedRequestEvent() +{ + SendEvent(AppExecFwk::InnerEvent::Get(UNSET_RENDERER_MARK_REACHED_REQUEST)); +} + +void AudioServiceClient::HandleUnsetRenderMarkReachedEvent() +{ + mRenderPositionCb = nullptr; +} + +// OnRenderPeriodReach by eventHandler +void AudioServiceClient::SendRenderPeriodReachedRequestEvent(uint64_t mFramePeriodNumber) +{ + SendEvent(AppExecFwk::InnerEvent::Get(RENDERER_PERIOD_REACHED_REQUEST, mFramePeriodNumber)); +} + +void AudioServiceClient::HandleRenderPeriodReachedEvent(uint64_t mFramePeriodNumber) +{ + if (mRenderPeriodPositionCb) { + mRenderPeriodPositionCb->OnPeriodReached(mFramePeriodNumber); + } +} + +// SetRenderPeriodReach by eventHandler +void AudioServiceClient::SendSetRenderPeriodReachedRequestEvent( + const std::shared_ptr &callback) +{ + SendEvent(AppExecFwk::InnerEvent::Get(SET_RENDERER_PERIOD_REACHED_REQUEST, callback)); +} + +void AudioServiceClient::HandleSetRenderPeriodReachedEvent( + const std::shared_ptr &callback) +{ + if (callback) { + mRenderPeriodPositionCb = callback; + } +} + +// UnsetRenderPeriodReach by eventHandler +void AudioServiceClient::SendUnsetRenderPeriodReachedRequestEvent() +{ + SendEvent(AppExecFwk::InnerEvent::Get(UNSET_RENDERER_PERIOD_REACHED_REQUEST)); +} + +void AudioServiceClient::HandleUnsetRenderPeriodReachedEvent() +{ + mRenderPeriodPositionCb = nullptr; +} + +// OnCapturerMarkReach by eventHandler +void AudioServiceClient::SendCapturerMarkReachedRequestEvent(uint64_t mFrameMarkPosition) +{ + SendEvent(AppExecFwk::InnerEvent::Get(CAPTURER_MARK_REACHED_REQUEST, mFrameMarkPosition)); +} + +void AudioServiceClient::HandleCapturerMarkReachedEvent(uint64_t mFrameMarkPosition) +{ + if (mCapturePositionCb) { + mCapturePositionCb->OnMarkReached(mFrameMarkPosition); + } +} + +// SetCapturerMarkReach by eventHandler +void AudioServiceClient::SendSetCapturerMarkReachedRequestEvent( + const std::shared_ptr &callback) +{ + SendEvent(AppExecFwk::InnerEvent::Get(SET_CAPTURER_MARK_REACHED_REQUEST, callback)); +} + +void AudioServiceClient::HandleSetCapturerMarkReachedEvent(const std::shared_ptr &callback) +{ + mCapturePositionCb = callback; +} + +// UnsetCapturerMarkReach by eventHandler +void AudioServiceClient::SendUnsetCapturerMarkReachedRequestEvent() +{ + SendEvent(AppExecFwk::InnerEvent::Get(UNSET_CAPTURER_MARK_REACHED_REQUEST)); +} + +void AudioServiceClient::HandleUnsetCapturerMarkReachedEvent() +{ + mCapturePositionCb = nullptr; +} + +// OnCapturerPeriodReach by eventHandler +void AudioServiceClient::SendCapturerPeriodReachedRequestEvent(uint64_t mFramePeriodNumber) +{ + SendEvent(AppExecFwk::InnerEvent::Get(CAPTURER_PERIOD_REACHED_REQUEST, mFramePeriodNumber)); +} + +void AudioServiceClient::HandleCapturerPeriodReachedEvent(uint64_t mFramePeriodNumber) +{ + if (mCapturePeriodPositionCb) { + mCapturePeriodPositionCb->OnPeriodReached(mFramePeriodNumber); + } +} + +// SetCapturerPeriodReach by eventHandler +void AudioServiceClient::SendSetCapturerPeriodReachedRequestEvent( + const std::shared_ptr &callback) +{ + SendEvent(AppExecFwk::InnerEvent::Get(SET_CAPTURER_PERIOD_REACHED_REQUEST, callback)); +} + +void AudioServiceClient::HandleSetCapturerPeriodReachedEvent( + const std::shared_ptr &callback) +{ + mCapturePeriodPositionCb = callback; +} + +// UnsetCapturerPeriodReach by eventHandler +void AudioServiceClient::SendUnsetCapturerPeriodReachedRequestEvent() +{ + SendEvent(AppExecFwk::InnerEvent::Get(UNSET_CAPTURER_PERIOD_REACHED_REQUEST)); +} + +void AudioServiceClient::HandleUnsetCapturerPeriodReachedEvent() +{ + mCapturePeriodPositionCb = nullptr; +} + +int32_t AudioServiceClient::SetRendererWriteCallback(const std::shared_ptr &callback) +{ + if (!callback) { + AUDIO_ERR_LOG("AudioServiceClient::SetRendererWriteCallback callback is nullptr"); + return ERR_INVALID_PARAM; + } + writeCallback_ = callback; + return SUCCESS; +} +void AudioServiceClient::SendWriteBufferRequestEvent() +{ + // send write event to handler + SendEvent(AppExecFwk::InnerEvent::Get(WRITE_BUFFER_REQUEST)); +} + +void AudioServiceClient::HandleWriteRequestEvent() +{ + // do callback to application + if (writeCallback_) { + size_t requestSize; + GetMinimumBufferSize(requestSize); + writeCallback_->OnWriteData(requestSize); + } +} + +void AudioServiceClient::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) +{ + uint32_t eventId = event->GetInnerEventId(); + uint64_t mFrameMarkPosition; + uint64_t mFramePeriodNumber; + std::shared_ptr renderPositionCb; + std::shared_ptr renderPeriodPositionCb; + std::shared_ptr capturePositionCb; + std::shared_ptr capturePeriodPositionCb; + + switch (eventId) { + case WRITE_BUFFER_REQUEST: + HandleWriteRequestEvent(); + break; + + // RenderMarkReach + case RENDERER_MARK_REACHED_REQUEST: + mFrameMarkPosition = event->GetParam(); + HandleRenderMarkReachedEvent(mFrameMarkPosition); + break; + case SET_RENDERER_MARK_REACHED_REQUEST: + renderPositionCb = event->GetSharedObject(); + HandleSetRenderMarkReachedEvent(renderPositionCb); + break; + case UNSET_RENDERER_MARK_REACHED_REQUEST: + HandleUnsetRenderMarkReachedEvent(); + break; + + // RenderPeriodReach + case RENDERER_PERIOD_REACHED_REQUEST: + mFramePeriodNumber = event->GetParam(); + HandleRenderPeriodReachedEvent(mFramePeriodNumber); + break; + case SET_RENDERER_PERIOD_REACHED_REQUEST: + renderPeriodPositionCb = event->GetSharedObject(); + HandleSetRenderPeriodReachedEvent(renderPeriodPositionCb); + break; + case UNSET_RENDERER_PERIOD_REACHED_REQUEST: + HandleUnsetRenderPeriodReachedEvent(); + break; + + // CapturerMarkReach + case CAPTURER_MARK_REACHED_REQUEST: + mFrameMarkPosition = event->GetParam(); + HandleCapturerMarkReachedEvent(mFrameMarkPosition); + break; + case SET_CAPTURER_MARK_REACHED_REQUEST: + capturePositionCb = event->GetSharedObject(); + HandleSetCapturerMarkReachedEvent(capturePositionCb); + break; + case UNSET_CAPTURER_MARK_REACHED_REQUEST: + HandleUnsetCapturerMarkReachedEvent(); + break; + + // CapturerPeriodReach + case CAPTURER_PERIOD_REACHED_REQUEST: + mFramePeriodNumber = event->GetParam(); + HandleCapturerPeriodReachedEvent(mFramePeriodNumber); + break; + case SET_CAPTURER_PERIOD_REACHED_REQUEST: + capturePeriodPositionCb = event->GetSharedObject(); + HandleSetCapturerPeriodReachedEvent(capturePeriodPositionCb); + break; + case UNSET_CAPTURER_PERIOD_REACHED_REQUEST: + HandleUnsetCapturerPeriodReachedEvent(); + break; + + default: + break; + } +} } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_service/client/src/audio_stream.cpp b/services/audio_service/client/src/audio_stream.cpp index 1b5216a47a..2e26181261 100644 --- a/services/audio_service/client/src/audio_stream.cpp +++ b/services/audio_service/client/src/audio_stream.cpp @@ -80,8 +80,7 @@ map, AudioStreamType> AudioStream::CreateStreamMa } AudioStream::AudioStream(AudioStreamType eStreamType, AudioMode eMode, int32_t appUid) - : AppExecFwk::EventHandler(AppExecFwk::EventRunner::Create("AudioStreamRunner")), - eStreamType_(eStreamType), + : eStreamType_(eStreamType), eMode_(eMode), state_(NEW), isReadInProgress_(false), @@ -751,9 +750,7 @@ int32_t AudioStream::SetRendererWriteCallback(const std::shared_ptr &callback) @@ -983,34 +980,5 @@ void AudioStream::SubmitAllFreeBuffers() SendWriteBufferRequestEvent(); } } - -void AudioStream::SendWriteBufferRequestEvent() -{ - // send write event to handler - SendEvent(AppExecFwk::InnerEvent::Get(WRITE_BUFFER_REQUEST)); -} - -void AudioStream::HandleWriteRequestEvent() -{ - // do callback to application - if (writeCallback_) { - size_t requestSize; - GetMinimumBufferSize(requestSize); - writeCallback_->OnWriteData(requestSize); - } -} - -void AudioStream::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) -{ - uint32_t eventId = event->GetInnerEventId(); - switch (eventId) { - case WRITE_BUFFER_REQUEST: { - HandleWriteRequestEvent(); - break; - } - default: - break; - } -} } // namespace AudioStandard } // namespace OHOS -- Gitee