openharmony/multimedia_audio_standard
1
0
Fork 0
mirror of https://gitee.com/openharmony/multimedia_audio_standard synced 2025-03-01 09:36:34 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

State Change Listener

Browse Source 
Signed-off-by: Kiran Bhupali <kiran.bhupali@huawei.com>
This commit is contained in:
Kiran Bhupali 2022-06-14 17:33:23 +05:30
parent 433502fcb1
commit fd878bcb20
62 changed files with 4139 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
frameworks/js/napi/audio_manager/include/audio_capturer_state_callback_napi.h Normal file
View File

@ -0,0 +1,49 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef AUDIO_CAPTURER_STATE_CALLBACK_NAPI_H
#define AUDIO_CAPTURER_STATE_CALLBACK_NAPI_H
#include "audio_common_napi.h"
#include "audio_manager_napi.h"
#include "audio_stream_manager.h"
#include "napi/native_api.h"
#include "napi/native_node_api.h"
namespace OHOS {
namespace AudioStandard {
class AudioCapturerStateCallbackNapi : public AudioCapturerStateChangeCallback {
public:
explicit AudioCapturerStateCallbackNapi(napi_env env);
virtual ~AudioCapturerStateCallbackNapi();
void SaveCallbackReference(napi_value callback);
void OnCapturerStateChange(
const std::vector<std::unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos) override;
private:
struct AudioCapturerStateJsCallback {
std::shared_ptr<AutoRef> callback = nullptr;
std::vector<std::unique_ptr<AudioCapturerChangeInfo>> changeInfos;
};
void OnJsCallbackCapturerState(std::unique_ptr<AudioCapturerStateJsCallback> &jsCb);
std::mutex mutex_;
napi_env env_ = nullptr;
std::shared_ptr<AutoRef> capturerStateCallback_ = nullptr;
};
} // namespace AudioStandard
} // namespace OHOS
#endif // AUDIO_CAPTURER_STATE_CALLBACK_NAPI_H

49
frameworks/js/napi/audio_manager/include/audio_renderer_state_callback_napi.h Normal file
View File

@ -0,0 +1,49 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef AUDIO_RENDERER_STATE_CALLBACK_NAPI_H
#define AUDIO_RENDERER_STATE_CALLBACK_NAPI_H
#include "audio_common_napi.h"
#include "audio_manager_napi.h"
#include "audio_stream_manager.h"
#include "napi/native_api.h"
#include "napi/native_node_api.h"
namespace OHOS {
namespace AudioStandard {
class AudioRendererStateCallbackNapi : public AudioRendererStateChangeCallback {
public:
explicit AudioRendererStateCallbackNapi(napi_env env);
virtual ~AudioRendererStateCallbackNapi();
void SaveCallbackReference(napi_value callback);
void OnRendererStateChange(
const std::vector<std::unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos) override;
private:
struct AudioRendererStateJsCallback {
std::shared_ptr<AutoRef> callback = nullptr;
std::vector<std::unique_ptr<AudioRendererChangeInfo>> changeInfos;
};
void OnJsCallbackRendererState(std::unique_ptr<AudioRendererStateJsCallback> &jsCb);
std::mutex mutex_;
napi_env env_ = nullptr;
std::shared_ptr<AutoRef> rendererStateCallback_ = nullptr;
};
} // namespace AudioStandard
} // namespace OHOS
#endif // AUDIO_RENDERERSTATE_CALLBACK_NAPI_H

168
frameworks/js/napi/audio_manager/src/audio_capturer_state_callback_napi.cpp Normal file
View File

@ -0,0 +1,168 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "audio_capturer_state_callback_napi.h"
#include <uv.h>
#include "audio_errors.h"
#include "audio_log.h"
using namespace std;
namespace OHOS {
namespace AudioStandard {
AudioCapturerStateCallbackNapi::AudioCapturerStateCallbackNapi(napi_env env)
: env_(env)
{
AUDIO_DEBUG_LOG("AudioCapturerStateCallbackNapi: instance create");
}
AudioCapturerStateCallbackNapi::~AudioCapturerStateCallbackNapi()
{
AUDIO_DEBUG_LOG("AudioCapturerStateCallbackNapi: instance destroy");
}
void AudioCapturerStateCallbackNapi::SaveCallbackReference(napi_value args)
{
std::lock_guard<std::mutex> lock(mutex_);
napi_ref callback = nullptr;
const int32_t refCount = 1;
napi_status status = napi_create_reference(env_, args, refCount, &callback);
CHECK_AND_RETURN_LOG(status == napi_ok && callback != nullptr,
"AudioCapturerStateCallbackNapi: creating reference for callback fail");
std::shared_ptr<AutoRef> cb = std::make_shared<AutoRef>(env_, callback);
CHECK_AND_RETURN_LOG(cb != nullptr, "AudioCapturerStateCallbackNapi: creating callback failed");
capturerStateCallback_ = cb;
}
void AudioCapturerStateCallbackNapi::OnCapturerStateChange(
const std::vector<std::unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos)
{
AUDIO_INFO_LOG("AudioCapturerStateCallbackNapi: OnCapturerStateChange is called");
std::lock_guard<std::mutex> lock(mutex_);
std::unique_ptr<AudioCapturerStateJsCallback> cb = std::make_unique<AudioCapturerStateJsCallback>();
CHECK_AND_RETURN_LOG(cb != nullptr, "No memory!!");
std::vector<std::unique_ptr<AudioCapturerChangeInfo>> capturerChangeInfos;
for (const auto &changeInfo : audioCapturerChangeInfos) {
capturerChangeInfos.push_back(std::make_unique<AudioCapturerChangeInfo>(*changeInfo));
}
AUDIO_DEBUG_LOG("AudioCapturerStateCallbackNapi::capturerChangeInfos Number of entries %{public}u",
static_cast<uint32_t>(capturerChangeInfos.size()));
int index = 0;
for (auto it = capturerChangeInfos.begin(); it != capturerChangeInfos.end(); it++) {
AudioCapturerChangeInfo audioCapturerChangeInfo = **it;
AUDIO_DEBUG_LOG("audioCapturerChangeInfos_[%{public}d]", index++);
AUDIO_DEBUG_LOG("clientUID = %{public}d", audioCapturerChangeInfo.clientUID);
AUDIO_DEBUG_LOG("sessionId = %{public}d", audioCapturerChangeInfo.sessionId);
AUDIO_DEBUG_LOG("capturerState = %{public}d", audioCapturerChangeInfo.capturerState);
}
cb->callback = capturerStateCallback_;
cb->changeInfos = move(capturerChangeInfos);
return OnJsCallbackCapturerState(cb);
}
static void SetValueInt32(const napi_env& env, const std::string& fieldStr, const int intValue, napi_value& obj)
{
napi_value value = nullptr;
napi_create_int32(env, intValue, &value);
napi_set_named_property(env, obj, fieldStr.c_str(), value);
}
static void NativeCapturerChangeInfoToJsObj(const napi_env &env, napi_value &jsArrayChangeInfoObj,
const vector<unique_ptr<AudioCapturerChangeInfo>> &changeInfos)
{
napi_value jsChangeInfoObj = nullptr;
napi_value jsCapInfoObj = nullptr;
size_t size = changeInfos.size();
int32_t position = 0;
napi_create_array_with_length(env, size, &jsArrayChangeInfoObj);
for (const unique_ptr<AudioCapturerChangeInfo> &changeInfo : changeInfos) {
AUDIO_DEBUG_LOG("AudioCapturerStateCallbackNapi: ChangeInfo to jsobj called");
napi_create_object(env, &jsChangeInfoObj);
SetValueInt32(env, "streamId", static_cast<int32_t>(changeInfo->sessionId), jsChangeInfoObj);
SetValueInt32(env, "capturerState", static_cast<int32_t>(changeInfo->capturerState), jsChangeInfoObj);
SetValueInt32(env, "clientUid", static_cast<int32_t>(changeInfo->clientUID), jsChangeInfoObj);
napi_create_object(env, &jsCapInfoObj);
SetValueInt32(env, "source", static_cast<int32_t>(changeInfo->capturerInfo.sourceType), jsCapInfoObj);
SetValueInt32(env, "capturerFlags", changeInfo->capturerInfo.capturerFlags, jsCapInfoObj);
napi_set_named_property(env, jsChangeInfoObj, "capturerInfo", jsCapInfoObj);
napi_set_element(env, jsArrayChangeInfoObj, position, jsChangeInfoObj);
position++;
}
}
void AudioCapturerStateCallbackNapi::OnJsCallbackCapturerState(std::unique_ptr<AudioCapturerStateJsCallback> &jsCb)
{
uv_loop_s *loop = nullptr;
napi_get_uv_event_loop(env_, &loop);
if (loop == nullptr) {
return;
}
uv_work_t *work = new(std::nothrow) uv_work_t;
if (work == nullptr) {
AUDIO_ERR_LOG("AudioCapturerStateCallbackNapi: OnJsCallbackCapturerState: No memory");
return;
}
work->data = reinterpret_cast<void *>(jsCb.get());
int ret = uv_queue_work(loop, work, [] (uv_work_t *work) {}, [] (uv_work_t *work, int status) {
// Js Thread
AudioCapturerStateJsCallback *event = reinterpret_cast<AudioCapturerStateJsCallback *>(work->data);
napi_env env = event->callback->env_;
napi_ref callback = event->callback->cb_;
do {
napi_value jsCallback = nullptr;
napi_status nstatus = napi_get_reference_value(env, callback, &jsCallback);
CHECK_AND_BREAK_LOG(nstatus == napi_ok && jsCallback != nullptr,
"callback get reference value fail");
// Call back function
napi_value args[1] = { nullptr };
NativeCapturerChangeInfoToJsObj(env, args[0], event->changeInfos);
CHECK_AND_BREAK_LOG(nstatus == napi_ok && args[0] != nullptr,
" fail to convert to jsobj");
const size_t argCount = 1;
napi_value result = nullptr;
nstatus = napi_call_function(env, nullptr, jsCallback, argCount, args, &result);
CHECK_AND_BREAK_LOG(nstatus == napi_ok, "Fail to call renderstate callback");
} while (0);
delete event;
delete work;
});
if (ret != 0) {
AUDIO_ERR_LOG("Failed to execute libuv work queue");
delete work;
} else {
jsCb.release();
}
}
} // namespace AudioStandard
} // namespace OHOS

72
frameworks/js/napi/audio_manager/src/audio_manager_napi.cpp
View File

@ -687,6 +687,7 @@ template<typename T> napi_value AudioManagerNapi::CreatePropertyBase(napi_env en
napi_value AudioManagerNapi::Init(napi_env env, napi_value exports)
{
AUDIO_INFO_LOG("AudioManagerNapi::Init");
napi_status status;
napi_value constructor;
napi_value result = nullptr;
@ -715,6 +716,7 @@ napi_value AudioManagerNapi::Init(napi_env env, napi_value exports)
DECLARE_NAPI_FUNCTION("off", Off),
DECLARE_NAPI_FUNCTION("requestIndependentInterrupt", RequestIndependentInterrupt),
DECLARE_NAPI_FUNCTION("abandonIndependentInterrupt", AbandonIndependentInterrupt),
DECLARE_NAPI_FUNCTION("getStreamManager", GetStreamManager),
};
napi_property_descriptor static_prop[] = {
@ -2409,6 +2411,75 @@ napi_value AudioManagerNapi::Off(napi_env env, napi_callback_info info)
return undefinedResult;
}
napi_value AudioManagerNapi::GetStreamManager(napi_env env, napi_callback_info info)
{
HiLog::Info(LABEL, "%{public}s IN", __func__);
napi_status status;
const int32_t refCount = 1;
napi_value result = nullptr;
GET_PARAMS(env, info, ARGS_ONE);
unique_ptr<AudioManagerAsyncContext> asyncContext = make_unique<AudioManagerAsyncContext>();
CHECK_AND_RETURN_RET_LOG(asyncContext != nullptr, nullptr, "AudioManagerAsyncContext object creation failed");
for (size_t i = PARAM0; i < argc; i++) {
napi_valuetype valueType = napi_undefined;
napi_typeof(env, argv[i], &valueType);
if (i == PARAM0 && valueType == napi_function) {
napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef);
break;
} else {
NAPI_ASSERT(env, false, "type mismatch");
}
}
if (asyncContext->callbackRef == nullptr) {
napi_create_promise(env, &asyncContext->deferred, &result);
} else {
napi_get_undefined(env, &result);
}
napi_value resource = nullptr;
napi_create_string_utf8(env, "GetStreamManager", NAPI_AUTO_LENGTH, &resource);
status = napi_create_async_work(
env, nullptr, resource,
[](napi_env env, void *data) {
auto context = static_cast<AudioManagerAsyncContext *>(data);
context->status = SUCCESS;
},
GetStreamMgrAsyncCallbackComplete, static_cast<void *>(asyncContext.get()), &asyncContext->work);
if (status != napi_ok) {
result = nullptr;
} else {
status = napi_queue_async_work(env, asyncContext->work);
if (status == napi_ok) {
asyncContext.release();
} else {
result = nullptr;
}
}
return result;
}
void AudioManagerNapi::GetStreamMgrAsyncCallbackComplete(napi_env env, napi_status status, void *data)
{
napi_value valueParam = nullptr;
auto asyncContext = static_cast<AudioManagerAsyncContext *>(data);
if (asyncContext != nullptr) {
if (!asyncContext->status) {
valueParam = AudioStreamMgrNapi::CreateStreamManagerWrapper(env);
}
CommonCallbackRoutine(env, asyncContext, valueParam);
} else {
HiLog::Error(LABEL, "ERROR: GetStreamMgrAsyncCallbackComplete asyncContext is Null!");
}
}
static napi_value Init(napi_env env, napi_value exports)
{
AudioManagerNapi::Init(env, exports);
@ -2419,6 +2490,7 @@ static napi_value Init(napi_env env, napi_value exports)
SystemSoundManagerNapi::Init(env, exports);
RingtoneOptionsNapi::Init(env, exports);
AudioRendererInfoNapi::Init(env, exports);
AudioStreamMgrNapi::Init(env, exports);
return exports;
}

167
frameworks/js/napi/audio_manager/src/audio_renderer_state_callback_napi.cpp Normal file
View File

@ -0,0 +1,167 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "audio_renderer_state_callback_napi.h"
#include <uv.h>
#include "audio_errors.h"
#include "audio_log.h"
using namespace std;
namespace OHOS {
namespace AudioStandard {
AudioRendererStateCallbackNapi::AudioRendererStateCallbackNapi(napi_env env)
: env_(env)
{
AUDIO_DEBUG_LOG("AudioRendererStateCallbackNapi: instance create");
}
AudioRendererStateCallbackNapi::~AudioRendererStateCallbackNapi()
{
AUDIO_DEBUG_LOG("AudioRendererStateCallbackNapi: instance destroy");
}
void AudioRendererStateCallbackNapi::SaveCallbackReference(napi_value args)
{
std::lock_guard<std::mutex> lock(mutex_);
napi_ref callback = nullptr;
const int32_t refCount = 1;
napi_status status = napi_create_reference(env_, args, refCount, &callback);
CHECK_AND_RETURN_LOG(status == napi_ok && callback != nullptr,
"AudioRendererStateCallbackNapi: creating reference for callback fail");
std::shared_ptr<AutoRef> cb = std::make_shared<AutoRef>(env_, callback);
CHECK_AND_RETURN_LOG(cb != nullptr, "AudioRendererStateCallbackNapi: creating callback failed");
rendererStateCallback_ = cb;
}
void AudioRendererStateCallbackNapi::OnRendererStateChange(
const std::vector<std::unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos)
{
AUDIO_INFO_LOG("AudioRendererStateCallbackNapi: OnRendererStateChange entered");
std::lock_guard<std::mutex> lock(mutex_);
std::unique_ptr<AudioRendererStateJsCallback> cb = std::make_unique<AudioRendererStateJsCallback>();
CHECK_AND_RETURN_LOG(cb != nullptr, "No memory!!");
std::vector<std::unique_ptr<AudioRendererChangeInfo>> rendererChangeInfos;
for (const auto &changeInfo : audioRendererChangeInfos) {
rendererChangeInfos.push_back(std::make_unique<AudioRendererChangeInfo>(*changeInfo));
}
AUDIO_DEBUG_LOG("AudioRendererStateCallbackNapi::OnRendererStateChange Number of entries %{public}u",
static_cast<uint32_t>(rendererChangeInfos.size()));
int index = 0;
for (auto it = rendererChangeInfos.begin(); it != rendererChangeInfos.end(); it++) {
AudioRendererChangeInfo audioRendererChangeInfo = **it;
AUDIO_DEBUG_LOG("audioRendererChangeInfos_[%{public}d]", index++);
AUDIO_DEBUG_LOG("clientUID = %{public}d", audioRendererChangeInfo.clientUID);
AUDIO_DEBUG_LOG("sessionId = %{public}d", audioRendererChangeInfo.sessionId);
AUDIO_DEBUG_LOG("rendererState = %{public}d", audioRendererChangeInfo.rendererState);
}
cb->callback = rendererStateCallback_;
cb->changeInfos = move(rendererChangeInfos);
return OnJsCallbackRendererState(cb);
}
static void SetValueInt32(const napi_env& env, const std::string& fieldStr, const int intValue, napi_value& obj)
{
napi_value value = nullptr;
napi_create_int32(env, intValue, &value);
napi_set_named_property(env, obj, fieldStr.c_str(), value);
}
static void NativeRendererChangeInfoToJsObj(const napi_env &env, napi_value &jsArrayChangeInfoObj,
const vector<unique_ptr<AudioRendererChangeInfo>> &changeInfos)
{
napi_value jsChangeInfoObj = nullptr;
napi_value jsRenInfoObj = nullptr;
size_t size = changeInfos.size();
int32_t position = 0;
napi_create_array_with_length(env, size, &jsArrayChangeInfoObj);
for (const unique_ptr<AudioRendererChangeInfo> &changeInfo: changeInfos) {
napi_create_object(env, &jsChangeInfoObj);
SetValueInt32(env, "streamId", static_cast<int32_t>(changeInfo->sessionId), jsChangeInfoObj);
SetValueInt32(env, "rendererState", static_cast<int32_t>(changeInfo->rendererState), jsChangeInfoObj);
SetValueInt32(env, "clientUid", static_cast<int32_t>(changeInfo->clientUID), jsChangeInfoObj);
napi_create_object(env, &jsRenInfoObj);
SetValueInt32(env, "content", static_cast<int32_t>(changeInfo->rendererInfo.contentType), jsRenInfoObj);
SetValueInt32(env, "usage", static_cast<int32_t>(changeInfo->rendererInfo.streamUsage), jsRenInfoObj);
SetValueInt32(env, "rendererFlags", changeInfo->rendererInfo.rendererFlags, jsRenInfoObj);
napi_set_named_property(env, jsChangeInfoObj, "rendererInfo", jsRenInfoObj);
napi_set_element(env, jsArrayChangeInfoObj, position, jsChangeInfoObj);
position++;
}
}
void AudioRendererStateCallbackNapi::OnJsCallbackRendererState(std::unique_ptr<AudioRendererStateJsCallback> &jsCb)
{
uv_loop_s *loop = nullptr;
napi_get_uv_event_loop(env_, &loop);
if (loop == nullptr) {
return;
}
uv_work_t *work = new(std::nothrow) uv_work_t;
if (work == nullptr) {
AUDIO_ERR_LOG("AudioRendererStateCallbackNapi: OnJsCallbackRendererState: No memory");
return;
}
work->data = reinterpret_cast<void *>(jsCb.get());
int ret = uv_queue_work(loop, work, [] (uv_work_t *work) {}, [] (uv_work_t *work, int status) {
// Js Thread
AudioRendererStateJsCallback *event = reinterpret_cast<AudioRendererStateJsCallback *>(work->data);
napi_env env = event->callback->env_;
napi_ref callback = event->callback->cb_;
do {
napi_value jsCallback = nullptr;
napi_status nstatus = napi_get_reference_value(env, callback, &jsCallback);
CHECK_AND_BREAK_LOG(nstatus == napi_ok && jsCallback != nullptr, "callback get reference value fail");
// Call back function
napi_value args[1] = { nullptr };
NativeRendererChangeInfoToJsObj(env, args[0], event->changeInfos);
CHECK_AND_BREAK_LOG(nstatus == napi_ok && args[0] != nullptr,
" fail to convert to jsobj");
const size_t argCount = 1;
napi_value result = nullptr;
nstatus = napi_call_function(env, nullptr, jsCallback, argCount, args, &result);
CHECK_AND_BREAK_LOG(nstatus == napi_ok, "Fail to call renderstate callback");
} while (0);
delete event;
delete work;
});
if (ret != 0) {
AUDIO_ERR_LOG("Failed to execute libuv work queue");
delete work;
} else {
jsCb.release();
}
}
} // namespace AudioStandard
} // namespace OHOS

551
frameworks/js/napi/audio_stream_manager/src/audio_stream_mgr_napi.cpp Normal file
View File

@ -0,0 +1,551 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "audio_stream_mgr_napi.h"
#include "audio_common_napi.h"
#include "audio_errors.h"
#include "audio_log.h"
#include "hilog/log.h"
#include "napi_base_context.h"
#include "audio_capturer_state_callback_napi.h"
#include "audio_renderer_state_callback_napi.h"
using namespace std;
using OHOS::HiviewDFX::HiLog;
using OHOS::HiviewDFX::HiLogLabel;
namespace OHOS {
namespace AudioStandard {
static __thread napi_ref g_streamMgrConstructor = nullptr;
namespace {
const std::string RENDERERCHANGE_CALLBACK_NAME = "audioRendererChange";
const std::string CAPTURERCHANGE_CALLBACK_NAME = "audioCapturerChange";
const int ARGS_ONE = 1;
const int ARGS_TWO = 2;
const int PARAM0 = 0;
const int PARAM1 = 1;
const int PARAM2 = 2;
const int PARAM3 = 3;
constexpr HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN, "AudioStreamManagerNapi"};
#define GET_PARAMS(env, info, num) \
size_t argc = num; \
napi_value argv[num] = {0}; \
napi_value thisVar = nullptr; \
void *data; \
napi_get_cb_info(env, info, &argc, argv, &thisVar, &data)
}
struct AudioStreamMgrAsyncContext {
napi_env env;
napi_async_work work;
napi_deferred deferred;
napi_ref callbackRef = nullptr;
int32_t status;
AudioStreamMgrNapi *objectInfo;
vector<unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
vector<unique_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
};
AudioStreamMgrNapi::AudioStreamMgrNapi()
: env_(nullptr), wrapper_(nullptr) {}
AudioStreamMgrNapi::~AudioStreamMgrNapi()
{
if (wrapper_ != nullptr) {
napi_delete_reference(env_, wrapper_);
}
}
void AudioStreamMgrNapi::Destructor(napi_env env, void *nativeObject, void *finalize_hint)
{
if (nativeObject != nullptr) {
auto obj = static_cast<AudioStreamMgrNapi *>(nativeObject);
delete obj;
obj = nullptr;
}
}
static void SetValueInt32(const napi_env& env, const std::string& fieldStr, const int intValue, napi_value &result)
{
napi_value value = nullptr;
napi_create_int32(env, intValue, &value);
napi_set_named_property(env, result, fieldStr.c_str(), value);
}
static void GetCurrentRendererChangeInfosCallbackComplete(napi_env env, napi_status status, void *data)
{
auto asyncContext = static_cast<AudioStreamMgrAsyncContext*>(data);
napi_value result[ARGS_TWO] = {0};
napi_value jsChangeInfoObj = nullptr;
napi_value jsRenInfoObj = nullptr;
napi_value retVal;
size_t size = asyncContext->audioRendererChangeInfos.size();
int32_t position = 0;
napi_create_array_with_length(env, size, &result[PARAM1]);
for (const unique_ptr<AudioRendererChangeInfo> &changeInfo: asyncContext->audioRendererChangeInfos) {
if (!changeInfo) {
AUDIO_ERR_LOG("AudioManagerNapi:AudioRendererChangeInfo Null, something wrong!!");
continue;
}
napi_create_object(env, &jsChangeInfoObj);
SetValueInt32(env, "streamId", changeInfo->sessionId, jsChangeInfoObj);
SetValueInt32(env, "rendererState", static_cast<int32_t>(changeInfo->rendererState), jsChangeInfoObj);
SetValueInt32(env, "clientUid", changeInfo->clientUID, jsChangeInfoObj);
napi_create_object(env, &jsRenInfoObj);
SetValueInt32(env, "content", static_cast<int32_t>(changeInfo->rendererInfo.contentType), jsRenInfoObj);
SetValueInt32(env, "usage", static_cast<int32_t>(changeInfo->rendererInfo.streamUsage), jsRenInfoObj);
SetValueInt32(env, "rendererFlags", changeInfo->rendererInfo.rendererFlags, jsRenInfoObj);
napi_set_named_property(env, jsChangeInfoObj, "rendererInfo", jsRenInfoObj);
napi_set_element(env, result[PARAM1], position, jsChangeInfoObj);
position++;
}
napi_get_undefined(env, &result[PARAM0]);
if (asyncContext->deferred) {
napi_resolve_deferred(env, asyncContext->deferred, result[PARAM1]);
} else {
napi_value callback = nullptr;
napi_get_reference_value(env, asyncContext->callbackRef, &callback);
napi_call_function(env, nullptr, callback, ARGS_TWO, result, &retVal);
napi_delete_reference(env, asyncContext->callbackRef);
}
napi_delete_async_work(env, asyncContext->work);
delete asyncContext;
}
static void GetCurrentCapturerChangeInfosCallbackComplete(napi_env env, napi_status status, void *data)
{
auto asyncContext = static_cast<AudioStreamMgrAsyncContext*>(data);
napi_value result[ARGS_TWO] = {0};
napi_value jsChangeInfoObj = nullptr;
napi_value jsCapInfoObj = nullptr;
napi_value retVal;
size_t size = asyncContext->audioCapturerChangeInfos.size();
int32_t position = 0;
napi_create_array_with_length(env, size, &result[PARAM1]);
for (const unique_ptr<AudioCapturerChangeInfo> &changeInfo: asyncContext->audioCapturerChangeInfos) {
if (!changeInfo) {
AUDIO_ERR_LOG("AudioManagerNapi:AudioCapturerChangeInfo Null, something wrong!!");
continue;
}
napi_create_object(env, &jsChangeInfoObj);
SetValueInt32(env, "streamId", changeInfo->sessionId, jsChangeInfoObj);
SetValueInt32(env, "capturerState", static_cast<int32_t>(changeInfo->capturerState), jsChangeInfoObj);
SetValueInt32(env, "clientUid", changeInfo->clientUID, jsChangeInfoObj);
napi_create_object(env, &jsCapInfoObj);
SetValueInt32(env, "source", static_cast<int32_t>(changeInfo->capturerInfo.sourceType), jsCapInfoObj);
SetValueInt32(env, "capturerFlags", changeInfo->capturerInfo.capturerFlags, jsCapInfoObj);
napi_set_named_property(env, jsChangeInfoObj, "capturerInfo", jsCapInfoObj);
napi_set_element(env, result[PARAM1], position, jsChangeInfoObj);
position++;
}
napi_get_undefined(env, &result[PARAM0]);
if (asyncContext->deferred) {
napi_resolve_deferred(env, asyncContext->deferred, result[PARAM1]);
} else {
napi_value callback = nullptr;
napi_get_reference_value(env, asyncContext->callbackRef, &callback);
napi_call_function(env, nullptr, callback, ARGS_TWO, result, &retVal);
napi_delete_reference(env, asyncContext->callbackRef);
}
napi_delete_async_work(env, asyncContext->work);
delete asyncContext;
}
napi_value AudioStreamMgrNapi::Init(napi_env env, napi_value exports)
{
AUDIO_INFO_LOG("AudioStreamMgrNapi::Init");
napi_status status;
napi_value constructor;
napi_value result = nullptr;
const int32_t refCount = 1;
napi_get_undefined(env, &result);
napi_property_descriptor audio_stream_mgr_properties[] = {
DECLARE_NAPI_FUNCTION("on", On),
DECLARE_NAPI_FUNCTION("off", Off),
DECLARE_NAPI_FUNCTION("getCurrentAudioRendererInfoArray", GetCurrentAudioRendererInfos),
DECLARE_NAPI_FUNCTION("getCurrentAudioCapturerInfoArray", GetCurrentAudioCapturerInfos)
};
status = napi_define_class(env, AUDIO_STREAM_MGR_NAPI_CLASS_NAME.c_str(), NAPI_AUTO_LENGTH, Construct, nullptr,
sizeof(audio_stream_mgr_properties) / sizeof(audio_stream_mgr_properties[PARAM0]),
audio_stream_mgr_properties, &constructor);
if (status != napi_ok) {
return result;
}
status = napi_create_reference(env, constructor, refCount, &g_streamMgrConstructor);
if (status == napi_ok) {
status = napi_set_named_property(env, exports, AUDIO_STREAM_MGR_NAPI_CLASS_NAME.c_str(), constructor);
if (status == napi_ok) {
return exports;
}
}
HiLog::Error(LABEL, "Failure in AudioStreamMgrNapi::Init()");
return result;
}
napi_value AudioStreamMgrNapi::CreateStreamManagerWrapper(napi_env env)
{
napi_status status;
napi_value result = nullptr;
napi_value constructor;
status = napi_get_reference_value(env, g_streamMgrConstructor, &constructor);
if (status == napi_ok) {
status = napi_new_instance(env, constructor, 0, nullptr, &result);
if (status == napi_ok) {
return result;
}
}
HiLog::Error(LABEL, "Failed in AudioStreamManagerNapi::CreateStreamMngrWrapper!");
napi_get_undefined(env, &result);
return result;
}
napi_value AudioStreamMgrNapi::Construct(napi_env env, napi_callback_info info)
{
AUDIO_INFO_LOG("AudioStreamMgrNapi::Construct");
napi_status status;
napi_value result = nullptr;
napi_get_undefined(env, &result);
GET_PARAMS(env, info, ARGS_TWO);
unique_ptr<AudioStreamMgrNapi> streamMgrNapi = make_unique<AudioStreamMgrNapi>();
CHECK_AND_RETURN_RET_LOG(streamMgrNapi != nullptr, result, "No memory");
streamMgrNapi->env_ = env;
streamMgrNapi->audioStreamMngr_ = AudioStreamManager::GetInstance();
streamMgrNapi->cachedClientId = getpid();
status = napi_wrap(env, thisVar, static_cast<void*>(streamMgrNapi.get()),
AudioStreamMgrNapi::Destructor, nullptr, &(streamMgrNapi->wrapper_));
if (status == napi_ok) {
streamMgrNapi.release();
return thisVar;
}
HiLog::Error(LABEL, "Failed in AudioStreamManager::Construct()!");
return result;
}
void AudioStreamMgrNapi::RegisterRendererStateChangeCallback(napi_env env, napi_value* args,
const std::string& cbName, AudioStreamMgrNapi *streamMgrNapi)
{
if (!streamMgrNapi->rendererStateChangeCallbackNapi_) {
streamMgrNapi->rendererStateChangeCallbackNapi_ = std::make_shared<AudioRendererStateCallbackNapi>(env);
if (!streamMgrNapi->rendererStateChangeCallbackNapi_) {
AUDIO_ERR_LOG("AudioStreamMgrNapi: Memory Allocation Failed !!");
return;
}
int32_t ret = streamMgrNapi->audioStreamMngr_->RegisterAudioRendererEventListener(streamMgrNapi->cachedClientId,
streamMgrNapi->rendererStateChangeCallbackNapi_);
if (ret) {
AUDIO_ERR_LOG("AudioStreamMgrNapi: Registering of Renderer State Change Callback Failed");
return;
}
}
std::shared_ptr<AudioRendererStateCallbackNapi> cb =
std::static_pointer_cast<AudioRendererStateCallbackNapi>(streamMgrNapi->rendererStateChangeCallbackNapi_);
cb->SaveCallbackReference(args[PARAM1]);
AUDIO_INFO_LOG("AudioManagerNapi::OnRendererStateChangeCallback is successful");
}
void AudioStreamMgrNapi::RegisterCapturerStateChangeCallback(napi_env env, napi_value* args,
const std::string& cbName, AudioStreamMgrNapi *streamMgrNapi)
{
if (!streamMgrNapi->capturerStateChangeCallbackNapi_) {
streamMgrNapi->capturerStateChangeCallbackNapi_ = std::make_shared<AudioCapturerStateCallbackNapi>(env);
if (!streamMgrNapi->capturerStateChangeCallbackNapi_) {
AUDIO_ERR_LOG("AudioStreamMgrNapi: Memory Allocation Failed !!");
return;
}
int32_t ret = streamMgrNapi->audioStreamMngr_->RegisterAudioCapturerEventListener(streamMgrNapi->cachedClientId,
streamMgrNapi->capturerStateChangeCallbackNapi_);
if (ret) {
AUDIO_ERR_LOG("AudioStreamMgrNapi: Registering of Capturer State Change Callback Failed");
return;
}
}
std::shared_ptr<AudioCapturerStateCallbackNapi> cb =
std::static_pointer_cast<AudioCapturerStateCallbackNapi>(streamMgrNapi->capturerStateChangeCallbackNapi_);
cb->SaveCallbackReference(args[PARAM1]);
AUDIO_INFO_LOG("AudioManagerNapi::OnCapturerStateChangeCallback is successful");
}
void AudioStreamMgrNapi::RegisterCallback(napi_env env, napi_value jsThis,
napi_value* args, const std::string& cbName)
{
AudioStreamMgrNapi *streamMgrNapi = nullptr;
napi_status status = napi_unwrap(env, jsThis, reinterpret_cast<void **>(&streamMgrNapi));
if ((status != napi_ok) || (streamMgrNapi == nullptr) || (streamMgrNapi->audioStreamMngr_ == nullptr)) {
AUDIO_ERR_LOG("AudioStreamMgrNapi::Failed to retrieve stream mgr napi instance.");
return;
}
if (!cbName.compare(RENDERERCHANGE_CALLBACK_NAME)) {
RegisterRendererStateChangeCallback(env, args, cbName, streamMgrNapi);
} else if (!cbName.compare(CAPTURERCHANGE_CALLBACK_NAME)) {
RegisterCapturerStateChangeCallback(env, args, cbName, streamMgrNapi);
} else {
AUDIO_ERR_LOG("AudioStreamMgrNapi::No such callback supported");
}
}
napi_value AudioStreamMgrNapi::On(napi_env env, napi_callback_info info)
{
const size_t requireArgc = PARAM2;
size_t argc = PARAM3;
napi_value undefinedResult = nullptr;
napi_get_undefined(env, &undefinedResult);
napi_value args[requireArgc + 1] = {nullptr, nullptr, nullptr};
napi_value jsThis = nullptr;
napi_status status = napi_get_cb_info(env, info, &argc, args, &jsThis, nullptr);
NAPI_ASSERT(env, status == napi_ok && argc == requireArgc, "AudioStreamMgrNapi: On: requires 2 parameters");
napi_valuetype eventType = napi_undefined;
napi_typeof(env, args[0], &eventType);
NAPI_ASSERT(env, eventType == napi_string, "AudioStreamMgrNapi:On: type mismatch for event name, parameter 1");
std::string callbackName = AudioCommonNapi::GetStringArgument(env, args[0]);
AUDIO_DEBUG_LOG("AudioStreamMgrNapi: On callbackName: %{public}s", callbackName.c_str());
napi_valuetype handler = napi_undefined;
napi_typeof(env, args[1], &handler);
NAPI_ASSERT(env, handler == napi_function, "type mismatch for parameter 2");
RegisterCallback(env, jsThis, args, callbackName);
return undefinedResult;
}
void AudioStreamMgrNapi::UnregisterCallback(napi_env env, napi_value jsThis, const std::string& cbName)
{
AUDIO_INFO_LOG("AudioStreamMgrNapi::UnregisterCallback");
AudioStreamMgrNapi *streamMgrNapi = nullptr;
napi_status status = napi_unwrap(env, jsThis, reinterpret_cast<void **>(&streamMgrNapi));
if ((status != napi_ok) || (streamMgrNapi == nullptr) || (streamMgrNapi->audioStreamMngr_ == nullptr)) {
AUDIO_ERR_LOG("AudioStreamMgrNapi::Failed to retrieve stream mgr napi instance.");
return;
}
if (!cbName.compare(RENDERERCHANGE_CALLBACK_NAME)) {
int32_t ret = streamMgrNapi->audioStreamMngr_->
UnregisterAudioRendererEventListener(streamMgrNapi->cachedClientId);
if (ret) {
AUDIO_ERR_LOG("AudioStreamMgrNapi:UnRegistering of Renderer State Change Callback Failed");
return;
}
if (streamMgrNapi->rendererStateChangeCallbackNapi_ != nullptr) {
streamMgrNapi->rendererStateChangeCallbackNapi_.reset();
streamMgrNapi->rendererStateChangeCallbackNapi_ = nullptr;
}
AUDIO_INFO_LOG("AudioStreamMgrNapi:UnRegistering of renderer State Change Callback successful");
} else if (!cbName.compare(CAPTURERCHANGE_CALLBACK_NAME)) {
int32_t ret = streamMgrNapi->audioStreamMngr_->
UnregisterAudioCapturerEventListener(streamMgrNapi->cachedClientId);
if (ret) {
AUDIO_ERR_LOG("AudioStreamMgrNapi:UnRegistering of capturer State Change Callback Failed");
return;
}
if (streamMgrNapi->capturerStateChangeCallbackNapi_ != nullptr) {
streamMgrNapi->capturerStateChangeCallbackNapi_.reset();
streamMgrNapi->capturerStateChangeCallbackNapi_ = nullptr;
}
AUDIO_INFO_LOG("AudioStreamMgrNapi:UnRegistering of capturer State Change Callback successful");
} else {
AUDIO_ERR_LOG("AudioStreamMgrNapi::No such callback supported");
}
}
napi_value AudioStreamMgrNapi::Off(napi_env env, napi_callback_info info)
{
const size_t requireArgc = 1;
size_t argc = 1;
napi_value undefinedResult = nullptr;
napi_get_undefined(env, &undefinedResult);
napi_value args[requireArgc] = {nullptr};
napi_value jsThis = nullptr;
napi_status status = napi_get_cb_info(env, info, &argc, args, &jsThis, nullptr);
NAPI_ASSERT(env, status == napi_ok && argc >= requireArgc, "AudioStreamMgrNapi: Off: requires min 1 parameters");
napi_valuetype eventType = napi_undefined;
napi_typeof(env, args[0], &eventType);
NAPI_ASSERT(env, eventType == napi_string, "AudioStreamMgrNapi:Off: type mismatch for event name, parameter 1");
std::string callbackName = AudioCommonNapi::GetStringArgument(env, args[0]);
AUDIO_DEBUG_LOG("AudioStreamMgrNapi: Off callbackName: %{public}s", callbackName.c_str());
UnregisterCallback(env, jsThis, callbackName);
return undefinedResult;
}
napi_value AudioStreamMgrNapi::GetCurrentAudioRendererInfos(napi_env env, napi_callback_info info)
{
napi_status status;
const int32_t refCount = 1;
napi_value result = nullptr;
GET_PARAMS(env, info, ARGS_ONE);
unique_ptr<AudioStreamMgrAsyncContext> asyncContext = make_unique<AudioStreamMgrAsyncContext>();
if (!asyncContext) {
AUDIO_ERR_LOG("AudioManagerNapi:Audio manager async context failed");
return result;
}
status = napi_unwrap(env, thisVar, reinterpret_cast<void**>(&asyncContext->objectInfo));
if (status == napi_ok && asyncContext->objectInfo != nullptr) {
for (size_t i = PARAM0; i < argc; i++) {
napi_valuetype valueType = napi_undefined;
napi_typeof(env, argv[i], &valueType);
if (i == PARAM0 && valueType == napi_function) {
napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef);
break;
} else {
NAPI_ASSERT(env, false, "type mismatch");
}
}
if (asyncContext->callbackRef == nullptr) {
napi_create_promise(env, &asyncContext->deferred, &result);
} else {
napi_get_undefined(env, &result);
}
napi_value resource = nullptr;
napi_create_string_utf8(env, "getCurrentAudioRendererInfoArray", NAPI_AUTO_LENGTH, &resource);
status = napi_create_async_work(
env, nullptr, resource,
[](napi_env env, void *data) {
auto context = static_cast<AudioStreamMgrAsyncContext *>(data);
context->status = context->objectInfo->audioStreamMngr_->
GetCurrentRendererChangeInfos(context->audioRendererChangeInfos);
},
GetCurrentRendererChangeInfosCallbackComplete, static_cast<void*>(asyncContext.get()), &asyncContext->work);
if (status != napi_ok) {
result = nullptr;
} else {
status = napi_queue_async_work(env, asyncContext->work);
if (status == napi_ok) {
asyncContext.release();
} else {
result = nullptr;
}
}
}
return result;
}
napi_value AudioStreamMgrNapi::GetCurrentAudioCapturerInfos(napi_env env, napi_callback_info info)
{
napi_status status;
const int32_t refCount = 1;
napi_value result = nullptr;
GET_PARAMS(env, info, ARGS_ONE);
unique_ptr<AudioStreamMgrAsyncContext> asyncContext = make_unique<AudioStreamMgrAsyncContext>();
if (!asyncContext) {
AUDIO_ERR_LOG("AudioStreamMgrNapi:async context memory alloc failed");
return result;
}
status = napi_unwrap(env, thisVar, reinterpret_cast<void**>(&asyncContext->objectInfo));
if (status == napi_ok && asyncContext->objectInfo != nullptr) {
for (size_t i = PARAM0; i < argc; i++) {
napi_valuetype valueType = napi_undefined;
napi_typeof(env, argv[i], &valueType);
if (i == PARAM0 && valueType == napi_function) {
napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef);
break;
} else {
NAPI_ASSERT(env, false, "type mismatch");
}
}
if (asyncContext->callbackRef == nullptr) {
napi_create_promise(env, &asyncContext->deferred, &result);
} else {
napi_get_undefined(env, &result);
}
napi_value resource = nullptr;
napi_create_string_utf8(env, "getCurrentAudioCapturerInfoArray", NAPI_AUTO_LENGTH, &resource);
status = napi_create_async_work(
env, nullptr, resource,
[](napi_env env, void *data) {
auto context = static_cast<AudioStreamMgrAsyncContext*>(data);
context->objectInfo->audioStreamMngr_->GetCurrentCapturerChangeInfos(context->audioCapturerChangeInfos);
context->status = 0;
},
GetCurrentCapturerChangeInfosCallbackComplete, static_cast<void*>(asyncContext.get()), &asyncContext->work);
if (status != napi_ok) {
result = nullptr;
} else {
status = napi_queue_async_work(env, asyncContext->work);
if (status == napi_ok) {
asyncContext.release();
} else {
result = nullptr;
}
}
}
return result;
}
} // namespace AudioStandard
} // namespace OHOS

3
frameworks/native/audiocapturer/include/audio_capturer_private.h
View File

@ -16,8 +16,8 @@
#ifndef AUDIO_CAPTURER_PRIVATE_H
#define AUDIO_CAPTURER_PRIVATE_H
#include "audio_capturer.h"
#include "audio_stream.h"
#include "audio_capturer_proxy_obj.h"
namespace OHOS {
namespace AudioStandard {
@ -62,6 +62,7 @@ public:
private:
std::shared_ptr<AudioStreamCallback> audioStreamCallback_ = nullptr;
AppInfo appInfo_ = {};
std::shared_ptr<AudioCapturerProxyObj> capturerProxyObj_;
};
class AudioStreamCallbackCapturer : public AudioStreamCallback {

34
frameworks/native/audiocapturer/include/audio_capturer_proxy_obj.h Normal file
View File

@ -0,0 +1,34 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef AUDIO_CAPTURER_PROXY_OBJ_H
#define AUDIO_CAPTURER_PROXY_OBJ_H
#include "audio_capturer.h"
#include "audio_stream_manager.h"
namespace OHOS {
namespace AudioStandard {
class AudioCapturerProxyObj : public AudioClientTracker {
public:
virtual ~AudioCapturerProxyObj() = default;
void SaveCapturerObj(const AudioCapturer *capturerObj);
private:
const AudioCapturer *capturer;
};
} // namespace AudioStandard
} // namespace OHOS
#endif // AUDIO_CAPTURER_PROXY_OBJ_H

24
frameworks/native/audiocapturer/src/audio_capturer.cpp
View File

@ -82,21 +82,25 @@ std::unique_ptr<AudioCapturer> AudioCapturer::Create(const AudioCapturerOptions
capturer->SetApplicationCachePath(cachePath);
}
if (capturer->SetParams(params) != SUCCESS) {
capturer = nullptr;
return nullptr;
}
capturer->capturerInfo_.sourceType = sourceType;
capturer->capturerInfo_.capturerFlags = capturerOptions.capturerInfo.capturerFlags;
if (capturer->SetParams(params) != SUCCESS) {
capturer = nullptr;
}
return capturer;
}
AudioCapturerPrivate::AudioCapturerPrivate(AudioStreamType audioStreamType, const AppInfo &appInfo)
{
audioStream_ = std::make_shared<AudioStream>(audioStreamType, AUDIO_MODE_RECORD);
appInfo_ = appInfo;
audioStream_ = std::make_shared<AudioStream>(audioStreamType, AUDIO_MODE_RECORD, appInfo_.appUid);
if (audioStream_) {
AUDIO_DEBUG_LOG("AudioCapturerPrivate::Audio stream created");
}
capturerProxyObj_ = std::make_shared<AudioCapturerProxyObj>();
if (!capturerProxyObj_) {
AUDIO_ERR_LOG("AudioCapturerProxyObj Memory Allocation Failed !!");
}
}
int32_t AudioCapturerPrivate::GetFrameCount(uint32_t &frameCount) const
@ -110,6 +114,10 @@ int32_t AudioCapturerPrivate::SetParams(const AudioCapturerParams params)
AUDIO_ERR_LOG("MICROPHONE permission denied for %{public}d", appInfo_.appTokenId);
return ERR_PERMISSION_DENIED;
}
const AudioCapturer *capturer = this;
capturerProxyObj_->SaveCapturerObj(capturer);
audioStream_->SetCapturerInfo(capturerInfo_);
AudioStreamParams audioStreamParams;
audioStreamParams.format = params.audioSampleFormat;
@ -126,7 +134,7 @@ int32_t AudioCapturerPrivate::SetParams(const AudioCapturerParams params)
}
audioStream_->SetClientID(appInfo_.appPid, appInfo_.appUid);
return audioStream_->SetAudioStreamInfo(audioStreamParams);
return audioStream_->SetAudioStreamInfo(audioStreamParams, capturerProxyObj_);
}
int32_t AudioCapturerPrivate::SetCapturerCallback(const std::shared_ptr<AudioCapturerCallback> &callback)

29
frameworks/native/audiocapturer/src/audio_capturer_proxy_obj.cpp Normal file
View File

@ -0,0 +1,29 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "audio_capturer_proxy_obj.h"
#include "audio_log.h"
using namespace std;
namespace OHOS {
namespace AudioStandard {
void AudioCapturerProxyObj::SaveCapturerObj(const AudioCapturer *capturerObj)
{
capturer = capturerObj;
}
} // namespace AudioStandard
} // namespace OHOS

3
frameworks/native/audiopolicy/BUILD.gn
View File

@ -46,10 +46,13 @@ config("audio_policy_public_config") {
ohos_shared_library("audio_policy_client") {
install_enable = true
sources = [
"//foundation/multimedia/audio_framework/services/src/audio_policy/client/audio_capturer_state_change_listener_stub.cpp",
"//foundation/multimedia/audio_framework/services/src/audio_policy/client/audio_client_tracker_callback_stub.cpp",
"//foundation/multimedia/audio_framework/services/src/audio_policy/client/audio_device_descriptor.cpp",
"//foundation/multimedia/audio_framework/services/src/audio_policy/client/audio_policy_manager.cpp",
"//foundation/multimedia/audio_framework/services/src/audio_policy/client/audio_policy_manager_listener_stub.cpp",
"//foundation/multimedia/audio_framework/services/src/audio_policy/client/audio_policy_proxy.cpp",
"//foundation/multimedia/audio_framework/services/src/audio_policy/client/audio_renderer_state_change_listener_stub.cpp",
"//foundation/multimedia/audio_framework/services/src/audio_policy/client/audio_ringermode_update_listener_stub.cpp",
"//foundation/multimedia/audio_framework/services/src/audio_policy/client/audio_volume_key_event_callback_stub.cpp",
]

34
frameworks/native/audiopolicy/include/audio_policy_manager.h
View File

@ -17,13 +17,20 @@
#define ST_AUDIO_POLICY_MANAGER_H
#include <cstdint>
#include "audio_capturer_state_change_listener_stub.h"
#include "audio_client_tracker_callback_stub.h"
#include "audio_info.h"
#include "audio_interrupt_callback.h"
#include "audio_policy_manager_listener_stub.h"
#include "audio_renderer_state_change_listener_stub.h"
#include "audio_ringermode_update_listener_stub.h"
#include "audio_system_manager.h"
#include "audio_volume_key_event_callback_stub.h"
#include "audio_system_manager.h"
#include "i_audio_volume_key_event_callback.h"
#include "i_standard_renderer_state_change_listener.h"
#include "i_standard_capturer_state_change_listener.h"
#include "i_standard_client_tracker.h"
namespace OHOS {
namespace AudioStandard {
@ -112,6 +119,27 @@ public:
int32_t ReconfigureAudioChannel(const uint32_t &count, DeviceType deviceType);
int32_t GetAudioLatencyFromXml();
int32_t RegisterAudioRendererEventListener(const int32_t clientUID,
const std::shared_ptr<AudioRendererStateChangeCallback> &callback);
int32_t UnregisterAudioRendererEventListener(const int32_t clientUID);
int32_t RegisterAudioCapturerEventListener(const int32_t clientUID,
const std::shared_ptr<AudioCapturerStateChangeCallback> &callback);
int32_t UnregisterAudioCapturerEventListener(const int32_t clientUID);
int32_t RegisterTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo,
const std::shared_ptr<AudioClientTracker> &clientTrackerObj);
int32_t UpdateTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo);
int32_t GetCurrentRendererChangeInfos(
std::vector<std::unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos);
int32_t GetCurrentCapturerChangeInfos(
std::vector<std::unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos);
private:
AudioPolicyManager()
{
@ -123,9 +151,13 @@ private:
sptr<AudioPolicyManagerListenerStub> listenerStub_ = nullptr;
std::mutex listenerStubMutex_;
std::mutex volumeCallbackMutex_;
std::mutex stateChangelistenerStubMutex_;
std::mutex clientTrackerStubMutex_;
sptr<AudioVolumeKeyEventCallbackStub> volumeKeyEventListenerStub_ = nullptr;
sptr<AudioRingerModeUpdateListenerStub> ringerModelistenerStub_ = nullptr;
sptr<AudioRendererStateChangeListenerStub> rendererStateChangelistenerStub_ = nullptr;
sptr<AudioCapturerStateChangeListenerStub> capturerStateChangelistenerStub_ = nullptr;
sptr<AudioClientTrackerCallbackStub> clientTrackerCbStub_ = nullptr;
static bool serverConnected;
void RegisterAudioPolicyServerDeathRecipient();
void AudioPolicyServerDied(pid_t pid);

2
frameworks/native/audiorenderer/include/audio_renderer_private.h
View File

@ -19,6 +19,7 @@
#include "audio_interrupt_callback.h"
#include "audio_renderer.h"
#include "audio_stream.h"
#include "audio_renderer_proxy_obj.h"
namespace OHOS {
namespace AudioStandard {
@ -83,6 +84,7 @@ private:
{STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, AudioStreamType::STREAM_DEFAULT, 0};
uint32_t sessionID_ = INVALID_SESSION_ID;
AudioStandard::InterruptMode mode_ = AudioStandard::InterruptMode::SHARE_MODE;
std::shared_ptr<AudioRendererProxyObj> rendererProxyObj_;
};
class AudioInterruptCallbackImpl : public AudioInterruptCallback {

34
frameworks/native/audiorenderer/include/audio_renderer_proxy_obj.h Normal file
View File

@ -0,0 +1,34 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef AUDIO_RENDERER_PROXY_OBJ_H
#define AUDIO_RENDERER_PROXY_OBJ_H
#include "audio_renderer.h"
#include "audio_stream_manager.h"
namespace OHOS {
namespace AudioStandard {
class AudioRendererProxyObj : public AudioClientTracker {
public:
virtual ~AudioRendererProxyObj() = default;
void SaveRendererObj(const AudioRenderer *rendererObj);
private:
const AudioRenderer *renderer;
};
} // namespace AudioStandard
} // namespace OHOS
#endif // AUDIO_RENDERER_PROXY_OBJ_H

20
frameworks/native/audiorenderer/src/audio_renderer.cpp
View File

@ -104,8 +104,20 @@ std::unique_ptr<AudioRenderer> AudioRenderer::Create(const std::string cachePath
AudioRendererPrivate::AudioRendererPrivate(AudioStreamType audioStreamType, const AppInfo &appInfo)
{
audioStream_ = std::make_shared<AudioStream>(audioStreamType, AUDIO_MODE_PLAYBACK);
appInfo_ = appInfo;
audioStream_ = std::make_shared<AudioStream>(audioStreamType, AUDIO_MODE_PLAYBACK, appInfo_.appUid);
if (audioStream_) {
AUDIO_DEBUG_LOG("AudioRendererPrivate::Audio stream created");
// Initializing with default values
rendererInfo_.contentType = CONTENT_TYPE_MUSIC;
rendererInfo_.streamUsage = STREAM_USAGE_MEDIA;
}
rendererProxyObj_ = std::make_shared<AudioRendererProxyObj>();
if (!rendererProxyObj_) {
AUDIO_ERR_LOG("AudioRendererProxyObj Memory Allocation Failed !!");
}
audioInterrupt_.streamType = audioStreamType;
if (AudioRendererPrivate::sharedInterrupts_.find(getpid()) == AudioRendererPrivate::sharedInterrupts_.end()) {
std::map<AudioStreamType, AudioInterrupt> interrupts;
@ -150,6 +162,10 @@ int32_t AudioRendererPrivate::GetLatency(uint64_t &latency) const
int32_t AudioRendererPrivate::SetParams(const AudioRendererParams params)
{
AudioStreamParams audioStreamParams;
AudioRenderer *renderer = this;
rendererProxyObj_->SaveRendererObj(renderer);
audioStream_->SetRendererInfo(rendererInfo_);
audioStreamParams.format = params.sampleFormat;
audioStreamParams.samplingRate = params.sampleRate;
audioStreamParams.channels = params.channelCount;
@ -164,7 +180,7 @@ int32_t AudioRendererPrivate::SetParams(const AudioRendererParams params)
}
audioStream_->SetClientID(appInfo_.appPid, appInfo_.appUid);
int32_t ret = audioStream_->SetAudioStreamInfo(audioStreamParams);
int32_t ret = audioStream_->SetAudioStreamInfo(audioStreamParams, rendererProxyObj_);
AUDIO_INFO_LOG("AudioRendererPrivate::SetParams SetAudioStreamInfo Success");
if (ret) {

29
frameworks/native/audiorenderer/src/audio_renderer_proxy_obj.cpp Normal file
View File

@ -0,0 +1,29 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "audio_renderer_proxy_obj.h"
#include "audio_log.h"
using namespace std;
namespace OHOS {
namespace AudioStandard {
void AudioRendererProxyObj::SaveRendererObj(const AudioRenderer *rendererObj)
{
renderer = rendererObj;
}
} // namespace AudioStandard
} // namespace OHOS

20
frameworks/native/audiostream/include/audio_stream.h
View File

@ -15,29 +15,27 @@
#ifndef AUDIO_STREAM_H
#define AUDIO_STREAM_H
#include "audio_renderer.h"
#include "audio_session.h"
#include "timestamp.h"
#include "audio_stream_tracker.h"
namespace OHOS {
namespace AudioStandard {
static constexpr int32_t MAX_NUM_BUFFERS = 3;
enum AudioMode {
AUDIO_MODE_PLAYBACK,
AUDIO_MODE_RECORD
};
class AudioStream : public AudioSession {
public:
AudioStream(AudioStreamType eStreamType, AudioMode eMode);
AudioStream(AudioStreamType eStreamType, AudioMode eMode, int32_t appUid);
virtual ~AudioStream();
int32_t SetAudioStreamInfo(const AudioStreamParams info);
void SetRendererInfo(const AudioRendererInfo &rendererInfo);
void SetCapturerInfo(const AudioCapturerInfo &capturerInfo);
int32_t SetAudioStreamInfo(const AudioStreamParams info,
const std::shared_ptr<AudioClientTracker> &proxyObj);
int32_t GetAudioStreamInfo(AudioStreamParams &info);
bool VerifyClientPermission(const std::string &permissionName, uint32_t appTokenId);
int32_t GetAudioSessionID(uint32_t &sessionID) const;
int32_t GetAudioSessionID(uint32_t &sessionID);
State GetState();
bool GetAudioTime(Timestamp &timestamp, Timestamp::Timestampbase base);
int32_t GetBufferSize(size_t &bufferSize) const;
@ -97,6 +95,10 @@ private:
bool isReadyToRead_;
void WriteBuffers();
void ReadBuffers();
std::unique_ptr<AudioStreamTracker> audioStreamTracker_;
AudioRendererInfo rendererInfo_;
AudioCapturerInfo capturerInfo_;
uint32_t sessionId_;
static const std::map<std::pair<ContentType, StreamUsage>, AudioStreamType> streamTypeMap_;
static std::map<std::pair<ContentType, StreamUsage>, AudioStreamType> CreateStreamMap();

5
interfaces/inner_api/native/audiocapturer/BUILD.gn
View File

@ -43,7 +43,10 @@ ohos_shared_library("audio_capturer") {
configs = [ ":audio_capturer_config" ]
sources = [ "//foundation/multimedia/audio_framework/frameworks/native/audiocapturer/src/audio_capturer.cpp" ]
sources = [
"//foundation/multimedia/audio_framework/frameworks/native/audiocapturer/src/audio_capturer.cpp",
"//foundation/multimedia/audio_framework/frameworks/native/audiocapturer/src/audio_capturer_proxy_obj.cpp",
]
deps = [ "//foundation/multimedia/audio_framework/interfaces/inner_api/native/audiomanager:audio_client" ]

20
interfaces/inner_api/native/audiocapturer/include/audio_capturer.h
View File

@ -41,26 +41,6 @@ struct AudioCapturerParams {
AudioSampleFormat audioSampleFormat = SAMPLE_S16LE;
};
/**
* @brief Enumerates the capturing states of the current device.
*/
enum CapturerState {
/** Capturer INVALID state */
CAPTURER_INVALID = -1,
/** Create new capturer instance */
CAPTURER_NEW,
/** Capturer Prepared state */
CAPTURER_PREPARED,
/** Capturer Running state */
CAPTURER_RUNNING,
/** Capturer Stopped state */
CAPTURER_STOPPED,
/** Capturer Released state */
CAPTURER_RELEASED,
/** Capturer Paused state */
CAPTURER_PAUSED
};
class AudioCapturerCallback {
public:
virtual ~AudioCapturerCallback() = default;

3
interfaces/inner_api/native/audiocommon/include/audio_errors.h
View File

@ -121,6 +121,9 @@ const int32_t ERR_INCORRECT_MODE = BASE_AUDIO_ERR_OFFSET - 19;
/** incorrect render/capture mode */
const int32_t ERR_PERMISSION_DENIED = BASE_AUDIO_ERR_OFFSET - 20;
/** Memory alloc failed */
const int32_t ERR_MEMORY_ALLOC_FAILED = BASE_AUDIO_ERR_OFFSET - 21;
/** Unknown error */
const int32_t ERR_UNKNOWN = BASE_AUDIO_ERR_OFFSET - 200;
} // namespace AudioStandard

64
interfaces/inner_api/native/audiocommon/include/audio_info.h
View File

@ -596,6 +596,70 @@ enum AudioServiceIndex {
HDI_SERVICE_INDEX = 0,
AUDIO_SERVICE_INDEX
};
/**
* @brief Enumerates the rendering states of the current device.
*/
enum RendererState {
/** INVALID state */
RENDERER_INVALID = -1,
/** Create New Renderer instance */
RENDERER_NEW,
/** Reneder Prepared state */
RENDERER_PREPARED,
/** Rendere Running state */
RENDERER_RUNNING,
/** Renderer Stopped state */
RENDERER_STOPPED,
/** Renderer Released state */
RENDERER_RELEASED,
/** Renderer Paused state */
RENDERER_PAUSED
};
/**
* @brief Enumerates the capturing states of the current device.
*/
enum CapturerState {
/** Capturer INVALID state */
CAPTURER_INVALID = -1,
/** Create new capturer instance */
CAPTURER_NEW,
/** Capturer Prepared state */
CAPTURER_PREPARED,
/** Capturer Running state */
CAPTURER_RUNNING,
/** Capturer Stopped state */
CAPTURER_STOPPED,
/** Capturer Released state */
CAPTURER_RELEASED,
/** Capturer Paused state */
CAPTURER_PAUSED
};
enum AudioMode {
AUDIO_MODE_PLAYBACK,
AUDIO_MODE_RECORD
};
struct AudioRendererChangeInfo {
int32_t clientUID;
int32_t sessionId;
AudioRendererInfo rendererInfo;
RendererState rendererState;
};
struct AudioCapturerChangeInfo {
int32_t clientUID;
int32_t sessionId;
AudioCapturerInfo capturerInfo;
CapturerState capturerState;
};
struct AudioStreamChangeInfo {
AudioRendererChangeInfo audioRendererChangeInfo;
AudioCapturerChangeInfo audioCapturerChangeInfo;
};
} // namespace AudioStandard
} // namespace OHOS
#endif // AUDIO_INFO_H

77
interfaces/inner_api/native/audiocommon/include/audio_stream_event_dispatcher.h Normal file
View File

@ -0,0 +1,77 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef AUDIO_STREAM_EVENT_DISPATCHER_INFO_H
#define AUDIO_STREAM_EVENT_DISPATCHER_INFO_H
#include <cstdlib>
#include <map>
#include <queue>
#include <stdio.h>
#include <thread>
#include <unordered_map>
#include <vector>
#include "audio_log.h"
#include "audio_stream_manager.h"
#include "iremote_proxy.h"
namespace OHOS {
namespace AudioStandard {
using namespace std;
struct StreamStateChangeRequest {
AudioMode mode;
std::vector<std::unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
std::vector<std::unique_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
};
class AudioStreamEventDispatcher {
public:
static AudioStreamEventDispatcher& GetAudioStreamEventDispatcher()
{
static AudioStreamEventDispatcher audioStreamEventDispatcher;
return audioStreamEventDispatcher;
}
AudioStreamEventDispatcher();
~AudioStreamEventDispatcher();
void addRendererListener(int32_t clientUID,
const std::shared_ptr<AudioRendererStateChangeCallback> &callback);
void removeRendererListener(int32_t clientUID);
void addCapturerListener(int32_t clientUID,
const std::shared_ptr<AudioCapturerStateChangeCallback> &callback);
void removeCapturerListener(int32_t clientUID);
void SendRendererInfoEventToDispatcher(AudioMode mode,
std::vector<std::unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos);
void SendCapturerInfoEventToDispatcher(AudioMode mode,
std::vector<std::unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos);
void HandleCapturerStreamStateChange(const unique_ptr<StreamStateChangeRequest> &streamStateChangeRequest);
void HandleRendererStreamStateChange(const unique_ptr<StreamStateChangeRequest> &streamStateChangeRequest);
void HandleStreamStateChange();
void DispatcherEvent();
private:
std::unordered_map<int32_t, std::shared_ptr<AudioRendererStateChangeCallback>> rendererCBMap_;
std::unordered_map<int32_t, std::shared_ptr<AudioCapturerStateChangeCallback>> capturerCBMap_;
std::queue<unique_ptr<StreamStateChangeRequest>> streamStateChangeQueue_;
std::unique_ptr<StreamStateChangeRequest> request;
uint32_t activeThread_;
static constexpr uint32_t MAX_THREAD = 1;
};
} // namespace AudioStandard
} // namespace OHOS
#endif // AUDIO_STREAM_EVENT_DISPATCHER_INFO_H

2
interfaces/inner_api/native/audiomanager/BUILD.gn
View File

@ -65,6 +65,8 @@ ohos_shared_library("audio_client") {
"//foundation/multimedia/audio_framework/services/src/audio_service/client/audio_service_client.cpp",
"//foundation/multimedia/audio_framework/services/src/audio_service/client/audio_session.cpp",
"//foundation/multimedia/audio_framework/services/src/audio_service/client/audio_stream.cpp",
"//foundation/multimedia/audio_framework/services/src/audio_service/client/audio_stream_manager.cpp",
"//foundation/multimedia/audio_framework/services/src/audio_service/client/audio_stream_tracker.cpp",
"//foundation/multimedia/audio_framework/services/src/audio_service/client/audio_system_manager.cpp",
]

73
interfaces/inner_api/native/audiomanager/include/audio_stream_manager.h Normal file
View File

@ -0,0 +1,73 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ST_AUDIO_STREAM_MANAGER_H
#define ST_AUDIO_STREAM_MANAGER_H
#include <iostream>
#include "audio_info.h"
namespace OHOS {
namespace AudioStandard {
class AudioRendererStateChangeCallback {
public:
virtual ~AudioRendererStateChangeCallback() = default;
/**
* Called when the renderer state changes
*
* @param rendererChangeInfo Contains the renderer state information.
*/
virtual void OnRendererStateChange(
const std::vector<std::unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos) = 0;
};
class AudioCapturerStateChangeCallback {
public:
virtual ~AudioCapturerStateChangeCallback() = default;
/**
* Called when the capturer state changes
*
* @param capturerChangeInfo Contains the renderer state information.
*/
virtual void OnCapturerStateChange(
const std::vector<std::unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos) = 0;
};
class AudioClientTracker {
public:
virtual ~AudioClientTracker() = default;
};
class AudioStreamManager {
public:
AudioStreamManager() = default;
virtual ~AudioStreamManager() = default;
static AudioStreamManager *GetInstance();
int32_t RegisterAudioRendererEventListener(const int32_t clientUID,
const std::shared_ptr<AudioRendererStateChangeCallback> &callback);
int32_t UnregisterAudioRendererEventListener(const int32_t clientUID);
int32_t RegisterAudioCapturerEventListener(const int32_t clientUID,
const std::shared_ptr<AudioCapturerStateChangeCallback> &callback);
int32_t UnregisterAudioCapturerEventListener(const int32_t clientUID);
int32_t GetCurrentRendererChangeInfos(
std::vector<std::unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos);
int32_t GetCurrentCapturerChangeInfos(
std::vector<std::unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos);
};
} // namespace AudioStandard
} // namespace OHOS
#endif // ST_AUDIO_STREAM_MANAGER_H

41
interfaces/inner_api/native/audiomanager/include/audio_stream_tracker.h Normal file
View File

@ -0,0 +1,41 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef AUDIO_STREAM_TRACKER_H
#define AUDIO_STREAM_TRACKER_H
#include "audio_service_client.h"
#include "audio_log.h"
namespace OHOS {
namespace AudioStandard {
class AudioStreamTracker {
public:
AudioStreamTracker(AudioMode mode, int32_t clientUID);
virtual ~AudioStreamTracker();
void RegisterTracker(const int32_t sessionId, const State state,
const AudioRendererInfo &rendererInfo, const AudioCapturerInfo &capturerInfo,
const std::shared_ptr<AudioClientTracker> &clientTrackerObj);
void UpdateTracker(const int32_t sessionId, const State state,
const AudioRendererInfo &rendererInfo, const AudioCapturerInfo &capturerInfo);
private:
int32_t clientUID_ = -1;
AudioMode eMode_; // to determine renderer or capturer
State state_;
};
} // namespace AudioStandard
} // namespace OHOS
#endif // AUDIO_STREAM_TRACKER_H

1
interfaces/inner_api/native/audiomanager/include/audio_system_manager.h
View File

@ -239,6 +239,7 @@ public:
bool RequestIndependentInterrupt(FocusType focusType);
bool AbandonIndependentInterrupt(FocusType focusType);
int32_t GetAudioLatencyFromXml() const;
private:
AudioSystemManager();
virtual ~AudioSystemManager();

5
interfaces/inner_api/native/audiorenderer/BUILD.gn
View File

@ -42,7 +42,10 @@ ohos_shared_library("audio_renderer") {
configs = [ ":audio_renderer_config" ]
sources = [ "//foundation/multimedia/audio_framework/frameworks/native/audiorenderer/src/audio_renderer.cpp" ]
sources = [
"//foundation/multimedia/audio_framework/frameworks/native/audiorenderer/src/audio_renderer.cpp",
"//foundation/multimedia/audio_framework/frameworks/native/audiorenderer/src/audio_renderer_proxy_obj.cpp",
]
deps = [
"//foundation/multimedia/audio_framework/frameworks/native/audiopolicy:audio_policy_client",

20
interfaces/inner_api/native/audiorenderer/include/audio_renderer.h
View File

@ -38,26 +38,6 @@ struct AudioRendererParams {
AudioEncodingType encodingType = ENCODING_PCM;
};
/**
* @brief Enumerates the rendering states of the current device.
*/
enum RendererState {
/** INVALID state */
RENDERER_INVALID = -1,
/** Create New Renderer instance */
RENDERER_NEW,
/** Reneder Prepared state */
RENDERER_PREPARED,
/** Rendere Running state */
RENDERER_RUNNING,
/** Renderer Stopped state */
RENDERER_STOPPED,
/** Renderer Released state */
RENDERER_RELEASED,
/** Renderer Paused state */
RENDERER_PAUSED
};
class AudioRendererCallback {
public:
virtual ~AudioRendererCallback() = default;

5
interfaces/kits/js/audio_manager/BUILD.gn
View File

@ -35,8 +35,10 @@ ohos_shared_library("audio") {
"//foundation/multimedia/audio_framework/frameworks/js/napi/audio_capturer/include",
"//foundation/multimedia/audio_framework/frameworks/js/napi/audio_common/include",
"//foundation/multimedia/audio_framework/frameworks/js/napi/audio_manager/include",
"//foundation/multimedia/audio_framework/frameworks/js/napi/audio_stream_manager/include",
"//foundation/multimedia/audio_framework/frameworks/js/napi/audio_renderer/include",
"//foundation/multimedia/audio_framework/interfaces/kits/js/audio_manager/include",
"//foundation/multimedia/audio_framework/interfaces/kits/js/audio_stream_manager/include",
"//foundation/multimedia/audio_framework/interfaces/kits/js/audio_capturer/include",
"//foundation/multimedia/audio_framework/interfaces/kits/js/audio_renderer/include",
"//foundation/multimedia/audio_framework/interfaces/kits/js/ringtone_manager/include",
@ -53,15 +55,18 @@ ohos_shared_library("audio") {
"//foundation/multimedia/audio_framework/frameworks/js/napi/audio_capturer/src/capturer_period_position_callback_napi.cpp",
"//foundation/multimedia/audio_framework/frameworks/js/napi/audio_capturer/src/capturer_position_callback_napi.cpp",
"//foundation/multimedia/audio_framework/frameworks/js/napi/audio_common/src/audio_common_napi.cpp",
"//foundation/multimedia/audio_framework/frameworks/js/napi/audio_manager/src/audio_capturer_state_callback_napi.cpp",
"//foundation/multimedia/audio_framework/frameworks/js/napi/audio_manager/src/audio_manager_callback_napi.cpp",
"//foundation/multimedia/audio_framework/frameworks/js/napi/audio_manager/src/audio_manager_interrupt_callback_napi.cpp",
"//foundation/multimedia/audio_framework/frameworks/js/napi/audio_manager/src/audio_manager_napi.cpp",
"//foundation/multimedia/audio_framework/frameworks/js/napi/audio_manager/src/audio_renderer_state_callback_napi.cpp",
"//foundation/multimedia/audio_framework/frameworks/js/napi/audio_manager/src/audio_ringermode_callback_napi.cpp",
"//foundation/multimedia/audio_framework/frameworks/js/napi/audio_manager/src/audio_volume_key_event_napi.cpp",
"//foundation/multimedia/audio_framework/frameworks/js/napi/audio_renderer/src/audio_renderer_callback_napi.cpp",
"//foundation/multimedia/audio_framework/frameworks/js/napi/audio_renderer/src/audio_renderer_napi.cpp",
"//foundation/multimedia/audio_framework/frameworks/js/napi/audio_renderer/src/renderer_period_position_callback_napi.cpp",
"//foundation/multimedia/audio_framework/frameworks/js/napi/audio_renderer/src/renderer_position_callback_napi.cpp",
"//foundation/multimedia/audio_framework/frameworks/js/napi/audio_stream_manager/src/audio_stream_mgr_napi.cpp",
"//foundation/multimedia/audio_framework/frameworks/js/napi/ringtone_manager/src/audio_renderer_info_napi.cpp",
"//foundation/multimedia/audio_framework/frameworks/js/napi/ringtone_manager/src/ringtone_options_napi.cpp",
"//foundation/multimedia/audio_framework/frameworks/js/napi/ringtone_manager/src/ringtone_player_napi.cpp",

3
interfaces/kits/js/audio_manager/include/audio_manager_napi.h
View File

@ -22,6 +22,7 @@
#include "audio_system_manager.h"
#include "napi/native_api.h"
#include "napi/native_node_api.h"
#include "audio_stream_mgr_napi.h"
namespace OHOS {
namespace AudioStandard {
@ -99,6 +100,8 @@ private:
static napi_value CreateAudioSceneObject(napi_env env);
static napi_value RequestIndependentInterrupt(napi_env env, napi_callback_info info);
static napi_value AbandonIndependentInterrupt(napi_env env, napi_callback_info info);
static napi_value GetStreamManager(napi_env env, napi_callback_info info);
static void GetStreamMgrAsyncCallbackComplete(napi_env env, napi_status status, void *data);
template<typename T> static napi_value CreatePropertyBase(napi_env env, T& t_map, napi_ref ref);

61
interfaces/kits/js/audio_stream_manager/include/audio_stream_mgr_napi.h Normal file
View File

@ -0,0 +1,61 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef AUDIO_STREAM_MGR_NAPI_H_
#define AUDIO_STREAM_MGR_NAPI_H_
#include "audio_renderer.h"
#include "napi/native_api.h"
#include "napi/native_node_api.h"
#include "audio_stream_manager.h"
namespace OHOS {
namespace AudioStandard {
static const std::string AUDIO_STREAM_MGR_NAPI_CLASS_NAME = "AudioStreamManager";
class AudioStreamMgrNapi {
public:
AudioStreamMgrNapi();
~AudioStreamMgrNapi();
static napi_value Init(napi_env env, napi_value exports);
static napi_value CreateStreamManagerWrapper(napi_env env);
static napi_value GetStreamManager(napi_env env, napi_callback_info info);
private:
static napi_value GetCurrentAudioRendererInfos(napi_env env, napi_callback_info info);
static napi_value GetCurrentAudioCapturerInfos(napi_env env, napi_callback_info info);
static napi_value On(napi_env env, napi_callback_info info);
static napi_value Off(napi_env env, napi_callback_info info);
static void RegisterCallback(napi_env env, napi_value jsThis,
napi_value* args, const std::string& cbName);
static void RegisterCapturerStateChangeCallback(napi_env env, napi_value* args,
const std::string& cbName, AudioStreamMgrNapi *streamMgrNapi);
static void RegisterRendererStateChangeCallback(napi_env env, napi_value* args,
const std::string& cbName, AudioStreamMgrNapi *streamMgrNapi);
static void UnregisterCallback(napi_env env, napi_value jsThis, const std::string& cbName);
static napi_value Construct(napi_env env, napi_callback_info info);
static void Destructor(napi_env env, void *nativeObject, void *finalize_hint);
napi_env env_;
napi_ref wrapper_;
AudioStreamManager *audioStreamMngr_;
int32_t cachedClientId = -1;
std::shared_ptr<AudioRendererStateChangeCallback> rendererStateChangeCallbackNapi_ = nullptr;
std::shared_ptr<AudioCapturerStateChangeCallback> capturerStateChangeCallbackNapi_ = nullptr;
};
} // namespace AudioStandard
} // namespace OHOS
#endif /* AUDIO_STREAM_MGR_NAPI_H_ */

5
services/BUILD.gn
View File

@ -165,10 +165,15 @@ ohos_shared_library("audio_policy_service") {
install_enable = true
sources = [
"//foundation/multimedia/audio_framework/services/src/audio_policy/client/audio_device_descriptor.cpp",
"//foundation/multimedia/audio_framework/services/src/audio_policy/server/audio_capturer_state_change_listener_proxy.cpp",
"//foundation/multimedia/audio_framework/services/src/audio_policy/server/audio_client_tracker_callback_proxy.cpp",
"//foundation/multimedia/audio_framework/services/src/audio_policy/server/audio_policy_manager_listener_proxy.cpp",
"//foundation/multimedia/audio_framework/services/src/audio_policy/server/audio_policy_manager_stub.cpp",
"//foundation/multimedia/audio_framework/services/src/audio_policy/server/audio_policy_server.cpp",
"//foundation/multimedia/audio_framework/services/src/audio_policy/server/audio_renderer_state_change_listener_proxy.cpp",
"//foundation/multimedia/audio_framework/services/src/audio_policy/server/audio_ringermode_update_listener_proxy.cpp",
"//foundation/multimedia/audio_framework/services/src/audio_policy/server/audio_stream_collector.cpp",
"//foundation/multimedia/audio_framework/services/src/audio_policy/server/audio_stream_event_dispatcher.cpp",
"//foundation/multimedia/audio_framework/services/src/audio_policy/server/audio_volume_key_event_callback_proxy.cpp",
"//foundation/multimedia/audio_framework/services/src/audio_policy/server/service/audio_policy_service.cpp",
"//foundation/multimedia/audio_framework/services/src/audio_policy/server/service/config/audio_focus_parser.cpp",

41
services/include/audio_policy/client/audio_capturer_state_change_listener_stub.h Normal file
View File

@ -0,0 +1,41 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef AUDIO_CAPTURER_STATE_CHANGE_LISTENER_STUB_H
#define AUDIO_CAPTURER_STATE_CHANGE_LISTENER_STUB_H
#include "audio_stream_manager.h"
#include "i_standard_capturer_state_change_listener.h"
namespace OHOS {
namespace AudioStandard {
class AudioCapturerStateChangeListenerStub : public IRemoteStub<IStandardCapturerStateChangeListener> {
public:
AudioCapturerStateChangeListenerStub();
virtual ~AudioCapturerStateChangeListenerStub();
int OnRemoteRequest(uint32_t code, MessageParcel &data,
MessageParcel &reply, MessageOption &option) override;
void OnCapturerStateChange(
const std::vector<std::unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos) override;
void SetCallback(const std::weak_ptr<AudioCapturerStateChangeCallback> &callback);
private:
void ReadAudioCapturerChangeInfo(MessageParcel &data,
std::unique_ptr<AudioCapturerChangeInfo> &capturerChangeInfo);
std::weak_ptr<AudioCapturerStateChangeCallback> callback_;
};
} // namespace AudioStandard
} // namespace OHOS
#endif // AUDIO_CAPTURER_STATE_CHANGE_LISTENER_STUB_H

37
services/include/audio_policy/client/audio_client_tracker_callback_stub.h Normal file
View File

@ -0,0 +1,37 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ST_AUDIO_CLIENT_TRACKER_CALLBACK_STUB_H
#define ST_AUDIO_CLIENT_TRACKER_CALLBACK_STUB_H
#include "audio_stream_manager.h"
#include "i_standard_client_tracker.h"
namespace OHOS {
namespace AudioStandard {
class AudioClientTrackerCallbackStub : public IRemoteStub<IStandardClientTracker> {
public:
AudioClientTrackerCallbackStub();
virtual ~AudioClientTrackerCallbackStub();
virtual int OnRemoteRequest(uint32_t code, MessageParcel &data,
MessageParcel &reply, MessageOption &option) override;
void SetClientTrackerCallback(const std::weak_ptr<AudioClientTracker> &callback);
private:
std::weak_ptr<AudioClientTracker> callback_;
};
} // namespace AudioStandard
} // namespace OHOS
#endif // ST_AUDIO_CLIENT_TRACKER_CALLBACK_STUB_H

20
services/include/audio_policy/client/audio_policy_base.h
View File

@ -95,6 +95,26 @@ public:
virtual int32_t ReconfigureAudioChannel(const uint32_t &count, DeviceType deviceType) = 0;
virtual int32_t GetAudioLatencyFromXml() = 0;
virtual int32_t RegisterAudioRendererEventListener(int32_t clientUID, const sptr<IRemoteObject> &object) = 0;
virtual int32_t UnregisterAudioRendererEventListener(int32_t clientUID) = 0;
virtual int32_t RegisterAudioCapturerEventListener(int32_t clientUID, const sptr<IRemoteObject> &object) = 0;
virtual int32_t UnregisterAudioCapturerEventListener(int32_t clientUID) = 0;
virtual int32_t RegisterTracker(AudioMode &mode,
AudioStreamChangeInfo &streamChangeInfo, const sptr<IRemoteObject> &object) = 0;
virtual int32_t UpdateTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo) = 0;
virtual int32_t GetCurrentRendererChangeInfos(
std::vector<std::unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos) = 0;
virtual int32_t GetCurrentCapturerChangeInfos(
std::vector<std::unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos) = 0;
public:
DECLARE_INTERFACE_DESCRIPTOR(u"IAudioPolicy");
};

9
services/include/audio_policy/client/audio_policy_manager_stub.h
View File

@ -62,6 +62,15 @@ private:
void VerifyClientPermissionInternal(MessageParcel &data, MessageParcel &reply);
void ReconfigureAudioChannelInternal(MessageParcel &data, MessageParcel &reply);
void GetAudioLatencyFromXmlInternal(MessageParcel &data, MessageParcel &reply);
void ReadStreamChangeInfo(MessageParcel &data, const AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo);
void RegisterAudioRendererEventListenerInternal(MessageParcel &data, MessageParcel &reply);
void UnregisterAudioRendererEventListenerInternal(MessageParcel &data, MessageParcel &reply);
void RegisterAudioCapturerEventListenerInternal(MessageParcel &data, MessageParcel &reply);
void UnregisterAudioCapturerEventListenerInternal(MessageParcel &data, MessageParcel &reply);
void RegisterTrackerInternal(MessageParcel &data, MessageParcel &reply);
void UpdateTrackerInternal(MessageParcel &data, MessageParcel &reply);
void GetRendererChangeInfosInternal(MessageParcel &data, MessageParcel &reply);
void GetCapturerChangeInfosInternal(MessageParcel &data, MessageParcel &reply);
};
} // namespace AudioStandard
} // namespace OHOS

28
services/include/audio_policy/client/audio_policy_proxy.h
View File

@ -18,6 +18,8 @@
#include "iremote_proxy.h"
#include "audio_policy_base.h"
#include "audio_info.h"
#include "audio_errors.h"
namespace OHOS {
namespace AudioStandard {
@ -91,11 +93,37 @@ public:
int32_t ReconfigureAudioChannel(const uint32_t &count, DeviceType deviceType) override;
int32_t GetAudioLatencyFromXml() override;
int32_t RegisterAudioRendererEventListener(int32_t clientUID, const sptr<IRemoteObject> &object) override;
int32_t UnregisterAudioRendererEventListener(int32_t clientUID) override;
int32_t RegisterAudioCapturerEventListener(int32_t clientUID, const sptr<IRemoteObject> &object) override;
int32_t UnregisterAudioCapturerEventListener(int32_t clientUID) override;
int32_t RegisterTracker(AudioMode &mode,
AudioStreamChangeInfo &streamChangeInfo, const sptr<IRemoteObject> &object) override;
int32_t UpdateTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo) override;
int32_t GetCurrentRendererChangeInfos(
std::vector<std::unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos) override;
int32_t GetCurrentCapturerChangeInfos(
std::vector<std::unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos) override;
private:
static inline BrokerDelegator<AudioPolicyProxy> mDdelegator;
void WriteAudioInteruptParams(MessageParcel &parcel, const AudioInterrupt &audioInterrupt);
void WriteAudioManagerInteruptParams(MessageParcel &parcel, const AudioInterrupt &audioInterrupt);
void ReadAudioInterruptParams(MessageParcel &reply, AudioInterrupt &audioInterrupt);
void WriteStreamChangeInfo(MessageParcel &data, const AudioMode &mode,
const AudioStreamChangeInfo &streamChangeInfo);
void ReadAudioRendererChangeInfo(MessageParcel &reply,
std::unique_ptr<AudioRendererChangeInfo> &rendererChangeInfo);
void ReadAudioCapturerChangeInfo(MessageParcel &reply,
std::unique_ptr<AudioCapturerChangeInfo> &capturerChangeInfo);
};
} // namespace AudioStandard
} // namespace OHOS

41
services/include/audio_policy/client/audio_renderer_state_change_listener_stub.h Normal file
View File

@ -0,0 +1,41 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef AUDIO_RENDERER_STATE_CHANGE_LISTENER_STUB_H
#define AUDIO_RENDERER_STATE_CHANGE_LISTENER_STUB_H
#include "audio_stream_manager.h"
#include "i_standard_renderer_state_change_listener.h"
namespace OHOS {
namespace AudioStandard {
class AudioRendererStateChangeListenerStub : public IRemoteStub<IStandardRendererStateChangeListener> {
public:
AudioRendererStateChangeListenerStub();
virtual ~AudioRendererStateChangeListenerStub();
int OnRemoteRequest(uint32_t code, MessageParcel &data,
MessageParcel &reply, MessageOption &option) override;
void OnRendererStateChange(const std::vector<std::unique_ptr<AudioRendererChangeInfo>>
&audioRendererChangeInfos) override;
void SetCallback(const std::weak_ptr<AudioRendererStateChangeCallback> &callback);
private:
void ReadAudioRendererChangeInfo(MessageParcel &data,
std::unique_ptr<AudioRendererChangeInfo> &rendererChangeInfo);
std::weak_ptr<AudioRendererStateChangeCallback> callback_;
};
} // namespace AudioStandard
} // namespace OHOS
#endif // AUDIO_RENDERER_STATE_CHANGE_LISTENER_STUB_H

10
services/include/audio_policy/common/audio_policy_types.h
View File

@ -53,7 +53,15 @@ enum AudioPolicyCommand {
UNSET_DEVICE_CHANGE_CALLBACK,
QUERY_PERMISSION,
RECONFIGURE_CHANNEL,
GET_AUDIO_LATENCY
GET_AUDIO_LATENCY,
REGISTER_PLAYBACK_EVENT,
UNREGISTER_PLAYBACK_EVENT,
REGISTER_RECORDING_EVENT,
UNREGISTER_RECORDING_EVENT,
REGISTER_TRACKER,
UPDATE_TRACKER,
GET_RENDERER_CHANGE_INFOS,
GET_CAPTURER_CHANGE_INFOS,
};
} // namespace AudioStandard
} // namespace OHOS

41
services/include/audio_policy/common/i_standard_capturer_state_change_listener.h Normal file
View File

@ -0,0 +1,41 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef I_STANDARD_CAPTURER_STATE_CHANGE_LISTENER_H
#define I_STANDARD_CAPTURER_STATE_CHANGE_LISTENER_H
#include "ipc_types.h"
#include "iremote_broker.h"
#include "iremote_proxy.h"
#include "iremote_stub.h"
namespace OHOS {
namespace AudioStandard {
class IStandardCapturerStateChangeListener : public IRemoteBroker {
public:
virtual ~IStandardCapturerStateChangeListener() = default;
virtual void OnCapturerStateChange(
const std::vector<std::unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos) = 0;
enum AudioCapturerStageChangeListenerMsg {
ON_ERROR = 0,
ON_CAPTURERSTATE_CHANGE,
};
DECLARE_INTERFACE_DESCRIPTOR(u"IStandardCapturerStateChangeListener");
};
} // namespace AudioStandard
} // namespace OHOS
#endif // I_STANDARD_CAPTURER_STATE_CHANGE_LISTENER_H

39
services/include/audio_policy/common/i_standard_client_tracker.h Normal file
View File

@ -0,0 +1,39 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef I_STANDARD_CLIENT_TRACKER_H
#define I_STANDARD_CLIENT_TRACKER_H
#include "ipc_types.h"
#include "iremote_broker.h"
#include "iremote_proxy.h"
#include "iremote_stub.h"
namespace OHOS {
namespace AudioStandard {
class IStandardClientTracker : public IRemoteBroker {
public:
virtual ~IStandardClientTracker() = default;
enum AudioClientTrackerMsg {
ON_ERROR = 0,
ON_INIT,
};
DECLARE_INTERFACE_DESCRIPTOR(u"IStandardClientTracker");
};
} // namespace AudioStandard
} // namespace OHOS
#endif // I_STANDARD_CLIENT_TRACKER_H

41
services/include/audio_policy/common/i_standard_renderer_state_change_listener.h Normal file
View File

@ -0,0 +1,41 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef I_STANDARD_RENDERER_STATE_CHANGE_LISTENER_H
#define I_STANDARD_RENDERER_STATE_CHANGE_LISTENER_H
#include "ipc_types.h"
#include "iremote_broker.h"
#include "iremote_proxy.h"
#include "iremote_stub.h"
namespace OHOS {
namespace AudioStandard {
class IStandardRendererStateChangeListener : public IRemoteBroker {
public:
virtual ~IStandardRendererStateChangeListener() = default;
virtual void OnRendererStateChange(
const std::vector<std::unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos) = 0;
enum AudioRendererStageChangeListenerMsg {
ON_ERROR = 0,
ON_RENDERERSTATE_CHANGE,
};
DECLARE_INTERFACE_DESCRIPTOR(u"IStandardRendererStateChangeListener");
};
} // namespace AudioStandard
} // namespace OHOS
#endif // I_STANDARD_RENDERER_STATE_CHANGE_LISTENER_H

50
services/include/audio_policy/server/audio_capturer_state_change_listener_proxy.h Normal file
View File

@ -0,0 +1,50 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef AUDIO_CAPTURER_STATE_CHANGE_LISTENER_PROXY_H
#define AUDIO_CAPTURER_STATE_CHANGE_LISTENER_PROXY_H
#include "audio_stream_manager.h"
#include "i_standard_capturer_state_change_listener.h"
namespace OHOS {
namespace AudioStandard {
class AudioCapturerStateChangeListenerProxy : public IRemoteProxy<IStandardCapturerStateChangeListener> {
public:
explicit AudioCapturerStateChangeListenerProxy(const sptr<IRemoteObject> &impl);
virtual ~AudioCapturerStateChangeListenerProxy();
DISALLOW_COPY_AND_MOVE(AudioCapturerStateChangeListenerProxy);
void OnCapturerStateChange(const std::vector<std::unique_ptr<AudioCapturerChangeInfo>>
&audioCapturerChangeInfos) override;
private:
static inline BrokerDelegator<AudioCapturerStateChangeListenerProxy> delegator_;
void WriteCapturerChangeInfo(MessageParcel &data, const std::unique_ptr<AudioCapturerChangeInfo>
&capturerChangeInfo);
};
class AudioCapturerStateChangeListenerCallback : public AudioCapturerStateChangeCallback {
public:
AudioCapturerStateChangeListenerCallback(const sptr<IStandardCapturerStateChangeListener> &listener);
virtual ~AudioCapturerStateChangeListenerCallback();
DISALLOW_COPY_AND_MOVE(AudioCapturerStateChangeListenerCallback);
void OnCapturerStateChange(const std::vector<std::unique_ptr<AudioCapturerChangeInfo>>
&audioCapturerChangeInfos) override;
private:
sptr<IStandardCapturerStateChangeListener> listener_ = nullptr;
};
} // namespace AudioStandard
} // namespace OHOS
#endif // AUDIO_CAPTURER_STATE_CHANGE_LISTENER_PROXY_H

45
services/include/audio_policy/server/audio_client_tracker_callback_proxy.h Normal file
View File

@ -0,0 +1,45 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ST_AUDIO_CLIENT_TRACKER_CALLBACK_PROXY_H
#define ST_AUDIO_CLIENT_TRACKER_CALLBACK_PROXY_H
#include "iremote_proxy.h"
#include "audio_stream_manager.h"
#include "i_standard_client_tracker.h"
namespace OHOS {
namespace AudioStandard {
class ClientTrackerCallbackListener : public AudioClientTracker {
public:
explicit ClientTrackerCallbackListener(const sptr<IStandardClientTracker> &listener);
virtual ~ClientTrackerCallbackListener();
DISALLOW_COPY_AND_MOVE(ClientTrackerCallbackListener);
private:
sptr<IStandardClientTracker> listener_ = nullptr;
};
class AudioClientTrackerCallbackProxy : public IRemoteProxy<IStandardClientTracker> {
public:
explicit AudioClientTrackerCallbackProxy(const sptr<IRemoteObject> &impl);
virtual ~AudioClientTrackerCallbackProxy() = default;
private:
static inline BrokerDelegator<AudioClientTrackerCallbackProxy> delegator_;
};
} // namespace AudioStandard
} // namespace OHOS
#endif // ST_AUDIO_CLIENT_TRACKER_CALLBACK_PROXY_H

35
services/include/audio_policy/server/audio_policy_server.h
View File

@ -22,11 +22,14 @@
#include "audio_interrupt_callback.h"
#include "audio_policy_manager_stub.h"
#include "audio_policy_service.h"
#include "audio_server_death_recipient.h"
#include "audio_session_callback.h"
#include "audio_stream_collector.h"
#include "i_audio_volume_key_event_callback.h"
#include "iremote_stub.h"
#include "system_ability.h"
#include "audio_service_dump.h"
#include "audio_info.h"
namespace OHOS {
namespace AudioStandard {
@ -35,6 +38,11 @@ class AudioPolicyServer : public SystemAbility, public AudioPolicyManagerStub, p
public:
DISALLOW_COPY_AND_MOVE(AudioPolicyServer);
enum DeathRecipientId {
TRACKER_CLIENT = 0,
LISTENER_CLIENT
};
explicit AudioPolicyServer(int32_t systemAbilityId, bool runOnCreate = true);
virtual ~AudioPolicyServer() = default;
@ -112,6 +120,32 @@ public:
int32_t ReconfigureAudioChannel(const uint32_t &count, DeviceType deviceType) override;
int32_t GetAudioLatencyFromXml() override;
int32_t RegisterAudioRendererEventListener(int32_t clientUID, const sptr<IRemoteObject> &object) override;
int32_t UnregisterAudioRendererEventListener(int32_t clientUID) override;
int32_t RegisterAudioCapturerEventListener(int32_t clientUID, const sptr<IRemoteObject> &object) override;
int32_t UnregisterAudioCapturerEventListener(int32_t clientUID) override;
int32_t RegisterTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo,
const sptr<IRemoteObject> &object) override;
int32_t UpdateTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo) override;
int32_t GetCurrentRendererChangeInfos(
std::vector<std::unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos) override;
int32_t GetCurrentCapturerChangeInfos(
std::vector<std::unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos) override;
void RegisterClientDeathRecipient(const sptr<IRemoteObject> &object, DeathRecipientId id);
void RegisteredTrackerClientDied(int pid);
void RegisteredStreamListenerClientDied(int pid);
protected:
void OnAddSystemAbility(int32_t systemAbilityId, const std::string& deviceId) override;
void OnRemoveSystemAbility(int32_t systemAbilityId, const std::string& deviceId) override;
@ -137,6 +171,7 @@ private:
static int32_t ConvertVolumeToInt(float volume);
AudioPolicyService& mPolicyService;
AudioStreamCollector& mStreamCollector;
std::unordered_map<int32_t, std::shared_ptr<VolumeKeyEventCallback>> volumeChangeCbsMap_;
std::mutex ringerModeMutex_;
std::mutex interruptMutex_;

50
services/include/audio_policy/server/audio_renderer_state_change_listener_proxy.h Normal file
View File

@ -0,0 +1,50 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef AUDIO_RENDERER_STATE_CHANGE_LISTENER_PROXY_H
#define AUDIO_RENDERER_STATE_CHANGE_LISTENER_PROXY_H
#include "audio_stream_manager.h"
#include "i_standard_renderer_state_change_listener.h"
namespace OHOS {
namespace AudioStandard {
class AudioRendererStateChangeListenerProxy : public IRemoteProxy<IStandardRendererStateChangeListener> {
public:
explicit AudioRendererStateChangeListenerProxy(const sptr<IRemoteObject> &impl);
virtual ~AudioRendererStateChangeListenerProxy();
DISALLOW_COPY_AND_MOVE(AudioRendererStateChangeListenerProxy);
void OnRendererStateChange(
const std::vector<std::unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos) override;
private:
static inline BrokerDelegator<AudioRendererStateChangeListenerProxy> delegator_;
void WriteRendererChangeInfo(MessageParcel &data,
const std::unique_ptr<AudioRendererChangeInfo> &rendererChangeInfo);
};
class AudioRendererStateChangeListenerCallback : public AudioRendererStateChangeCallback {
public:
AudioRendererStateChangeListenerCallback(const sptr<IStandardRendererStateChangeListener> &listener);
virtual ~AudioRendererStateChangeListenerCallback();
DISALLOW_COPY_AND_MOVE(AudioRendererStateChangeListenerCallback);
void OnRendererStateChange(
const std::vector<std::unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos) override;
private:
sptr<IStandardRendererStateChangeListener> listener_ = nullptr;
};
} // namespace AudioStandard
} // namespace OHOS
#endif // AUDIO_RENDERER_STATE_CHANGE_LISTENER_PROXY_H

63
services/include/audio_policy/server/audio_stream_collector.h Normal file
View File

@ -0,0 +1,63 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef AUDIO_STREAM_COLLECTOR_H
#define AUDIO_STREAM_COLLECTOR_H
#include "audio_info.h"
#include "audio_stream_event_dispatcher.h"
namespace OHOS {
namespace AudioStandard {
class AudioStreamCollector {
public:
static AudioStreamCollector& GetAudioStreamCollector()
{
static AudioStreamCollector audioStreamCollector;
return audioStreamCollector;
}
AudioStreamCollector();
~AudioStreamCollector();
int32_t RegisterAudioRendererEventListener(int32_t clientUID, const sptr<IRemoteObject> &object);
int32_t UnregisterAudioRendererEventListener(int32_t clientUID);
int32_t RegisterAudioCapturerEventListener(int32_t clientUID, const sptr<IRemoteObject> &object);
int32_t UnregisterAudioCapturerEventListener(int32_t clientUID);
int32_t RegisterTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo,
const sptr<IRemoteObject> &object);
int32_t UpdateTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo);
int32_t GetCurrentRendererChangeInfos(vector<unique_ptr<AudioRendererChangeInfo>> &rendererChangeInfos);
int32_t GetCurrentCapturerChangeInfos(vector<unique_ptr<AudioCapturerChangeInfo>> &capturerChangeInfos);
void RegisteredTrackerClientDied(int32_t uid);
void RegisteredStreamListenerClientDied(int32_t uid);
private:
AudioStreamEventDispatcher &mDispatcherService;
std::mutex rendererStateChangeEventMutex_;
std::mutex capturerStateChangeEventMutex_;
std::map<std::pair<int32_t, int32_t>, int32_t> rendererStatequeue_;
std::map<std::pair<int32_t, int32_t>, int32_t> capturerStatequeue_;
std::vector<std::unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos_;
std::vector<std::unique_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos_;
std::unordered_map<int32_t, std::shared_ptr<AudioClientTracker>> clientTracker_;
int32_t AddRendererStream(AudioStreamChangeInfo &streamChangeInfo);
int32_t AddCapturerStream(AudioStreamChangeInfo &streamChangeInfo);
int32_t UpdateRendererStream(AudioStreamChangeInfo &streamChangeInfo);
int32_t UpdateCapturerStream(AudioStreamChangeInfo &streamChangeInfo);
void DisplayInternalStreamInfo();
};
} // namespace AudioStandard
} // namespace OHOS
#endif

101
services/src/audio_policy/client/audio_capturer_state_change_listener_stub.cpp Normal file
View File

@ -0,0 +1,101 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "audio_capturer_state_change_listener_stub.h"
#include "audio_errors.h"
#include "audio_system_manager.h"
#include "audio_log.h"
using namespace std;
namespace OHOS {
namespace AudioStandard {
AudioCapturerStateChangeListenerStub::AudioCapturerStateChangeListenerStub()
{
AUDIO_DEBUG_LOG("AudioCapturerStateChangeListenerStub Instance create");
}
AudioCapturerStateChangeListenerStub::~AudioCapturerStateChangeListenerStub()
{
AUDIO_DEBUG_LOG("AudioCapturerStateChangeListenerStub Instance destroy");
}
void AudioCapturerStateChangeListenerStub::ReadAudioCapturerChangeInfo(MessageParcel &data,
unique_ptr<AudioCapturerChangeInfo> &capturerChangeInfo)
{
AUDIO_DEBUG_LOG("AudioCapturerStateChangeListenerStub: ReadAudioCapturerChangeInfo");
capturerChangeInfo->sessionId = data.ReadInt32();
capturerChangeInfo->capturerState = static_cast<CapturerState>(data.ReadInt32());
capturerChangeInfo->clientUID = data.ReadInt32();
capturerChangeInfo->capturerInfo.sourceType = static_cast<SourceType>(data.ReadInt32());
capturerChangeInfo->capturerInfo.capturerFlags = data.ReadInt32();
AUDIO_DEBUG_LOG("AudioCapturerStateChangeListenerStub, sessionid = %{public}d", capturerChangeInfo->sessionId);
AUDIO_DEBUG_LOG("AudioCapturerStateChangeListenerStub, capturerState = %{public}d",
capturerChangeInfo->capturerState);
AUDIO_DEBUG_LOG("AudioCapturerStateChangeListenerStub, clientUID = %{public}d", capturerChangeInfo->clientUID);
AUDIO_DEBUG_LOG("AudioCapturerStateChangeListenerStub, sourceType = %{public}d",
capturerChangeInfo->capturerInfo.sourceType);
AUDIO_DEBUG_LOG("AudioCapturerStateChangeListenerStub, capturerFlags = %{public}d",
capturerChangeInfo->capturerInfo.capturerFlags);
}
int AudioCapturerStateChangeListenerStub::OnRemoteRequest(
uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
{
if (data.ReadInterfaceToken() != GetDescriptor()) {
AUDIO_ERR_LOG("AudioCapturerStateChangeListenerStub: ReadInterfaceToken failed");
return -1;
}
switch (code) {
case ON_CAPTURERSTATE_CHANGE: {
vector<unique_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
size_t size = data.ReadInt32();
while (size > 0) {
unique_ptr<AudioCapturerChangeInfo> capturerChangeInfo = make_unique<AudioCapturerChangeInfo>();
CHECK_AND_RETURN_RET_LOG(capturerChangeInfo != nullptr, ERR_MEMORY_ALLOC_FAILED, "No memory!!");
ReadAudioCapturerChangeInfo(data, capturerChangeInfo);
audioCapturerChangeInfos.push_back(move(capturerChangeInfo));
size--;
}
OnCapturerStateChange(audioCapturerChangeInfos);
return AUDIO_OK;
}
default: {
AUDIO_ERR_LOG("default case, need check AudioListenerStub");
return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
}
}
}
void AudioCapturerStateChangeListenerStub::OnCapturerStateChange(
const vector<unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos)
{
shared_ptr<AudioCapturerStateChangeCallback> cb = callback_.lock();
if (cb == nullptr) {
AUDIO_ERR_LOG("AudioCapturerStateChangeListenerStub: callback_ is nullptr");
}
cb->OnCapturerStateChange(audioCapturerChangeInfos);
return;
}
void AudioCapturerStateChangeListenerStub::SetCallback(const weak_ptr<AudioCapturerStateChangeCallback> &callback)
{
callback_ = callback;
}
} // namespace AudioStandard
} // namespace OHOS

47
services/src/audio_policy/client/audio_client_tracker_callback_stub.cpp Normal file
View File

@ -0,0 +1,47 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "audio_client_tracker_callback_stub.h"
#include "audio_log.h"
namespace OHOS {
namespace AudioStandard {
AudioClientTrackerCallbackStub::AudioClientTrackerCallbackStub()
{
}
AudioClientTrackerCallbackStub::~AudioClientTrackerCallbackStub()
{
}
int AudioClientTrackerCallbackStub::OnRemoteRequest(
uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
{
AUDIO_DEBUG_LOG("AudioClientTrackerCallbackStub::OnRemoteRequest");
if (data.ReadInterfaceToken() != GetDescriptor()) {
AUDIO_ERR_LOG("AudioClientTrackerCallbackStub: ReadInterfaceToken failed");
return -1;
}
return 0;
}
void AudioClientTrackerCallbackStub::SetClientTrackerCallback(
const std::weak_ptr<AudioClientTracker> &callback)
{
AUDIO_DEBUG_LOG("AudioClientTrackerCallbackStub::SetClientTrackerCallback");
callback_ = callback;
}
} // namespace AudioStandard
} // namespace OHOS

116
services/src/audio_policy/client/audio_policy_manager.cpp
View File

@ -23,6 +23,8 @@
namespace OHOS {
namespace AudioStandard {
using namespace std;
static sptr<IAudioPolicy> g_sProxy = nullptr;
bool AudioPolicyManager::serverConnected = false;
@ -326,6 +328,104 @@ int32_t AudioPolicyManager::UnsetVolumeKeyEventCallback(const int32_t clientPid)
return g_sProxy->UnsetVolumeKeyEventCallback(clientPid);
}
int32_t AudioPolicyManager::RegisterAudioRendererEventListener(const int32_t clientUID,
const std::shared_ptr<AudioRendererStateChangeCallback> &callback)
{
AUDIO_INFO_LOG("AudioPolicyManager::RegisterAudioRendererEventListener");
if (callback == nullptr) {
AUDIO_ERR_LOG("AudioPolicyManager: RendererEvent Listener callback is nullptr");
return ERR_INVALID_PARAM;
}
std::unique_lock<std::mutex> lock(stateChangelistenerStubMutex_);
rendererStateChangelistenerStub_ = new(std::nothrow) AudioRendererStateChangeListenerStub();
if (rendererStateChangelistenerStub_ == nullptr || g_sProxy == nullptr) {
AUDIO_ERR_LOG("AudioPolicyManager: object null");
return ERROR;
}
rendererStateChangelistenerStub_->SetCallback(callback);
sptr<IRemoteObject> object = rendererStateChangelistenerStub_->AsObject();
if (object == nullptr) {
AUDIO_ERR_LOG("AudioPolicyManager:RenderStateChangeListener IPC object creation failed");
return ERROR;
}
lock.unlock();
return g_sProxy->RegisterAudioRendererEventListener(clientUID, object);
}
int32_t AudioPolicyManager::UnregisterAudioRendererEventListener(const int32_t clientUID)
{
AUDIO_INFO_LOG("AudioPolicyManager::UnregisterAudioRendererEventListener");
return g_sProxy->UnregisterAudioRendererEventListener(clientUID);
}
int32_t AudioPolicyManager::RegisterAudioCapturerEventListener(const int32_t clientUID,
const std::shared_ptr<AudioCapturerStateChangeCallback> &callback)
{
AUDIO_INFO_LOG("AudioPolicyManager::RegisterAudioCapturerEventListener");
if (callback == nullptr) {
AUDIO_ERR_LOG("AudioPolicyManager: Capturer Event Listener callback is nullptr");
return ERR_INVALID_PARAM;
}
std::unique_lock<std::mutex> lock(stateChangelistenerStubMutex_);
capturerStateChangelistenerStub_ = new(std::nothrow) AudioCapturerStateChangeListenerStub();
if (capturerStateChangelistenerStub_ == nullptr || g_sProxy == nullptr) {
AUDIO_ERR_LOG("AudioPolicyManager: object null");
return ERROR;
}
capturerStateChangelistenerStub_->SetCallback(callback);
sptr<IRemoteObject> object = capturerStateChangelistenerStub_->AsObject();
if (object == nullptr) {
AUDIO_ERR_LOG("AudioPolicyManager:CapturerStateChangeListener IPC object creation failed");
return ERROR;
}
lock.unlock();
return g_sProxy->RegisterAudioCapturerEventListener(clientUID, object);
}
int32_t AudioPolicyManager::UnregisterAudioCapturerEventListener(const int32_t clientUID)
{
AUDIO_INFO_LOG("AudioPolicyManager::UnregisterAudioCapturerEventListener");
return g_sProxy->UnregisterAudioCapturerEventListener(clientUID);
}
int32_t AudioPolicyManager::RegisterTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo,
const std::shared_ptr<AudioClientTracker> &clientTrackerObj)
{
AUDIO_INFO_LOG("AudioPolicyManager::RegisterTracker");
std::unique_lock<std::mutex> lock(clientTrackerStubMutex_);
clientTrackerCbStub_ = new(std::nothrow) AudioClientTrackerCallbackStub();
if (clientTrackerCbStub_ == nullptr || g_sProxy == nullptr) {
AUDIO_ERR_LOG("clientTrackerCbStub: memory allocation failed");
return ERROR;
}
clientTrackerCbStub_->SetClientTrackerCallback(clientTrackerObj);
sptr<IRemoteObject> object = clientTrackerCbStub_->AsObject();
if (object == nullptr) {
AUDIO_ERR_LOG("clientTrackerCbStub: IPC object creation failed");
return ERROR;
}
lock.unlock();
return g_sProxy->RegisterTracker(mode, streamChangeInfo, object);
}
int32_t AudioPolicyManager::UpdateTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo)
{
AUDIO_INFO_LOG("AudioPolicyManager::UpdateTracker");
return g_sProxy->UpdateTracker(mode, streamChangeInfo);
}
bool AudioPolicyManager::VerifyClientPermission(const std::string &permissionName)
{
return VerifyClientPermission(permissionName, 0);
@ -345,5 +445,21 @@ int32_t AudioPolicyManager::GetAudioLatencyFromXml()
{
return g_sProxy->GetAudioLatencyFromXml();
}
int32_t AudioPolicyManager::GetCurrentRendererChangeInfos(
vector<unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos)
{
AUDIO_DEBUG_LOG("AudioPolicyManager::GetCurrentRendererChangeInfos");
return g_sProxy->GetCurrentRendererChangeInfos(audioRendererChangeInfos);
}
int32_t AudioPolicyManager::GetCurrentCapturerChangeInfos(
vector<unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos)
{
AUDIO_DEBUG_LOG("AudioPolicyManager::GetCurrentCapturerChangeInfos");
return g_sProxy->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
}
} // namespace AudioStandard
} // namespace OHOS

263
services/src/audio_policy/client/audio_policy_proxy.cpp
View File

@ -19,6 +19,8 @@
namespace OHOS {
namespace AudioStandard {
using namespace std;
AudioPolicyProxy::AudioPolicyProxy(const sptr<IRemoteObject> &impl)
: IRemoteProxy<IAudioPolicy>(impl)
{
@ -48,6 +50,25 @@ void AudioPolicyProxy::ReadAudioInterruptParams(MessageParcel &reply, AudioInter
audioInterrupt.sessionID = reply.ReadUint32();
}
void AudioPolicyProxy::WriteStreamChangeInfo(MessageParcel &data,
const AudioMode &mode, const AudioStreamChangeInfo &streamChangeInfo)
{
if (mode == AUDIO_MODE_PLAYBACK) {
data.WriteInt32(streamChangeInfo.audioRendererChangeInfo.sessionId);
data.WriteInt32(streamChangeInfo.audioRendererChangeInfo.rendererState);
data.WriteInt32(streamChangeInfo.audioRendererChangeInfo.clientUID);
data.WriteInt32(streamChangeInfo.audioRendererChangeInfo.rendererInfo.contentType);
data.WriteInt32(streamChangeInfo.audioRendererChangeInfo.rendererInfo.streamUsage);
data.WriteInt32(streamChangeInfo.audioRendererChangeInfo.rendererInfo.rendererFlags);
} else {
data.WriteInt32(streamChangeInfo.audioCapturerChangeInfo.sessionId);
data.WriteInt32(streamChangeInfo.audioCapturerChangeInfo.capturerState);
data.WriteInt32(streamChangeInfo.audioCapturerChangeInfo.clientUID);
data.WriteInt32(streamChangeInfo.audioCapturerChangeInfo.capturerInfo.sourceType);
data.WriteInt32(streamChangeInfo.audioCapturerChangeInfo.capturerInfo.capturerFlags);
}
}
int32_t AudioPolicyProxy::SetStreamVolume(AudioStreamType streamType, float volume)
{
MessageParcel data;
@ -724,6 +745,55 @@ int32_t AudioPolicyProxy::ReconfigureAudioChannel(const uint32_t &count, DeviceT
return reply.ReadInt32();
}
int32_t AudioPolicyProxy::RegisterAudioRendererEventListener(const int32_t clientUID, const sptr<IRemoteObject> &object)
{
MessageParcel data;
MessageParcel reply;
MessageOption option;
AUDIO_INFO_LOG("AudioPolicyProxy::RegisterAudioRendererEventListener");
if (!data.WriteInterfaceToken(GetDescriptor())) {
AUDIO_ERR_LOG("RegisterAudioRendererEventListener: WriteInterfaceToken failed");
return ERROR;
}
if (object == nullptr) {
AUDIO_ERR_LOG("RegisterAudioRendererEventListener Event object is null");
return ERR_NULL_OBJECT;
}
data.WriteInt32(clientUID);
data.WriteRemoteObject(object);
int32_t error = Remote() ->SendRequest(REGISTER_PLAYBACK_EVENT, data, reply, option);
if (error != ERR_NONE) {
AUDIO_ERR_LOG("RegisterAudioRendererEventListener register playback event faild , error: %d", error);
return ERROR;
}
return reply.ReadInt32();
}
int32_t AudioPolicyProxy::UnregisterAudioRendererEventListener(const int32_t clientUID)
{
MessageParcel data;
MessageParcel reply;
MessageOption option;
AUDIO_INFO_LOG("AudioPolicyProxy::UnregisterAudioRendererEventListener");
if (!data.WriteInterfaceToken(GetDescriptor())) {
AUDIO_ERR_LOG("UnregisterAudioRendererEventListener WriteInterfaceToken failed");
return ERROR;
}
data.WriteInt32(clientUID);
int32_t error = Remote() ->SendRequest(UNREGISTER_PLAYBACK_EVENT, data, reply, option);
if (error != ERR_NONE) {
AUDIO_ERR_LOG("UnregisterAudioRendererEventListener unregister playback event failed , error: %d", error);
return ERROR;
}
return reply.ReadInt32();
}
int32_t AudioPolicyProxy::GetAudioLatencyFromXml()
{
MessageParcel data;
@ -743,5 +813,198 @@ int32_t AudioPolicyProxy::GetAudioLatencyFromXml()
return reply.ReadInt32();
}
int32_t AudioPolicyProxy::RegisterAudioCapturerEventListener(const int32_t clientUID, const sptr<IRemoteObject> &object)
{
MessageParcel data;
MessageParcel reply;
MessageOption option;
AUDIO_INFO_LOG("AudioPolicyProxy::RegisterAudioCapturerEventListener");
if (!data.WriteInterfaceToken(GetDescriptor())) {
AUDIO_ERR_LOG("RegisterAudioCapturerEventListener:: WriteInterfaceToken failed");
return ERROR;
}
if (object == nullptr) {
AUDIO_ERR_LOG("RegisterAudioCapturerEventListener Event object is null");
return ERR_NULL_OBJECT;
}
data.WriteInt32(clientUID);
data.WriteRemoteObject(object);
int32_t error = Remote() ->SendRequest(REGISTER_RECORDING_EVENT, data, reply, option);
if (error != ERR_NONE) {
AUDIO_ERR_LOG("RegisterAudioCapturerEventListener recording event faild , error: %d", error);
return ERROR;
}
return reply.ReadInt32();
}
int32_t AudioPolicyProxy::UnregisterAudioCapturerEventListener(const int32_t clientUID)
{
MessageParcel data;
MessageParcel reply;
MessageOption option;
AUDIO_INFO_LOG("AudioPolicyProxy::UnregisterAudioCapturerEventListener");
if (!data.WriteInterfaceToken(GetDescriptor())) {
AUDIO_ERR_LOG("AudioPolicyProxy:: WriteInterfaceToken failed");
return ERROR;
}
data.WriteInt32(clientUID);
int32_t error = Remote() ->SendRequest(UNREGISTER_RECORDING_EVENT, data, reply, option);
if (error != ERR_NONE) {
AUDIO_ERR_LOG("UnregisterAudioCapturerEventListener recording event faild , error: %d", error);
return ERROR;
}
return reply.ReadInt32();
}
int32_t AudioPolicyProxy::RegisterTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo,
const sptr<IRemoteObject> &object)
{
MessageParcel data;
MessageParcel reply;
MessageOption option;
AUDIO_INFO_LOG("AudioPolicyProxy::RegisterTracker");
if (!data.WriteInterfaceToken(GetDescriptor())) {
AUDIO_ERR_LOG("RegisterTracker WriteInterfaceToken failed");
return ERROR;
}
if (object == nullptr) {
AUDIO_ERR_LOG("Register Tracker Event object is null");
return ERR_NULL_OBJECT;
}
data.WriteUint32(mode);
WriteStreamChangeInfo(data, mode, streamChangeInfo);
data.WriteRemoteObject(object);
int32_t error = Remote()->SendRequest(REGISTER_TRACKER, data, reply, option);
if (error != ERR_NONE) {
AUDIO_ERR_LOG("RegisterTracker event failed , error: %d", error);
return ERROR;
}
return reply.ReadInt32();
}
int32_t AudioPolicyProxy::UpdateTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo)
{
MessageParcel data;
MessageParcel reply;
MessageOption option;
AUDIO_INFO_LOG("AudioPolicyProxy::UpdateTracker");
if (!data.WriteInterfaceToken(GetDescriptor())) {
AUDIO_ERR_LOG("UpdateTracker: WriteInterfaceToken failed");
return ERROR;
}
data.WriteUint32(mode);
WriteStreamChangeInfo(data, mode, streamChangeInfo);
int32_t error = Remote()->SendRequest(UPDATE_TRACKER, data, reply, option);
if (error != ERR_NONE) {
AUDIO_ERR_LOG("UpdateTracker event failed , error: %d", error);
return ERROR;
}
return reply.ReadInt32();
}
void AudioPolicyProxy::ReadAudioRendererChangeInfo(MessageParcel &reply,
unique_ptr<AudioRendererChangeInfo> &rendererChangeInfo)
{
rendererChangeInfo->sessionId = reply.ReadInt32();
rendererChangeInfo->rendererState = static_cast<RendererState>(reply.ReadInt32());
rendererChangeInfo->clientUID = reply.ReadInt32();
rendererChangeInfo->rendererInfo.contentType = static_cast<ContentType>(reply.ReadInt32());
rendererChangeInfo->rendererInfo.streamUsage = static_cast<StreamUsage>(reply.ReadInt32());
rendererChangeInfo->rendererInfo.rendererFlags = reply.ReadInt32();
}
void AudioPolicyProxy::ReadAudioCapturerChangeInfo(MessageParcel &reply,
unique_ptr<AudioCapturerChangeInfo> &capturerChangeInfo)
{
capturerChangeInfo->sessionId = reply.ReadInt32();
capturerChangeInfo->capturerState = static_cast<CapturerState>(reply.ReadInt32());
capturerChangeInfo->clientUID = reply.ReadInt32();
capturerChangeInfo->capturerInfo.sourceType = static_cast<SourceType>(reply.ReadInt32());
capturerChangeInfo->capturerInfo.capturerFlags = reply.ReadInt32();
}
int32_t AudioPolicyProxy::GetCurrentRendererChangeInfos(
vector<unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos)
{
MessageParcel data;
MessageParcel reply;
MessageOption option;
AUDIO_DEBUG_LOG("AudioPolicyProxy::GetCurrentRendererChangeInfos");
if (!data.WriteInterfaceToken(GetDescriptor())) {
AUDIO_ERR_LOG("GetCurrentRendererChangeInfo: WriteInterfaceToken failed");
return ERROR;
}
int32_t error = Remote()->SendRequest(GET_RENDERER_CHANGE_INFOS, data, reply, option);
if (error != ERR_NONE) {
AUDIO_ERR_LOG("Get Renderer change info event failed , error: %d", error);
return ERROR;
}
size_t size = reply.ReadInt32();
while (size > 0) {
unique_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_unique<AudioRendererChangeInfo>();
CHECK_AND_RETURN_RET_LOG(rendererChangeInfo != nullptr, ERR_MEMORY_ALLOC_FAILED, "No memory!!");
ReadAudioRendererChangeInfo(reply, rendererChangeInfo);
audioRendererChangeInfos.push_back(move(rendererChangeInfo));
size--;
}
return SUCCESS;
}
int32_t AudioPolicyProxy::GetCurrentCapturerChangeInfos(
vector<unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos)
{
MessageParcel data;
MessageParcel reply;
MessageOption option;
AUDIO_DEBUG_LOG("AudioPolicyProxy::GetCurrentCapturerChangeInfos");
if (!data.WriteInterfaceToken(GetDescriptor())) {
AUDIO_ERR_LOG("GetCurrentCapturerChangeInfos: WriteInterfaceToken failed");
return ERROR;
}
int32_t error = Remote()->SendRequest(GET_CAPTURER_CHANGE_INFOS, data, reply, option);
if (error != ERR_NONE) {
AUDIO_ERR_LOG("Get capturer change info event failed , error: %d", error);
return ERROR;
}
size_t size = reply.ReadInt32();
while (size > 0) {
unique_ptr<AudioCapturerChangeInfo> capturerChangeInfo = make_unique<AudioCapturerChangeInfo>();
CHECK_AND_RETURN_RET_LOG(capturerChangeInfo != nullptr, ERR_MEMORY_ALLOC_FAILED, "No memory!!");
ReadAudioCapturerChangeInfo(reply, capturerChangeInfo);
audioCapturerChangeInfos.push_back(move(capturerChangeInfo));
size--;
}
return SUCCESS;
}
} // namespace AudioStandard
} // namespace OHOS

108
services/src/audio_policy/client/audio_renderer_state_change_listener_stub.cpp Normal file
View File

@ -0,0 +1,108 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "audio_renderer_state_change_listener_stub.h"
#include "audio_errors.h"
#include "audio_system_manager.h"
#include "audio_log.h"
using namespace std;
namespace OHOS {
namespace AudioStandard {
AudioRendererStateChangeListenerStub::AudioRendererStateChangeListenerStub()
{
AUDIO_DEBUG_LOG("AudioRendererStateChangeListenerStub Instance create");
}
AudioRendererStateChangeListenerStub::~AudioRendererStateChangeListenerStub()
{
AUDIO_DEBUG_LOG("AudioRendererStateChangeListenerStub Instance destroy");
}
void AudioRendererStateChangeListenerStub::ReadAudioRendererChangeInfo(MessageParcel &data,
unique_ptr<AudioRendererChangeInfo> &rendererChangeInfo)
{
AUDIO_INFO_LOG("AudioRendererStateChangeListenerStub ReadAudioRendererChangeInfo");
rendererChangeInfo->sessionId = data.ReadInt32();
rendererChangeInfo->rendererState = static_cast<RendererState>(data.ReadInt32());
rendererChangeInfo->clientUID = data.ReadInt32();
rendererChangeInfo->rendererInfo.contentType = static_cast<ContentType>(data.ReadInt32());
rendererChangeInfo->rendererInfo.streamUsage = static_cast<StreamUsage>(data.ReadInt32());
rendererChangeInfo->rendererInfo.rendererFlags = data.ReadInt32();
AUDIO_DEBUG_LOG("AudioRendererStateChangeListenerStub, sessionid = %{public}d", rendererChangeInfo->sessionId);
AUDIO_DEBUG_LOG("AudioRendererStateChangeListenerStub, rendererState = %{public}d",
rendererChangeInfo->rendererState);
AUDIO_DEBUG_LOG("AudioRendererStateChangeListenerStub, clientUID = %{public}d", rendererChangeInfo->clientUID);
AUDIO_DEBUG_LOG("AudioRendererStateChangeListenerStub, contentType = %{public}d",
rendererChangeInfo->rendererInfo.contentType);
AUDIO_DEBUG_LOG("AudioRendererStateChangeListenerStub, streamUsage = %{public}d",
rendererChangeInfo->rendererInfo.streamUsage);
AUDIO_DEBUG_LOG("AudioRendererStateChangeListenerStub, rendererFlags = %{public}d",
rendererChangeInfo->rendererInfo.rendererFlags);
}
int AudioRendererStateChangeListenerStub::OnRemoteRequest(
uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
{
if (data.ReadInterfaceToken() != GetDescriptor()) {
AUDIO_ERR_LOG("AudioRendererStateChangeListenerStub: ReadInterfaceToken failed");
return -1;
}
AUDIO_INFO_LOG("AudioRendererStateChangeListenerStub OnRemoteRequest");
switch (code) {
case ON_RENDERERSTATE_CHANGE: {
vector<unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
size_t size = data.ReadInt32();
while (size > 0) {
unique_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_unique<AudioRendererChangeInfo>();
CHECK_AND_RETURN_RET_LOG(rendererChangeInfo != nullptr, ERR_MEMORY_ALLOC_FAILED, "No memory!!");
ReadAudioRendererChangeInfo(data, rendererChangeInfo);
audioRendererChangeInfos.push_back(move(rendererChangeInfo));
size--;
}
OnRendererStateChange(audioRendererChangeInfos);
return AUDIO_OK;
}
default: {
AUDIO_ERR_LOG("default case, need check AudioListenerStub");
return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
}
}
}
void AudioRendererStateChangeListenerStub::OnRendererStateChange(
const vector<unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos)
{
AUDIO_DEBUG_LOG("AudioRendererStateChangeListenerStub OnRendererStateChange");
shared_ptr<AudioRendererStateChangeCallback> cb = callback_.lock();
if (cb == nullptr) {
AUDIO_ERR_LOG("AudioRendererStateChangeListenerStub: callback_ is nullptr");
return;
}
cb->OnRendererStateChange(audioRendererChangeInfos);
return;
}
void AudioRendererStateChangeListenerStub::SetCallback(const weak_ptr<AudioRendererStateChangeCallback> &callback)
{
AUDIO_DEBUG_LOG("AudioRendererStateChangeListenerStub SetCallback");
callback_ = callback;
}
} // namespace AudioStandard
} // namespace OHOS

99
services/src/audio_policy/server/audio_capturer_state_change_listener_proxy.cpp Normal file
View File

@ -0,0 +1,99 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "audio_capturer_state_change_listener_proxy.h"
#include "audio_system_manager.h"
#include "audio_log.h"
using namespace std;
namespace OHOS {
namespace AudioStandard {
AudioCapturerStateChangeListenerProxy::AudioCapturerStateChangeListenerProxy(const sptr<IRemoteObject> &impl)
: IRemoteProxy<IStandardCapturerStateChangeListener>(impl)
{
AUDIO_DEBUG_LOG("AudioCapturerStateChangeListenerProxy:Instances create");
}
AudioCapturerStateChangeListenerProxy::~AudioCapturerStateChangeListenerProxy()
{
AUDIO_DEBUG_LOG("~AudioCapturerStateChangeListenerProxy: Instance destroy");
}
void AudioCapturerStateChangeListenerProxy::WriteCapturerChangeInfo(MessageParcel &data,
const unique_ptr<AudioCapturerChangeInfo> &capturerChangeInfo)
{
AUDIO_DEBUG_LOG("AudioCapturerStateChangeListenerProxy WriteCapturerChangeInfo sessionId = %{public}d",
capturerChangeInfo->sessionId);
AUDIO_DEBUG_LOG("AudioCapturerStateChangeListenerProxy WriteCapturerChangeInfo capturerState = %{public}d",
capturerChangeInfo->capturerState);
AUDIO_DEBUG_LOG("AudioCapturerStateChangeListenerProxy WriteCapturerChangeInfo client id = %{public}d",
capturerChangeInfo->clientUID);
data.WriteInt32(capturerChangeInfo->sessionId);
data.WriteInt32(capturerChangeInfo->capturerState);
data.WriteInt32(capturerChangeInfo->clientUID);
data.WriteInt32(capturerChangeInfo->capturerInfo.sourceType);
data.WriteInt32(capturerChangeInfo->capturerInfo.capturerFlags);
}
void AudioCapturerStateChangeListenerProxy::OnCapturerStateChange(
const vector<unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos)
{
MessageParcel data;
MessageParcel reply;
MessageOption option;
AUDIO_DEBUG_LOG("AudioCapturerStateChangeListenerProxy OnCapturerStateChange entered");
if (!data.WriteInterfaceToken(GetDescriptor())) {
AUDIO_ERR_LOG("AudioCapturerStateChangeListener: WriteInterfaceToken failed");
return;
}
size_t size = audioCapturerChangeInfos.size();
data.WriteInt32(size);
for (const unique_ptr<AudioCapturerChangeInfo> &capturerChangeInfo: audioCapturerChangeInfos) {
WriteCapturerChangeInfo(data, capturerChangeInfo);
}
int error = Remote()->SendRequest(ON_CAPTURERSTATE_CHANGE, data, reply, option);
if (error != ERR_NONE) {
AUDIO_ERR_LOG("AudioCapturerStateChangeListener failed, error: %{public}d", error);
}
return;
}
AudioCapturerStateChangeListenerCallback::AudioCapturerStateChangeListenerCallback(
const sptr<IStandardCapturerStateChangeListener> &listener) : listener_(listener)
{
AUDIO_DEBUG_LOG("AudioCapturerStateChangeListenerCallback: Instance create");
}
AudioCapturerStateChangeListenerCallback::~AudioCapturerStateChangeListenerCallback()
{
AUDIO_DEBUG_LOG("AudioCapturerStateChangeListenerCallback: Instance destroy");
}
void AudioCapturerStateChangeListenerCallback::OnCapturerStateChange(
const vector<unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos)
{
AUDIO_DEBUG_LOG("AudioCapturerStateChangeListenerCallback OnCapturerStateChange entered");
if (listener_ != nullptr) {
listener_->OnCapturerStateChange(audioCapturerChangeInfos);
}
}
} // namespace AudioStandard
} // namespace OHOS

34
services/src/audio_policy/server/audio_client_tracker_callback_proxy.cpp Normal file
View File

@ -0,0 +1,34 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "audio_log.h"
#include "audio_client_tracker_callback_proxy.h"
namespace OHOS {
namespace AudioStandard {
AudioClientTrackerCallbackProxy::AudioClientTrackerCallbackProxy(const sptr<IRemoteObject> &impl)
: IRemoteProxy<IStandardClientTracker>(impl) { }
ClientTrackerCallbackListener::ClientTrackerCallbackListener(const sptr<IStandardClientTracker> &listener)
: listener_(listener)
{
AUDIO_DEBUG_LOG("ClientTrackerCallbackListener");
}
ClientTrackerCallbackListener::~ClientTrackerCallbackListener()
{
AUDIO_DEBUG_LOG("ClientTrackerCallbackListener destructor");
}
} // namespace AudioStandard
} // namespace OHOS

190
services/src/audio_policy/server/audio_policy_manager_stub.cpp
View File

@ -21,6 +21,8 @@
namespace OHOS {
namespace AudioStandard {
using namespace std;
void AudioPolicyManagerStub::ReadAudioInterruptParams(MessageParcel &data, AudioInterrupt &audioInterrupt)
{
audioInterrupt.streamUsage = static_cast<StreamUsage>(data.ReadInt32());
@ -45,6 +47,27 @@ void AudioPolicyManagerStub::WriteAudioInteruptParams(MessageParcel &reply, cons
reply.WriteUint32(audioInterrupt.sessionID);
}
void AudioPolicyManagerStub::ReadStreamChangeInfo(MessageParcel &data, const AudioMode &mode,
AudioStreamChangeInfo &streamChangeInfo)
{
if (mode == AUDIO_MODE_PLAYBACK) {
streamChangeInfo.audioRendererChangeInfo.sessionId = data.ReadInt32();
streamChangeInfo.audioRendererChangeInfo.rendererState = static_cast<RendererState>(data.ReadInt32());
streamChangeInfo.audioRendererChangeInfo.clientUID = data.ReadInt32();
streamChangeInfo.audioRendererChangeInfo.rendererInfo.contentType = static_cast<ContentType>(data.ReadInt32());
streamChangeInfo.audioRendererChangeInfo.rendererInfo.streamUsage = static_cast<StreamUsage>(data.ReadInt32());
streamChangeInfo.audioRendererChangeInfo.rendererInfo.rendererFlags = data.ReadInt32();
return;
} else {
// mode == AUDIO_MODE_RECORDING
streamChangeInfo.audioCapturerChangeInfo.sessionId = data.ReadInt32();
streamChangeInfo.audioCapturerChangeInfo.capturerState = static_cast<CapturerState>(data.ReadInt32());
streamChangeInfo.audioCapturerChangeInfo.clientUID = data.ReadInt32();
streamChangeInfo.audioCapturerChangeInfo.capturerInfo.sourceType = static_cast<SourceType>(data.ReadInt32());
streamChangeInfo.audioCapturerChangeInfo.capturerInfo.capturerFlags = data.ReadInt32();
}
}
void AudioPolicyManagerStub::SetStreamVolumeInternal(MessageParcel &data, MessageParcel &reply)
{
AudioStreamType streamType = static_cast<AudioStreamType>(data.ReadInt32());
@ -324,6 +347,141 @@ void AudioPolicyManagerStub::ReconfigureAudioChannelInternal(MessageParcel &data
reply.WriteInt32(ret);
}
void AudioPolicyManagerStub::RegisterAudioRendererEventListenerInternal(MessageParcel &data, MessageParcel &reply)
{
AUDIO_DEBUG_LOG("AudioPolicyManagerStub:register event listener entered");
int32_t clientUID = data.ReadInt32();
sptr<IRemoteObject> remoteObject = data.ReadRemoteObject();
if (remoteObject == nullptr) {
AUDIO_ERR_LOG("AudioPolicyManagerStub: AudioRendererStateCallback obj is null");
return;
}
int ret = RegisterAudioRendererEventListener(clientUID, remoteObject);
reply.WriteInt32(ret);
AUDIO_DEBUG_LOG("AudioPolicyManagerStub:register event listener exit");
}
void AudioPolicyManagerStub::UnregisterAudioRendererEventListenerInternal(MessageParcel &data, MessageParcel &reply)
{
AUDIO_DEBUG_LOG("AudioPolicyManagerStub:unregister event listener entered");
int32_t clientUID = data.ReadInt32();
int ret = UnregisterAudioRendererEventListener(clientUID);
reply.WriteInt32(ret);
AUDIO_DEBUG_LOG("AudioPolicyManagerStub:unregister event listener exit");
}
void AudioPolicyManagerStub::RegisterAudioCapturerEventListenerInternal(MessageParcel &data, MessageParcel &reply)
{
AUDIO_DEBUG_LOG("AudioPolicyManagerStub:cap register event listener entered");
int32_t clientUID = data.ReadInt32();
sptr<IRemoteObject> remoteObject = data.ReadRemoteObject();
if (remoteObject == nullptr) {
AUDIO_ERR_LOG("AudioPolicyManagerStub: AudioCapturerStateCallback obj is null");
return;
}
int ret = RegisterAudioCapturerEventListener(clientUID, remoteObject);
reply.WriteInt32(ret);
AUDIO_DEBUG_LOG("AudioPolicyManagerStub:cap register event listener exit");
}
void AudioPolicyManagerStub::UnregisterAudioCapturerEventListenerInternal(MessageParcel &data, MessageParcel &reply)
{
AUDIO_DEBUG_LOG("AudioPolicyManagerStub:cap unnregister event listener entered");
int32_t clientUID = data.ReadInt32();
int ret = UnregisterAudioCapturerEventListener(clientUID);
reply.WriteInt32(ret);
AUDIO_DEBUG_LOG("AudioPolicyManagerStub:cap unregister event listener exit");
}
void AudioPolicyManagerStub::RegisterTrackerInternal(MessageParcel &data, MessageParcel &reply)
{
AUDIO_DEBUG_LOG("AudioPolicyManagerStub:register tracker internal entered");
AudioStreamChangeInfo streamChangeInfo = {};
AudioMode mode = static_cast<AudioMode> (data.ReadInt32());
ReadStreamChangeInfo(data, mode, streamChangeInfo);
sptr<IRemoteObject> remoteObject = data.ReadRemoteObject();
if (remoteObject == nullptr) {
AUDIO_ERR_LOG("AudioPolicyManagerStub: Client Tracker obj is null");
return;
}
int ret = RegisterTracker(mode, streamChangeInfo, remoteObject);
reply.WriteInt32(ret);
AUDIO_DEBUG_LOG("AudioPolicyManagerStub:register tracker internal ret = %{public}d", ret);
}
void AudioPolicyManagerStub::UpdateTrackerInternal(MessageParcel &data, MessageParcel &reply)
{
AUDIO_DEBUG_LOG("AudioPolicyManagerStub:update tracker internal entered");
AudioStreamChangeInfo streamChangeInfo = {};
AudioMode mode = static_cast<AudioMode> (data.ReadInt32());
ReadStreamChangeInfo(data, mode, streamChangeInfo);
int ret = UpdateTracker(mode, streamChangeInfo);
reply.WriteInt32(ret);
AUDIO_DEBUG_LOG("AudioPolicyManagerStub:update tracker internal ret = %{public}d", ret);
}
void AudioPolicyManagerStub::GetRendererChangeInfosInternal(MessageParcel &data, MessageParcel &reply)
{
AUDIO_DEBUG_LOG("AudioPolicyManagerStub:Renderer change info internal entered");
size_t size = 0;
vector<unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
int ret = GetCurrentRendererChangeInfos(audioRendererChangeInfos);
if (ret != SUCCESS) {
AUDIO_ERR_LOG("AudioPolicyManagerStub:GetRendererChangeInfos Error!!");
reply.WriteInt32(size);
return;
}
size = audioRendererChangeInfos.size();
reply.WriteInt32(size);
for (const unique_ptr<AudioRendererChangeInfo> &rendererChangeInfo: audioRendererChangeInfos) {
if (!rendererChangeInfo) {
AUDIO_ERR_LOG("AudioPolicyManagerStub:Renderer change info null, something wrong!!");
continue;
}
reply.WriteInt32(rendererChangeInfo->sessionId);
reply.WriteInt32(rendererChangeInfo->rendererState);
reply.WriteInt32(rendererChangeInfo->clientUID);
reply.WriteInt32(rendererChangeInfo->rendererInfo.contentType);
reply.WriteInt32(rendererChangeInfo->rendererInfo.streamUsage);
reply.WriteInt32(rendererChangeInfo->rendererInfo.rendererFlags);
}
AUDIO_DEBUG_LOG("AudioPolicyManagerStub:Renderer change info internal exit");
}
void AudioPolicyManagerStub::GetCapturerChangeInfosInternal(MessageParcel &data, MessageParcel &reply)
{
AUDIO_DEBUG_LOG("AudioPolicyManagerStub:Capturer change info internal entered");
size_t size = 0;
vector<unique_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
int32_t ret = GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
if (ret != SUCCESS) {
AUDIO_ERR_LOG("AudioPolicyManagerStub:GetCapturerChangeInfos Error!!");
reply.WriteInt32(size);
return;
}
size = audioCapturerChangeInfos.size();
reply.WriteInt32(size);
for (const unique_ptr<AudioCapturerChangeInfo> &capturerChangeInfo: audioCapturerChangeInfos) {
if (!capturerChangeInfo) {
AUDIO_ERR_LOG("AudioPolicyManagerStub:Capturer change info null, something wrong!!");
continue;
}
reply.WriteInt32(capturerChangeInfo->sessionId);
reply.WriteInt32(capturerChangeInfo->capturerState);
reply.WriteInt32(capturerChangeInfo->clientUID);
reply.WriteInt32(capturerChangeInfo->capturerInfo.sourceType);
reply.WriteInt32(capturerChangeInfo->capturerInfo.capturerFlags);
}
AUDIO_DEBUG_LOG("AudioPolicyManagerStub:Capturer change info internal exit");
}
int AudioPolicyManagerStub::OnRemoteRequest(
uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
{
@ -464,6 +622,38 @@ int AudioPolicyManagerStub::OnRemoteRequest(
GetAudioLatencyFromXmlInternal(data, reply);
break;
case REGISTER_PLAYBACK_EVENT:
RegisterAudioRendererEventListenerInternal(data, reply);
break;
case UNREGISTER_PLAYBACK_EVENT:
UnregisterAudioRendererEventListenerInternal(data, reply);
break;
case REGISTER_RECORDING_EVENT:
RegisterAudioCapturerEventListenerInternal(data, reply);
break;
case UNREGISTER_RECORDING_EVENT:
UnregisterAudioCapturerEventListenerInternal(data, reply);
break;
case REGISTER_TRACKER:
RegisterTrackerInternal(data, reply);
break;
case UPDATE_TRACKER:
UpdateTrackerInternal(data, reply);
break;
case GET_RENDERER_CHANGE_INFOS:
GetRendererChangeInfosInternal(data, reply);
break;
case GET_CAPTURER_CHANGE_INFOS:
GetCapturerChangeInfosInternal(data, reply);
break;
default:
AUDIO_ERR_LOG("default case, need check AudioPolicyManagerStub");
return IPCObjectStub::OnRemoteRequest(code, data, reply, option);

113
services/src/audio_policy/server/audio_policy_server.cpp
View File

@ -20,7 +20,6 @@
#include "audio_errors.h"
#include "audio_policy_manager_listener_proxy.h"
#include "audio_ringermode_update_listener_proxy.h"
#include "audio_server_death_recipient.h"
#include "audio_volume_key_event_callback_proxy.h"
#include "i_standard_audio_policy_manager_listener.h"
@ -46,7 +45,8 @@ REGISTER_SYSTEM_ABILITY_BY_ID(AudioPolicyServer, AUDIO_POLICY_SERVICE_ID, true)
AudioPolicyServer::AudioPolicyServer(int32_t systemAbilityId, bool runOnCreate)
: SystemAbility(systemAbilityId, runOnCreate),
mPolicyService(AudioPolicyService::GetAudioPolicyService())
mPolicyService(AudioPolicyService::GetAudioPolicyService()),
mStreamCollector(AudioStreamCollector::GetAudioStreamCollector())
{
if (mPolicyService.SetAudioSessionCallback(this)) {
AUDIO_DEBUG_LOG("AudioPolicyServer: SetAudioSessionCallback failed");
@ -1117,5 +1117,114 @@ int32_t AudioPolicyServer::GetAudioLatencyFromXml()
{
return mPolicyService.GetAudioLatencyFromXml();
}
int32_t AudioPolicyServer::RegisterAudioRendererEventListener(int32_t clientUID, const sptr<IRemoteObject> &object)
{
RegisterClientDeathRecipient(object, LISTENER_CLIENT);
return mStreamCollector.RegisterAudioRendererEventListener(clientUID, object);
}
int32_t AudioPolicyServer::UnregisterAudioRendererEventListener(int32_t clientUID)
{
return mStreamCollector.UnregisterAudioRendererEventListener(clientUID);
}
int32_t AudioPolicyServer::RegisterAudioCapturerEventListener(int32_t clientUID, const sptr<IRemoteObject> &object)
{
RegisterClientDeathRecipient(object, LISTENER_CLIENT);
return mStreamCollector.RegisterAudioCapturerEventListener(clientUID, object);
}
int32_t AudioPolicyServer::UnregisterAudioCapturerEventListener(int32_t clientUID)
{
return mStreamCollector.UnregisterAudioCapturerEventListener(clientUID);
}
int32_t AudioPolicyServer::RegisterTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo,
const sptr<IRemoteObject> &object)
{
// update the clientUID
auto callerUid = IPCSkeleton::GetCallingUid();
AUDIO_INFO_LOG(" AudioPolicyServer::RegisterTracker : [caller uid:%{public}d]==", callerUid);
if (callerUid != MEDIA_SERVICE_UID) {
if (mode == AUDIO_MODE_PLAYBACK) {
streamChangeInfo.audioRendererChangeInfo.clientUID = callerUid;
AUDIO_DEBUG_LOG("Non media service caller, use the uid retrieved. ClientUID:%{public}d]",
streamChangeInfo.audioRendererChangeInfo.clientUID);
} else {
streamChangeInfo.audioCapturerChangeInfo.clientUID = callerUid;
AUDIO_DEBUG_LOG("Non media service caller, use the uid retrieved. ClientUID:%{public}d]",
streamChangeInfo.audioCapturerChangeInfo.clientUID);
}
}
RegisterClientDeathRecipient(object, TRACKER_CLIENT);
return mStreamCollector.RegisterTracker(mode, streamChangeInfo, object);
}
int32_t AudioPolicyServer::UpdateTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo)
{
// update the clientUID
auto callerUid = IPCSkeleton::GetCallingUid();
AUDIO_INFO_LOG(" AudioPolicyServer::UpdateTracker : [caller uid:%{public}d]==", callerUid);
if (callerUid != MEDIA_SERVICE_UID) {
if (mode == AUDIO_MODE_PLAYBACK) {
streamChangeInfo.audioRendererChangeInfo.clientUID = callerUid;
AUDIO_DEBUG_LOG("Non media service caller, use the uid retrieved. ClientUID:%{public}d]",
streamChangeInfo.audioRendererChangeInfo.clientUID);
} else {
streamChangeInfo.audioCapturerChangeInfo.clientUID = callerUid;
AUDIO_DEBUG_LOG("Non media service caller, use the uid retrieved. ClientUID:%{public}d]",
streamChangeInfo.audioCapturerChangeInfo.clientUID);
}
}
return mStreamCollector.UpdateTracker(mode, streamChangeInfo);
}
int32_t AudioPolicyServer::GetCurrentRendererChangeInfos(
vector<unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos)
{
return mStreamCollector.GetCurrentRendererChangeInfos(audioRendererChangeInfos);
}
int32_t AudioPolicyServer::GetCurrentCapturerChangeInfos(
vector<unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos)
{
return mStreamCollector.GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
}
void AudioPolicyServer::RegisterClientDeathRecipient(const sptr<IRemoteObject> &object, DeathRecipientId id)
{
AUDIO_INFO_LOG("Register clients death recipient");
CHECK_AND_RETURN_LOG(object != nullptr, "Client proxy obj NULL!!");
// Deliberately casting UID to pid_t
pid_t uid = static_cast<pid_t>(IPCSkeleton::GetCallingUid());
sptr<AudioServerDeathRecipient> deathRecipient_ = new(std::nothrow) AudioServerDeathRecipient(uid);
if (deathRecipient_ != nullptr) {
if (id == TRACKER_CLIENT) {
deathRecipient_->SetNotifyCb(std::bind(&AudioPolicyServer::RegisteredTrackerClientDied,
this, std::placeholders::_1));
} else {
deathRecipient_->SetNotifyCb(std::bind(&AudioPolicyServer::RegisteredStreamListenerClientDied,
this, std::placeholders::_1));
}
bool result = object->AddDeathRecipient(deathRecipient_);
if (!result) {
AUDIO_ERR_LOG("failed to add deathRecipient");
}
}
}
void AudioPolicyServer::RegisteredTrackerClientDied(pid_t pid)
{
AUDIO_INFO_LOG("RegisteredTrackerClient died: remove entry, uid %{public}d", pid);
mStreamCollector.RegisteredTrackerClientDied(static_cast<int32_t>(pid));
}
void AudioPolicyServer::RegisteredStreamListenerClientDied(pid_t pid)
{
AUDIO_INFO_LOG("RegisteredStreamListenerClient died: remove entry, uid %{public}d", pid);
mStreamCollector.RegisteredStreamListenerClientDied(static_cast<int32_t>(pid));
}
} // namespace AudioStandard
} // namespace OHOS

106
services/src/audio_policy/server/audio_renderer_state_change_listener_proxy.cpp Normal file
View File

@ -0,0 +1,106 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "audio_renderer_state_change_listener_proxy.h"
#include "audio_system_manager.h"
#include "audio_log.h"
using namespace std;
namespace OHOS {
namespace AudioStandard {
AudioRendererStateChangeListenerProxy::AudioRendererStateChangeListenerProxy(const sptr<IRemoteObject> &impl)
: IRemoteProxy<IStandardRendererStateChangeListener>(impl)
{
AUDIO_DEBUG_LOG("AudioRendererStateChangeListenerProxy:Instances create");
}
AudioRendererStateChangeListenerProxy::~AudioRendererStateChangeListenerProxy()
{
AUDIO_DEBUG_LOG("~AudioRendererStateChangeListenerProxy: Instance destroy");
}
void AudioRendererStateChangeListenerProxy::WriteRendererChangeInfo(MessageParcel &data,
const unique_ptr<AudioRendererChangeInfo> &rendererChangeInfo)
{
AUDIO_INFO_LOG("AudioRendererStateChangeListenerProxy WriteRendererChangeInfo sessionId = %{public}d",
rendererChangeInfo->sessionId);
AUDIO_INFO_LOG("AudioRendererStateChangeListenerProxy WriteRendererChangeInfo rendererState = %{public}d",
rendererChangeInfo->rendererState);
AUDIO_INFO_LOG("AudioRendererStateChangeListenerProxy WriteRendererChangeInfo client id = %{public}d",
rendererChangeInfo->clientUID);
AUDIO_INFO_LOG("AudioRendererStateChangeListenerProxy WriteRendererChangeInfo contenttype = %{public}d",
rendererChangeInfo->rendererInfo.contentType);
AUDIO_INFO_LOG("AudioRendererStateChangeListenerProxy WriteRendererChangeInfo streamusage = %{public}d",
rendererChangeInfo->rendererInfo.streamUsage);
AUDIO_INFO_LOG("AudioRendererStateChangeListenerProxy WriteRendererChangeInfo rendererflags = %{public}d",
rendererChangeInfo->rendererInfo.rendererFlags);
data.WriteInt32(rendererChangeInfo->sessionId);
data.WriteInt32(rendererChangeInfo->rendererState);
data.WriteInt32(rendererChangeInfo->clientUID);
data.WriteInt32(rendererChangeInfo->rendererInfo.contentType);
data.WriteInt32(rendererChangeInfo->rendererInfo.streamUsage);
data.WriteInt32(rendererChangeInfo->rendererInfo.rendererFlags);
}
void AudioRendererStateChangeListenerProxy::OnRendererStateChange(
const vector<unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos)
{
MessageParcel data;
MessageParcel reply;
MessageOption option;
AUDIO_DEBUG_LOG("AudioRendererStateChangeListenerProxy OnRendererStateChange entered");
if (!data.WriteInterfaceToken(GetDescriptor())) {
AUDIO_ERR_LOG("AudioRendererStateChangeListener: WriteInterfaceToken failed");
return;
}
size_t size = audioRendererChangeInfos.size();
data.WriteInt32(size);
for (const unique_ptr<AudioRendererChangeInfo> &rendererChangeInfo: audioRendererChangeInfos) {
WriteRendererChangeInfo(data, rendererChangeInfo);
}
int error = Remote()->SendRequest(ON_RENDERERSTATE_CHANGE, data, reply, option);
if (error != ERR_NONE) {
AUDIO_ERR_LOG("AudioRendererStateChangeListener failed, error: %{public}d", error);
}
return;
}
AudioRendererStateChangeListenerCallback::AudioRendererStateChangeListenerCallback(
const sptr<IStandardRendererStateChangeListener> &listener) : listener_(listener)
{
AUDIO_DEBUG_LOG("AudioRendererStateChangeListenerCallback: Instance create");
}
AudioRendererStateChangeListenerCallback::~AudioRendererStateChangeListenerCallback()
{
AUDIO_DEBUG_LOG("AudioRendererStateChangeListenerCallback: Instance destroy");
}
void AudioRendererStateChangeListenerCallback::OnRendererStateChange(
const vector<unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos)
{
AUDIO_DEBUG_LOG("AudioRendererStateChangeListenerCallback OnRendererStateChange entered");
if (listener_ != nullptr) {
listener_->OnRendererStateChange(audioRendererChangeInfos);
}
}
} // namespace AudioStandard
} // namespace OHOS

416
services/src/audio_policy/server/audio_stream_collector.cpp Normal file
View File

@ -0,0 +1,416 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "audio_stream_collector.h"
#include "audio_capturer_state_change_listener_proxy.h"
#include "audio_errors.h"
#include "audio_renderer_state_change_listener_proxy.h"
#include "audio_client_tracker_callback_proxy.h"
#include "i_standard_renderer_state_change_listener.h"
#include "i_standard_capturer_state_change_listener.h"
#include "i_standard_client_tracker.h"
namespace OHOS {
namespace AudioStandard {
using namespace std;
AudioStreamCollector::AudioStreamCollector() : mDispatcherService
(AudioStreamEventDispatcher::GetAudioStreamEventDispatcher())
{
AUDIO_INFO_LOG("AudioStreamCollector::AudioStreamCollector()");
}
AudioStreamCollector::~AudioStreamCollector()
{
AUDIO_INFO_LOG("AudioStreamCollector::~AudioStreamCollector()");
}
int32_t AudioStreamCollector::RegisterAudioRendererEventListener(int32_t clientUID, const sptr<IRemoteObject> &object)
{
AUDIO_INFO_LOG("AudioStreamCollector: RegisterAudioRendererEventListener client id %{public}d done", clientUID);
std::lock_guard<std::mutex> lock(rendererStateChangeEventMutex_);
CHECK_AND_RETURN_RET_LOG(object != nullptr, ERR_INVALID_PARAM,
"AudioStreamCollector:set renderer state change event listner object is nullptr");
sptr<IStandardRendererStateChangeListener> listener = iface_cast<IStandardRendererStateChangeListener>(object);
CHECK_AND_RETURN_RET_LOG(listener != nullptr, ERR_INVALID_PARAM,
"AudioStreamCollector: renderer listener obj cast failed");
std::shared_ptr<AudioRendererStateChangeCallback> callback =
std::make_shared<AudioRendererStateChangeListenerCallback>(listener);
CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM, "AudioStreamCollector: failed to create cb obj");
mDispatcherService.addRendererListener(clientUID, callback);
return SUCCESS;
}
int32_t AudioStreamCollector::UnregisterAudioRendererEventListener(int32_t clientUID)
{
AUDIO_INFO_LOG("AudioStreamCollector::UnregisterAudioRendererEventListener()");
mDispatcherService.removeRendererListener(clientUID);
return SUCCESS;
}
int32_t AudioStreamCollector::RegisterAudioCapturerEventListener(int32_t clientUID, const sptr<IRemoteObject> &object)
{
AUDIO_INFO_LOG("AudioStreamCollector: RegisterAudioCapturerEventListener for client id %{public}d done", clientUID);
std::lock_guard<std::mutex> lock(capturerStateChangeEventMutex_);
CHECK_AND_RETURN_RET_LOG(object != nullptr, ERR_INVALID_PARAM,
"AudioStreamCollector:set capturer event listner object is nullptr");
sptr<IStandardCapturerStateChangeListener> listener = iface_cast<IStandardCapturerStateChangeListener>(object);
CHECK_AND_RETURN_RET_LOG(listener != nullptr, ERR_INVALID_PARAM, "AudioStreamCollector: capturer obj cast failed");
std::shared_ptr<AudioCapturerStateChangeCallback> callback =
std::make_shared<AudioCapturerStateChangeListenerCallback>(listener);
CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM,
"AudioStreamCollector: failed to create capturer cb obj");
mDispatcherService.addCapturerListener(clientUID, callback);
return SUCCESS;
}
int32_t AudioStreamCollector::UnregisterAudioCapturerEventListener(int32_t clientUID)
{
AUDIO_INFO_LOG("AudioStreamCollector: UnregisterAudioCapturerEventListener client id %{public}d done", clientUID);
mDispatcherService.removeCapturerListener(clientUID);
return SUCCESS;
}
int32_t AudioStreamCollector::AddRendererStream(AudioStreamChangeInfo &streamChangeInfo)
{
AUDIO_INFO_LOG("AudioStreamCollector: AddRendererStream playback client id %{public}d session %{public}d",
streamChangeInfo.audioRendererChangeInfo.clientUID, streamChangeInfo.audioRendererChangeInfo.sessionId);
rendererStatequeue_.insert({{streamChangeInfo.audioRendererChangeInfo.clientUID,
streamChangeInfo.audioRendererChangeInfo.sessionId},
streamChangeInfo.audioRendererChangeInfo.rendererState});
unique_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_unique<AudioRendererChangeInfo>();
if (!rendererChangeInfo) {
AUDIO_ERR_LOG("AudioStreamCollector::AddRendererStream Memory Allocation Failed");
return ERR_MEMORY_ALLOC_FAILED;
}
rendererChangeInfo->clientUID = streamChangeInfo.audioRendererChangeInfo.clientUID;
rendererChangeInfo->sessionId = streamChangeInfo.audioRendererChangeInfo.sessionId;
rendererChangeInfo->rendererState = streamChangeInfo.audioRendererChangeInfo.rendererState;
rendererChangeInfo->rendererInfo = streamChangeInfo.audioRendererChangeInfo.rendererInfo;
audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
AUDIO_DEBUG_LOG("AudioStreamCollector: audioRendererChangeInfos_: Added for client %{public}d session %{public}d",
streamChangeInfo.audioRendererChangeInfo.clientUID, streamChangeInfo.audioRendererChangeInfo.sessionId);
mDispatcherService.SendRendererInfoEventToDispatcher(AudioMode::AUDIO_MODE_PLAYBACK, audioRendererChangeInfos_);
return SUCCESS;
}
int32_t AudioStreamCollector::AddCapturerStream(AudioStreamChangeInfo &streamChangeInfo)
{
AUDIO_INFO_LOG("AudioStreamCollector: AddCapturerStream recording client id %{public}d session %{public}d",
streamChangeInfo.audioCapturerChangeInfo.clientUID, streamChangeInfo.audioCapturerChangeInfo.sessionId);
capturerStatequeue_.insert({{streamChangeInfo.audioCapturerChangeInfo.clientUID,
streamChangeInfo.audioCapturerChangeInfo.sessionId},
streamChangeInfo.audioCapturerChangeInfo.capturerState});
unique_ptr<AudioCapturerChangeInfo> capturerChangeInfo = make_unique<AudioCapturerChangeInfo>();
if (!capturerChangeInfo) {
AUDIO_ERR_LOG("AudioStreamCollector::AddCapturerStream Memory Allocation Failed");
return ERR_MEMORY_ALLOC_FAILED;
}
capturerChangeInfo->clientUID = streamChangeInfo.audioCapturerChangeInfo.clientUID;
capturerChangeInfo->sessionId = streamChangeInfo.audioCapturerChangeInfo.sessionId;
capturerChangeInfo->capturerState = streamChangeInfo.audioCapturerChangeInfo.capturerState;
capturerChangeInfo->capturerInfo = streamChangeInfo.audioCapturerChangeInfo.capturerInfo;
audioCapturerChangeInfos_.push_back(move(capturerChangeInfo));
AUDIO_DEBUG_LOG("AudioStreamCollector: audioCapturerChangeInfos_: Added for client %{public}d session %{public}d",
streamChangeInfo.audioCapturerChangeInfo.clientUID, streamChangeInfo.audioCapturerChangeInfo.sessionId);
mDispatcherService.SendCapturerInfoEventToDispatcher(AudioMode::AUDIO_MODE_RECORD, audioCapturerChangeInfos_);
return SUCCESS;
}
int32_t AudioStreamCollector::RegisterTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo,
const sptr<IRemoteObject> &object)
{
AUDIO_INFO_LOG("AudioStreamCollector: RegisterTracker mode %{public}d", mode);
DisplayInternalStreamInfo();
int32_t clientUID;
if (mode == AUDIO_MODE_PLAYBACK) {
AddRendererStream(streamChangeInfo);
clientUID = streamChangeInfo.audioRendererChangeInfo.clientUID;
} else {
// mode = AUDIO_MODE_RECORD
AddCapturerStream(streamChangeInfo);
clientUID = streamChangeInfo.audioCapturerChangeInfo.clientUID;
}
DisplayInternalStreamInfo();
sptr<IStandardClientTracker> listener = iface_cast<IStandardClientTracker>(object);
CHECK_AND_RETURN_RET_LOG(listener != nullptr,
ERR_INVALID_PARAM, "AudioStreamCollector: client tracker obj cast failed");
std::shared_ptr<AudioClientTracker> callback = std::make_shared<ClientTrackerCallbackListener>(listener);
CHECK_AND_RETURN_RET_LOG(callback != nullptr,
ERR_INVALID_PARAM, "AudioStreamCollector: failed to create tracker cb obj");
clientTracker_[clientUID] = callback;
return SUCCESS;
}
int32_t AudioStreamCollector::UpdateRendererStream(AudioStreamChangeInfo &streamChangeInfo)
{
AUDIO_INFO_LOG("AudioStreamCollector: UpdateRendererStream client %{public}d state %{public}d session %{public}d",
streamChangeInfo.audioRendererChangeInfo.clientUID, streamChangeInfo.audioRendererChangeInfo.rendererState,
streamChangeInfo.audioRendererChangeInfo.sessionId);
if (rendererStatequeue_.find(make_pair(streamChangeInfo.audioRendererChangeInfo.clientUID,
streamChangeInfo.audioRendererChangeInfo.sessionId)) != rendererStatequeue_.end()) {
if (streamChangeInfo.audioRendererChangeInfo.rendererState ==
rendererStatequeue_[make_pair(streamChangeInfo.audioRendererChangeInfo.clientUID,
streamChangeInfo.audioRendererChangeInfo.sessionId)]) {
// Renderer state not changed
AUDIO_DEBUG_LOG("UpdateRendererStream playback state no change clientid %{public}d sessionId %{public}d",
streamChangeInfo.audioRendererChangeInfo.clientUID,
streamChangeInfo.audioRendererChangeInfo.sessionId);
return SUCCESS;
}
} else {
AUDIO_INFO_LOG("UpdateRendererStream client %{public}d not found in rendererStatequeue_",
streamChangeInfo.audioRendererChangeInfo.clientUID);
}
// Update the renderer info in audioRendererChangeInfos_
for (auto it = audioRendererChangeInfos_.begin(); it != audioRendererChangeInfos_.end(); it++) {
AudioRendererChangeInfo audioRendererChangeInfo = **it;
if (audioRendererChangeInfo.clientUID == streamChangeInfo.audioRendererChangeInfo.clientUID &&
audioRendererChangeInfo.sessionId == streamChangeInfo.audioRendererChangeInfo.sessionId) {
rendererStatequeue_[make_pair(audioRendererChangeInfo.clientUID, audioRendererChangeInfo.sessionId)] =
streamChangeInfo.audioRendererChangeInfo.rendererState;
AUDIO_DEBUG_LOG("AudioStreamCollector: UpdateRendererStream: update client %{public}d session %{public}d",
audioRendererChangeInfo.clientUID, audioRendererChangeInfo.sessionId);
unique_ptr<AudioRendererChangeInfo> RendererChangeInfo = make_unique<AudioRendererChangeInfo>();
RendererChangeInfo->clientUID = streamChangeInfo.audioRendererChangeInfo.clientUID;
RendererChangeInfo->sessionId = streamChangeInfo.audioRendererChangeInfo.sessionId;
RendererChangeInfo->rendererState = streamChangeInfo.audioRendererChangeInfo.rendererState;
RendererChangeInfo->rendererInfo = streamChangeInfo.audioRendererChangeInfo.rendererInfo;
*it = move(RendererChangeInfo);
AUDIO_DEBUG_LOG("AudioStreamCollector: Playback details updated, to be dispatched");
mDispatcherService.SendRendererInfoEventToDispatcher(AudioMode::AUDIO_MODE_PLAYBACK,
audioRendererChangeInfos_);
if (streamChangeInfo.audioRendererChangeInfo.rendererState == RENDERER_RELEASED) {
audioRendererChangeInfos_.erase(it);
AUDIO_DEBUG_LOG("AudioStreamCollector: Session removed for client %{public}d session %{public}d",
streamChangeInfo.audioRendererChangeInfo.clientUID,
streamChangeInfo.audioRendererChangeInfo.sessionId);
rendererStatequeue_.erase(make_pair(audioRendererChangeInfo.clientUID,
audioRendererChangeInfo.sessionId));
}
return SUCCESS;
}
}
AUDIO_INFO_LOG("UpdateRendererStream: Not found clientUid:%{public}d sessionId:%{public}d",
streamChangeInfo.audioRendererChangeInfo.clientUID, streamChangeInfo.audioRendererChangeInfo.clientUID);
return SUCCESS;
}
int32_t AudioStreamCollector::UpdateCapturerStream(AudioStreamChangeInfo &streamChangeInfo)
{
AUDIO_INFO_LOG("AudioStreamCollector: UpdateCapturerStream client %{public}d state %{public}d session %{public}d",
streamChangeInfo.audioCapturerChangeInfo.clientUID, streamChangeInfo.audioCapturerChangeInfo.capturerState,
streamChangeInfo.audioCapturerChangeInfo.sessionId);
if (capturerStatequeue_.find(make_pair(streamChangeInfo.audioCapturerChangeInfo.clientUID,
streamChangeInfo.audioCapturerChangeInfo.sessionId)) != capturerStatequeue_.end()) {
if (streamChangeInfo.audioCapturerChangeInfo.capturerState ==
capturerStatequeue_[make_pair(streamChangeInfo.audioCapturerChangeInfo.clientUID,
streamChangeInfo.audioCapturerChangeInfo.sessionId)]) {
// Capturer state not changed
AUDIO_DEBUG_LOG("UpdateCapturerStream recorder state no change clientid %{public}d sessionId %{public}d",
streamChangeInfo.audioCapturerChangeInfo.clientUID,
streamChangeInfo.audioCapturerChangeInfo.sessionId);
return SUCCESS;
}
} else {
AUDIO_INFO_LOG("AudioStreamCollector: UpdateCapturerStream client %{public}d not found in capturerStatequeue_",
streamChangeInfo.audioCapturerChangeInfo.clientUID);
}
// Update the capturer info in audioCapturerChangeInfos_
for (auto it = audioCapturerChangeInfos_.begin(); it != audioCapturerChangeInfos_.end(); it++) {
AudioCapturerChangeInfo audioCapturerChangeInfo = **it;
if (audioCapturerChangeInfo.clientUID == streamChangeInfo.audioCapturerChangeInfo.clientUID &&
audioCapturerChangeInfo.sessionId == streamChangeInfo.audioCapturerChangeInfo.sessionId) {
capturerStatequeue_[make_pair(audioCapturerChangeInfo.clientUID, audioCapturerChangeInfo.sessionId)] =
streamChangeInfo.audioCapturerChangeInfo.capturerState;
AUDIO_DEBUG_LOG("AudioStreamCollector: Session is updated for client %{public}d session %{public}d",
streamChangeInfo.audioCapturerChangeInfo.clientUID,
streamChangeInfo.audioCapturerChangeInfo.sessionId);
unique_ptr<AudioCapturerChangeInfo> CapturerChangeInfo = make_unique<AudioCapturerChangeInfo>();
CapturerChangeInfo->clientUID = streamChangeInfo.audioCapturerChangeInfo.clientUID;
CapturerChangeInfo->sessionId = streamChangeInfo.audioCapturerChangeInfo.sessionId;
CapturerChangeInfo->capturerState = streamChangeInfo.audioCapturerChangeInfo.capturerState;
CapturerChangeInfo->capturerInfo = streamChangeInfo.audioCapturerChangeInfo.capturerInfo;
*it = move(CapturerChangeInfo);
AUDIO_DEBUG_LOG("AudioStreamCollector: Recorder details updated");
mDispatcherService.SendCapturerInfoEventToDispatcher(AudioMode::AUDIO_MODE_RECORD,
audioCapturerChangeInfos_);
if (streamChangeInfo.audioCapturerChangeInfo.capturerState == CAPTURER_RELEASED) {
audioCapturerChangeInfos_.erase(it);
AUDIO_DEBUG_LOG("UpdateCapturerStream::Session is removed for client %{public}d session %{public}d",
streamChangeInfo.audioCapturerChangeInfo.clientUID,
streamChangeInfo.audioCapturerChangeInfo.sessionId);
capturerStatequeue_.erase(make_pair(audioCapturerChangeInfo.clientUID,
audioCapturerChangeInfo.sessionId));
}
return SUCCESS;
}
}
AUDIO_INFO_LOG("AudioStreamCollector:UpdateCapturerStream: clientUI not in audioCapturerChangeInfos_::%{public}d",
streamChangeInfo.audioCapturerChangeInfo.clientUID);
return SUCCESS;
}
int32_t AudioStreamCollector::UpdateTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo)
{
DisplayInternalStreamInfo();
// update the stream change info
if (mode == AUDIO_MODE_PLAYBACK) {
UpdateRendererStream(streamChangeInfo);
} else {
// mode = AUDIO_MODE_RECORD
UpdateCapturerStream(streamChangeInfo);
}
DisplayInternalStreamInfo();
return SUCCESS;
}
void AudioStreamCollector::DisplayInternalStreamInfo()
{
AUDIO_DEBUG_LOG("AudioStreamCollector: Display audioRendererChangeInfos_ Number of entries %{public}u",
static_cast<uint32_t>(audioRendererChangeInfos_.size()));
int index = 0;
for (auto it = audioRendererChangeInfos_.begin(); it != audioRendererChangeInfos_.end(); it++) {
AudioRendererChangeInfo audioRendererChangeInfo = **it;
AUDIO_DEBUG_LOG("audioRendererChangeInfos_[%{public}d]", index++);
AUDIO_DEBUG_LOG("clientUID = %{public}d", audioRendererChangeInfo.clientUID);
AUDIO_DEBUG_LOG("sessionId = %{public}d", audioRendererChangeInfo.sessionId);
AUDIO_DEBUG_LOG("rendererState = %{public}d", audioRendererChangeInfo.rendererState);
}
AUDIO_DEBUG_LOG("rendererStatequeue_");
for (auto const &pair: rendererStatequeue_) {
AUDIO_DEBUG_LOG("clientUID: %{public}d:sessionId %{public}d :: RendererState : %{public}d",
pair.first.first, pair.first.second, pair.second);
}
AUDIO_DEBUG_LOG("AudioStreamCollector: Display audioCapturerChangeInfos_ Number of entries %{public}u",
static_cast<uint32_t>(audioCapturerChangeInfos_.size()));
index = 0;
for (auto it = audioCapturerChangeInfos_.begin(); it != audioCapturerChangeInfos_.end(); it++) {
AudioCapturerChangeInfo audioCapturerChangeInfo = **it;
AUDIO_DEBUG_LOG("audioCapturerChangeInfos_[%{public}d]", index++);
AUDIO_DEBUG_LOG("clientUID = %{public}d", audioCapturerChangeInfo.clientUID);
AUDIO_DEBUG_LOG("sessionId = %{public}d", audioCapturerChangeInfo.sessionId);
AUDIO_DEBUG_LOG("capturerState = %{public}d", audioCapturerChangeInfo.capturerState);
}
AUDIO_DEBUG_LOG("capturerStatequeue_");
for (auto const &pair: capturerStatequeue_) {
AUDIO_DEBUG_LOG("clientUID: %{public}d sessionId %{public}d :: CapturerState : %{public}d",
pair.first.first, pair.first.second, pair.second);
}
}
int32_t AudioStreamCollector::GetCurrentRendererChangeInfos(
vector<unique_ptr<AudioRendererChangeInfo>> &rendererChangeInfos)
{
DisplayInternalStreamInfo();
for (const auto &changeInfo : audioRendererChangeInfos_) {
rendererChangeInfos.push_back(make_unique<AudioRendererChangeInfo>(*changeInfo));
}
AUDIO_DEBUG_LOG("AudioStreamCollector::GetCurrentRendererChangeInfos returned");
return SUCCESS;
}
int32_t AudioStreamCollector::GetCurrentCapturerChangeInfos(
vector<unique_ptr<AudioCapturerChangeInfo>> &capturerChangeInfos)
{
AUDIO_DEBUG_LOG("AudioStreamCollector::GetCurrentCapturerChangeInfos");
DisplayInternalStreamInfo();
for (const auto &changeInfo : audioCapturerChangeInfos_) {
capturerChangeInfos.push_back(make_unique<AudioCapturerChangeInfo>(*changeInfo));
AUDIO_DEBUG_LOG("AudioStreamCollector::GetCurrentCapturerChangeInfos returned");
}
return SUCCESS;
}
void AudioStreamCollector::RegisteredTrackerClientDied(int32_t uid)
{
AUDIO_DEBUG_LOG("TrackerClientDied:client %{public}d Died", uid);
// Send the release state event notification for all stream of died client to registered app
for (auto it = audioRendererChangeInfos_.begin(); it != audioRendererChangeInfos_.end(); it++) {
AudioRendererChangeInfo audioRendererChangeInfo = **it;
if (audioRendererChangeInfo.clientUID == uid) {
AUDIO_DEBUG_LOG("TrackerClientDied:client %{public}d session %{public}d Renderer Release",
uid, audioRendererChangeInfo.sessionId);
audioRendererChangeInfo.rendererState = RENDERER_RELEASED;
mDispatcherService.SendRendererInfoEventToDispatcher(AudioMode::AUDIO_MODE_PLAYBACK,
audioRendererChangeInfos_);
rendererStatequeue_.erase(make_pair(audioRendererChangeInfo.clientUID, audioRendererChangeInfo.sessionId));
audioRendererChangeInfos_.erase(it);
}
}
for (auto it = audioCapturerChangeInfos_.begin(); it != audioCapturerChangeInfos_.end(); it++) {
AudioCapturerChangeInfo audioCapturerChangeInfo = **it;
if (audioCapturerChangeInfo.clientUID == uid) {
AUDIO_DEBUG_LOG("TrackerClientDied:client %{public}d session %{public}d Capturer Release",
uid, audioCapturerChangeInfo.sessionId);
audioCapturerChangeInfo.capturerState = CAPTURER_RELEASED;
mDispatcherService.SendCapturerInfoEventToDispatcher(AudioMode::AUDIO_MODE_RECORD,
audioCapturerChangeInfos_);
capturerStatequeue_.erase(make_pair(audioCapturerChangeInfo.clientUID, audioCapturerChangeInfo.sessionId));
audioCapturerChangeInfos_.erase(it);
}
}
if (clientTracker_.erase(uid)) {
AUDIO_DEBUG_LOG("AudioStreamCollector::TrackerClientDied:client %{public}d done", uid);
return;
}
AUDIO_INFO_LOG("AudioStreamCollector::TrackerClientDied:client %{public}d not present", uid);
}
void AudioStreamCollector::RegisteredStreamListenerClientDied(int32_t uid)
{
AUDIO_INFO_LOG("AudioStreamCollector::StreamListenerClientDied:client %{public}d", uid);
mDispatcherService.removeRendererListener(uid);
mDispatcherService.removeCapturerListener(uid);
}
} // namespace AudioStandard
} // namespace OHOS

165
services/src/audio_policy/server/audio_stream_event_dispatcher.cpp Normal file
View File

@ -0,0 +1,165 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "audio_stream_event_dispatcher.h"
#include "i_standard_capturer_state_change_listener.h"
#include "i_standard_renderer_state_change_listener.h"
namespace OHOS {
namespace AudioStandard {
AudioStreamEventDispatcher::AudioStreamEventDispatcher() : activeThread_(0)
{
AUDIO_DEBUG_LOG("AudioStreamEventDispatcher::AudioStreamEventDispatcher()");
}
AudioStreamEventDispatcher::~AudioStreamEventDispatcher()
{
AUDIO_DEBUG_LOG("AudioStreamEventDispatcher::~AudioStreamEventDispatcher()");
}
void AudioStreamEventDispatcher::addRendererListener(int32_t clientUID,
const std::shared_ptr<AudioRendererStateChangeCallback> &callback)
{
rendererCBMap_[clientUID] = callback;
AUDIO_DEBUG_LOG("AudioStreamEventDispatcher::addRendererListener:client %{public}d added", clientUID);
}
void AudioStreamEventDispatcher::removeRendererListener(int32_t clientUID)
{
if (rendererCBMap_.erase(clientUID)) {
AUDIO_INFO_LOG("AudioStreamEventDispatcher::removeRendererListener:client %{public}d done", clientUID);
return;
}
AUDIO_DEBUG_LOG("AudioStreamEventDispatcher::removeRendererListener:client %{public}d not present", clientUID);
}
void AudioStreamEventDispatcher::addCapturerListener(int32_t clientUID,
const std::shared_ptr<AudioCapturerStateChangeCallback> &callback)
{
capturerCBMap_[clientUID] = callback;
AUDIO_DEBUG_LOG("AudioStreamEventDispatcher::addCapturerListener:client %{public}d added", clientUID);
}
void AudioStreamEventDispatcher::removeCapturerListener(int32_t clientUID)
{
if (capturerCBMap_.erase(clientUID)) {
AUDIO_INFO_LOG("AudioStreamEventDispatcher::removeCapturerListener:client %{public}d done", clientUID);
return;
}
AUDIO_DEBUG_LOG("AudioStreamEventDispatcher::removeCapturerListener:client %{public}d not present", clientUID);
}
void AudioStreamEventDispatcher::SendRendererInfoEventToDispatcher(AudioMode mode,
std::vector<std::unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos)
{
AUDIO_DEBUG_LOG("AudioStreamEventDispatcher::SendRendererInfoEventToDispatcher:mode %{public}d ", mode);
unique_ptr<StreamStateChangeRequest> streamStateChangeRequest = make_unique<StreamStateChangeRequest>();
std::vector<std::unique_ptr<AudioRendererChangeInfo>> rendererChangeInfos;
for (const auto &changeInfo : audioRendererChangeInfos) {
rendererChangeInfos.push_back(std::make_unique<AudioRendererChangeInfo>(*changeInfo));
}
if (!streamStateChangeRequest) {
AUDIO_ERR_LOG("AudioStreamEventDispatcher::SendRendererInfoEventToDispatcher:Memory alloc failed!!");
return;
}
streamStateChangeRequest->mode = mode;
streamStateChangeRequest->audioRendererChangeInfos = move(rendererChangeInfos);
streamStateChangeQueue_.push(move(streamStateChangeRequest));
DispatcherEvent();
}
void AudioStreamEventDispatcher::SendCapturerInfoEventToDispatcher(AudioMode mode,
std::vector<std::unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos)
{
AUDIO_DEBUG_LOG("AudioStreamEventDispatcher::SendCapturerInfoEventToDispatcher:mode %{public}d ", mode);
std::vector<std::unique_ptr<AudioCapturerChangeInfo>> capturerChangeInfos;
for (const auto &changeInfo : audioCapturerChangeInfos) {
capturerChangeInfos.push_back(std::make_unique<AudioCapturerChangeInfo>(*changeInfo));
}
unique_ptr<StreamStateChangeRequest> streamStateChangeRequest = make_unique<StreamStateChangeRequest>();
if (!streamStateChangeRequest) {
AUDIO_ERR_LOG("AudioStreamEventDispatcher::Memory alloc failed!!");
return;
}
streamStateChangeRequest->mode = mode;
streamStateChangeRequest->audioCapturerChangeInfos = move(capturerChangeInfos);
streamStateChangeQueue_.push(move(streamStateChangeRequest));
DispatcherEvent();
}
void AudioStreamEventDispatcher::HandleRendererStreamStateChange(
const unique_ptr<StreamStateChangeRequest> &streamStateChangeRequest)
{
for (auto it = rendererCBMap_.begin(); it != rendererCBMap_.end(); ++it) {
std::shared_ptr<AudioRendererStateChangeCallback> rendererStateChangeCb = it->second;
if (rendererStateChangeCb == nullptr) {
rendererCBMap_.erase(it->first);
AUDIO_ERR_LOG("rendererStateChangeCb : nullptr for client : %{public}d", it->first);
continue;
}
AUDIO_DEBUG_LOG("rendererStateChangeCb : client = %{public}d", it->first);
rendererStateChangeCb->OnRendererStateChange(streamStateChangeRequest->audioRendererChangeInfos);
}
}
void AudioStreamEventDispatcher::HandleCapturerStreamStateChange(
const unique_ptr<StreamStateChangeRequest> &streamStateChangeRequest)
{
for (auto it = capturerCBMap_.begin(); it != capturerCBMap_.end(); ++it) {
std::shared_ptr<AudioCapturerStateChangeCallback> capturerStateChangeCb = it->second;
if (capturerStateChangeCb == nullptr) {
capturerCBMap_.erase(it->first);
AUDIO_ERR_LOG("capturerStateChangeCb : nullptr for client : %{public}d", it->first);
continue;
}
AUDIO_DEBUG_LOG("capturerStateChangeCb : client = %{public}d", it->first);
capturerStateChangeCb->OnCapturerStateChange(streamStateChangeRequest->audioCapturerChangeInfos);
}
}
void AudioStreamEventDispatcher::HandleStreamStateChange()
{
AUDIO_DEBUG_LOG("HandleStreamStateChange entered");
while (!streamStateChangeQueue_.empty()) {
std::unique_ptr<StreamStateChangeRequest> streamStateChangeRequest =
std::move(streamStateChangeQueue_.front());
if (streamStateChangeRequest->mode == AUDIO_MODE_PLAYBACK) {
HandleRendererStreamStateChange(streamStateChangeRequest);
} else {
HandleCapturerStreamStateChange(streamStateChangeRequest);
}
streamStateChangeQueue_.pop();
}
activeThread_ --;
}
void AudioStreamEventDispatcher::DispatcherEvent()
{
AUDIO_DEBUG_LOG("DispatcherEvent entered");
size_t avlThread = MAX_THREAD - activeThread_;
for (size_t i = 0; i < avlThread; i++) {
if (!streamStateChangeQueue_.empty() && (activeThread_ < streamStateChangeQueue_.size())) {
std::thread(&AudioStreamEventDispatcher::HandleStreamStateChange, this).detach();
activeThread_++;
}
}
}
} // namespace AudioStandard
} // namespace OHOS

80
services/src/audio_service/client/audio_stream.cpp
View File

@ -80,20 +80,23 @@ map<pair<ContentType, StreamUsage>, AudioStreamType> AudioStream::CreateStreamMa
return streamMap;
}
AudioStream::AudioStream(AudioStreamType eStreamType, AudioMode eMode) : eStreamType_(eStreamType),
eMode_(eMode),
state_(NEW),
isReadInProgress_(false),
isWriteInProgress_(false),
resetTime_(false),
resetTimestamp_(0),
renderMode_(RENDER_MODE_NORMAL),
captureMode_(CAPTURE_MODE_NORMAL),
isReadyToWrite_(false),
isReadyToRead_(false),
isFirstRead_(false)
AudioStream::AudioStream(AudioStreamType eStreamType, AudioMode eMode, int32_t appUid)
: eStreamType_(eStreamType),
eMode_(eMode),
state_(NEW),
isReadInProgress_(false),
isWriteInProgress_(false),
resetTime_(false),
resetTimestamp_(0),
renderMode_(RENDER_MODE_NORMAL),
captureMode_(CAPTURE_MODE_NORMAL),
isReadyToWrite_(false),
isReadyToRead_(false),
isFirstRead_(false)
{
AUDIO_DEBUG_LOG("AudioStream ctor");
AUDIO_DEBUG_LOG("AudioStream ctor, appUID = %{public}d", appUid);
audioStreamTracker_ = std::make_unique<AudioStreamTracker>(eMode, appUid);
AUDIO_DEBUG_LOG("AudioStreamTracker created");
}
AudioStream::~AudioStream()
@ -112,6 +115,24 @@ AudioStream::~AudioStream()
if (state_ != RELEASED && state_ != NEW) {
ReleaseAudioStream();
}
if (audioStreamTracker_) {
AUDIO_DEBUG_LOG("AudioStream:~AudioStream:Calling update tracker");
AudioRendererInfo rendererInfo = {};
AudioCapturerInfo capturerInfo = {};
state_ = RELEASED;
audioStreamTracker_->UpdateTracker(sessionId_, state_, rendererInfo, capturerInfo);
}
}
void AudioStream::SetRendererInfo(const AudioRendererInfo &rendererInfo)
{
rendererInfo_ = rendererInfo;
}
void AudioStream::SetCapturerInfo(const AudioCapturerInfo &capturerInfo)
{
capturerInfo_ = capturerInfo;
}
State AudioStream::GetState()
@ -119,7 +140,7 @@ State AudioStream::GetState()
return state_;
}
int32_t AudioStream::GetAudioSessionID(uint32_t &sessionID) const
int32_t AudioStream::GetAudioSessionID(uint32_t &sessionID)
{
if ((state_ == RELEASED) || (state_ == NEW)) {
return ERR_ILLEGAL_STATE;
@ -129,6 +150,8 @@ int32_t AudioStream::GetAudioSessionID(uint32_t &sessionID) const
return ERR_INVALID_INDEX;
}
sessionId_ = sessionID;
return SUCCESS;
}
@ -257,7 +280,8 @@ bool AudioStream::VerifyClientPermission(const std::string &permissionName, uint
return AudioServiceClient::VerifyClientPermission(permissionName, appTokenId);
}
int32_t AudioStream::SetAudioStreamInfo(const AudioStreamParams info)
int32_t AudioStream::SetAudioStreamInfo(const AudioStreamParams info,
const std::shared_ptr<AudioClientTracker> &proxyObj)
{
AUDIO_INFO_LOG("AudioStream: SetAudioParams");
AUDIO_DEBUG_LOG("AudioStream: Sampling rate: %{public}d", info.samplingRate);
@ -274,7 +298,6 @@ int32_t AudioStream::SetAudioStreamInfo(const AudioStreamParams info)
StopAudioStream();
ReleaseAudioStream();
}
int32_t ret = 0;
switch (eMode_) {
case AUDIO_MODE_PLAYBACK:
@ -301,14 +324,18 @@ int32_t AudioStream::SetAudioStreamInfo(const AudioStreamParams info)
AUDIO_DEBUG_LOG("AudioStream: Error initializing!");
return ret;
}
if (CreateStream(info, eStreamType_) != SUCCESS) {
AUDIO_ERR_LOG("AudioStream:Create stream failed");
return ERROR;
}
state_ = PREPARED;
AUDIO_INFO_LOG("AudioStream:Set stream Info SUCCESS");
if (audioStreamTracker_) {
(void)GetSessionID(sessionId_);
AUDIO_DEBUG_LOG("AudioStream:Calling register tracker, sessionid = %{public}d", sessionId_);
audioStreamTracker_->RegisterTracker(sessionId_, state_, rendererInfo_, capturerInfo_, proxyObj);
}
return SUCCESS;
}
@ -342,6 +369,11 @@ bool AudioStream::StartAudioStream()
isFirstRead_ = true;
state_ = RUNNING;
AUDIO_INFO_LOG("StartAudioStream SUCCESS");
if (audioStreamTracker_) {
AUDIO_DEBUG_LOG("AudioStream:Calling Update tracker for Running");
audioStreamTracker_->UpdateTracker(sessionId_, state_, rendererInfo_, capturerInfo_);
}
return true;
}
@ -441,6 +473,10 @@ bool AudioStream::PauseAudioStream()
AUDIO_INFO_LOG("PauseAudioStream SUCCESS");
if (audioStreamTracker_) {
AUDIO_DEBUG_LOG("AudioStream:Calling Update tracker for Pause");
audioStreamTracker_->UpdateTracker(sessionId_, state_, rendererInfo_, capturerInfo_);
}
return true;
}
@ -483,6 +519,10 @@ bool AudioStream::StopAudioStream()
AUDIO_INFO_LOG("StopAudioStream SUCCESS");
if (audioStreamTracker_) {
AUDIO_DEBUG_LOG("AudioStream:Calling Update tracker for stop");
audioStreamTracker_->UpdateTracker(sessionId_, state_, rendererInfo_, capturerInfo_);
}
return true;
}
@ -535,6 +575,10 @@ bool AudioStream::ReleaseAudioStream()
state_ = RELEASED;
AUDIO_INFO_LOG("ReleaseAudiostream SUCCESS");
if (audioStreamTracker_) {
AUDIO_DEBUG_LOG("AudioStream:Calling Update tracker for release");
audioStreamTracker_->UpdateTracker(sessionId_, state_, rendererInfo_, capturerInfo_);
}
return true;
}

78
services/src/audio_service/client/audio_stream_manager.cpp Normal file
View File

@ -0,0 +1,78 @@
/*
* Copyright (c) 2021-2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "audio_errors.h"
#include "audio_policy_manager.h"
#include "audio_log.h"
#include "audio_stream_manager.h"
namespace OHOS {
namespace AudioStandard {
using namespace std;
AudioStreamManager *AudioStreamManager::GetInstance()
{
static AudioStreamManager audioStreamManager;
return &audioStreamManager;
}
int32_t AudioStreamManager::RegisterAudioRendererEventListener(const int32_t clientUID,
const std::shared_ptr<AudioRendererStateChangeCallback> &callback)
{
AUDIO_INFO_LOG("AudioStreamManager:: RegisterAudioRendererEventListener client id: %{public}d", clientUID);
if (callback == nullptr) {
AUDIO_ERR_LOG("AudioStreamManager::callback is null");
return ERR_INVALID_PARAM;
}
return AudioPolicyManager::GetInstance().RegisterAudioRendererEventListener(clientUID, callback);
}
int32_t AudioStreamManager::UnregisterAudioRendererEventListener(const int32_t clientUID)
{
AUDIO_INFO_LOG("AudioStreamManager:: UnregisterAudioRendererEventListener client id: %{public}d", clientUID);
return AudioPolicyManager::GetInstance().UnregisterAudioRendererEventListener(clientUID);
}
int32_t AudioStreamManager::RegisterAudioCapturerEventListener(const int32_t clientUID,
const std::shared_ptr<AudioCapturerStateChangeCallback> &callback)
{
AUDIO_INFO_LOG("AudioStreamManager:: RegisterAudioCapturerEventListener client id: %{public}d", clientUID);
if (callback == nullptr) {
AUDIO_ERR_LOG("AudioStreamManager::callback is null");
return ERR_INVALID_PARAM;
}
return AudioPolicyManager::GetInstance().RegisterAudioCapturerEventListener(clientUID, callback);
}
int32_t AudioStreamManager::UnregisterAudioCapturerEventListener(const int32_t clientUID)
{
AUDIO_INFO_LOG("AudioStreamManager:: UnregisterAudioCapturerEventListener client id: %{public}d", clientUID);
return AudioPolicyManager::GetInstance().UnregisterAudioCapturerEventListener(clientUID);
}
int32_t AudioStreamManager::GetCurrentRendererChangeInfos(
vector<unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos)
{
AUDIO_INFO_LOG("AudioStreamManager:: GetCurrentRendererChangeInfos");
return AudioPolicyManager::GetInstance().GetCurrentRendererChangeInfos(audioRendererChangeInfos);
}
int32_t AudioStreamManager::GetCurrentCapturerChangeInfos(
vector<unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos)
{
AUDIO_INFO_LOG("AudioStreamManager:: GetCurrentCapturerChangeInfos");
return AudioPolicyManager::GetInstance().GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
}
} // namespace AudioStandard
} // namespace OHOS

84
services/src/audio_service/client/audio_stream_tracker.cpp Normal file
View File

@ -0,0 +1,84 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "audio_stream_tracker.h"
namespace OHOS {
namespace AudioStandard {
AudioStreamTracker::AudioStreamTracker(AudioMode mode, int32_t clientUID)
{
AUDIO_DEBUG_LOG("AudioStreamtracker:CTOR");
eMode_ = mode;
clientUID_ = clientUID;
state_ = INVALID;
}
AudioStreamTracker::~AudioStreamTracker() {}
void AudioStreamTracker::RegisterTracker(const int32_t sessionId, const State state,
const AudioRendererInfo &rendererInfo, const AudioCapturerInfo &capturerInfo,
const std::shared_ptr<AudioClientTracker> &clientTrackerObj)
{
AUDIO_DEBUG_LOG("AudioStreamtracker:Register tracker entered");
AudioStreamChangeInfo streamChangeInfo;
if (state_ != INVALID) {
AUDIO_DEBUG_LOG("AudioStreamtracker:Register tracker is called in wrong state");
return;
}
state_ = state;
if (eMode_ == AUDIO_MODE_PLAYBACK) {
streamChangeInfo.audioRendererChangeInfo.clientUID = clientUID_;
streamChangeInfo.audioRendererChangeInfo.sessionId = sessionId;
streamChangeInfo.audioRendererChangeInfo.rendererState = static_cast<RendererState>(state);
streamChangeInfo.audioRendererChangeInfo.rendererInfo = rendererInfo;
} else {
streamChangeInfo.audioCapturerChangeInfo.clientUID = clientUID_;
streamChangeInfo.audioCapturerChangeInfo.sessionId = sessionId;
streamChangeInfo.audioCapturerChangeInfo.capturerState = static_cast<CapturerState>(state);
streamChangeInfo.audioCapturerChangeInfo.capturerInfo = capturerInfo;
}
AudioPolicyManager::GetInstance().RegisterTracker(eMode_, streamChangeInfo, clientTrackerObj);
}
void AudioStreamTracker::UpdateTracker(const int32_t sessionId, const State state,
const AudioRendererInfo &rendererInfo, const AudioCapturerInfo &capturerInfo)
{
AUDIO_DEBUG_LOG("AudioStreamtracker:Update tracker entered");
AudioStreamChangeInfo streamChangeInfo;
if (state_ == INVALID || state_ == state) {
AUDIO_DEBUG_LOG("AudioStreamtracker:Update tracker is called in wrong state/same state");
return;
}
state_ = state;
if (eMode_ == AUDIO_MODE_PLAYBACK) {
streamChangeInfo.audioRendererChangeInfo.clientUID = clientUID_;
streamChangeInfo.audioRendererChangeInfo.sessionId = sessionId;
streamChangeInfo.audioRendererChangeInfo.rendererState = static_cast<RendererState>(state);
streamChangeInfo.audioRendererChangeInfo.rendererInfo = rendererInfo;
} else {
streamChangeInfo.audioCapturerChangeInfo.clientUID = clientUID_;
streamChangeInfo.audioCapturerChangeInfo.sessionId = sessionId;
streamChangeInfo.audioCapturerChangeInfo.capturerState = static_cast<CapturerState>(state);
streamChangeInfo.audioCapturerChangeInfo.capturerInfo = capturerInfo;
}
AudioPolicyManager::GetInstance().UpdateTracker(eMode_, streamChangeInfo);
}
} // namespace AudioStandard
} // namespace OHOS