Merge "audio policy: add option to use new policy manager" (9ac3c9a7) · Commits · e / os / android_frameworks_av

CleanSpec.mk

+3 −0

Original line number	Diff line number	Diff line
		@@ -49,6 +49,9 @@ $(call add-clean-step, rm -rf $(PRODUCT_OUT)/symbols/system/lib/libmedia_native.
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/lib/libmedia_native.so)
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/SHARED_LIBRARIES/libaudioflinger_intermediates)
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/lib/libaudioflinger.so)
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/SHARED_LIBRARIES/libaudiopolicy_intermediates)
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/lib/libaudiopolicy.so)

		# ************************************************
		# NEWER CLEAN STEPS MUST BE AT THE END OF THE LIST
		# ************************************************

services/audiopolicy/Android.mk

+14 −2

Original line number	Diff line number	Diff line
		@@ -3,9 +3,21 @@ LOCAL_PATH:= $(call my-dir)
		include $(CLEAR_VARS)

		LOCAL_SRC_FILES:= \
		AudioPolicyService.cpp \
		AudioPolicyService.cpp

		USE_LEGACY_AUDIO_POLICY = 1
		ifeq ($(USE_LEGACY_AUDIO_POLICY), 1)
		LOCAL_SRC_FILES += \
		AudioPolicyInterfaceImplLegacy.cpp \
		AudioPolicyClientImplLegacy.cpp

		LOCAL_CFLAGS += -DUSE_LEGACY_AUDIO_POLICY
		else
		LOCAL_SRC_FILES += \
		AudioPolicyInterfaceImpl.cpp \
		AudioPolicyClientImpl.cpp
		AudioPolicyClientImpl.cpp \
		AudioPolicyManager.cpp
		endif

		LOCAL_C_INCLUDES := \
		$(TOPDIR)frameworks/av/services/audioflinger \

services/audiopolicy/AudioPolicyClientImpl.cpp

+54 −128

Original line number	Diff line number	Diff line
		@@ -14,44 +14,17 @@
		* limitations under the License.
		*/

		#define LOG_TAG "AudioPolicyService"
		#define LOG_TAG "AudioPolicyClientImpl"
		//#define LOG_NDEBUG 0

		#include "Configuration.h"
		#undef __STRICT_ANSI__
		#define __STDINT_LIMITS
		#define __STDC_LIMIT_MACROS
		#include <stdint.h>

		#include <sys/time.h>
		#include <binder/IServiceManager.h>
		#include <utils/Log.h>
		#include <cutils/properties.h>
		#include <binder/IPCThreadState.h>
		#include <utils/String16.h>
		#include <utils/threads.h>
		#include "AudioPolicyService.h"
		#include "ServiceUtilities.h"
		#include <hardware_legacy/power.h>
		#include <media/AudioEffect.h>
		#include <media/EffectsFactoryApi.h>
		//#include <media/IAudioFlinger.h>

		#include <hardware/hardware.h>
		#include <system/audio.h>
		#include <system/audio_policy.h>
		#include <hardware/audio_policy.h>
		#include <audio_effects/audio_effects_conf.h>
		#include <media/AudioParameter.h>


		namespace android {

		/* implementation of the interface to the policy manager */
		extern "C" {
		/* implementation of the client interface from the policy manager */

		audio_module_handle_t aps_load_hw_module(void *service __unused,
		const char *name)
		audio_module_handle_t AudioPolicyService::AudioPolicyClient::loadHwModule(const char *name)
		{
		sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
		if (af == 0) {
		@@ -62,27 +35,7 @@ audio_module_handle_t aps_load_hw_module(void *service __unused,
		return af->loadHwModule(name);
		}

		// deprecated: replaced by aps_open_output_on_module()
		audio_io_handle_t aps_open_output(void *service __unused,
		audio_devices_t *pDevices,
		uint32_t *pSamplingRate,
		audio_format_t *pFormat,
		audio_channel_mask_t *pChannelMask,
		uint32_t *pLatencyMs,
		audio_output_flags_t flags)
		{
		sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
		if (af == 0) {
		ALOGW("%s: could not get AudioFlinger", __func__);
		return 0;
		}

		return af->openOutput((audio_module_handle_t)0, pDevices, pSamplingRate, pFormat, pChannelMask,
		pLatencyMs, flags);
		}

		audio_io_handle_t aps_open_output_on_module(void *service __unused,
		audio_module_handle_t module,
		audio_io_handle_t AudioPolicyService::AudioPolicyClient::openOutput(audio_module_handle_t module,
		audio_devices_t *pDevices,
		uint32_t *pSamplingRate,
		audio_format_t *pFormat,
		@@ -100,7 +53,7 @@ audio_io_handle_t aps_open_output_on_module(void *service __unused,
		pLatencyMs, flags, offloadInfo);
		}

		audio_io_handle_t aps_open_dup_output(void *service __unused,
		audio_io_handle_t AudioPolicyService::AudioPolicyClient::openDuplicateOutput(
		audio_io_handle_t output1,
		audio_io_handle_t output2)
		{
		@@ -112,7 +65,7 @@ audio_io_handle_t aps_open_dup_output(void *service __unused,
		return af->openDuplicateOutput(output1, output2);
		}

		int aps_close_output(void *service __unused, audio_io_handle_t output)
		status_t AudioPolicyService::AudioPolicyClient::closeOutput(audio_io_handle_t output)
		{
		sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
		if (af == 0) {
		@@ -122,7 +75,7 @@ int aps_close_output(void *service __unused, audio_io_handle_t output)
		return af->closeOutput(output);
		}

		int aps_suspend_output(void *service __unused, audio_io_handle_t output)
		status_t AudioPolicyService::AudioPolicyClient::suspendOutput(audio_io_handle_t output)
		{
		sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
		if (af == 0) {
		@@ -133,7 +86,7 @@ int aps_suspend_output(void *service __unused, audio_io_handle_t output)
		return af->suspendOutput(output);
		}

		int aps_restore_output(void *service __unused, audio_io_handle_t output)
		status_t AudioPolicyService::AudioPolicyClient::restoreOutput(audio_io_handle_t output)
		{
		sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
		if (af == 0) {
		@@ -144,25 +97,7 @@ int aps_restore_output(void *service __unused, audio_io_handle_t output)
		return af->restoreOutput(output);
		}

		// deprecated: replaced by aps_open_input_on_module(), and acoustics parameter is ignored
		audio_io_handle_t aps_open_input(void *service __unused,
		audio_devices_t *pDevices,
		uint32_t *pSamplingRate,
		audio_format_t *pFormat,
		audio_channel_mask_t *pChannelMask,
		audio_in_acoustics_t acoustics __unused)
		{
		sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
		if (af == 0) {
		ALOGW("%s: could not get AudioFlinger", __func__);
		return 0;
		}

		return af->openInput((audio_module_handle_t)0, pDevices, pSamplingRate, pFormat, pChannelMask);
		}

		audio_io_handle_t aps_open_input_on_module(void *service __unused,
		audio_module_handle_t module,
		audio_io_handle_t AudioPolicyService::AudioPolicyClient::openInput(audio_module_handle_t module,
		audio_devices_t *pDevices,
		uint32_t *pSamplingRate,
		audio_format_t *pFormat,
		@@ -177,7 +112,7 @@ audio_io_handle_t aps_open_input_on_module(void *service __unused,
		return af->openInput(module, pDevices, pSamplingRate, pFormat, pChannelMask);
		}

		int aps_close_input(void *service __unused, audio_io_handle_t input)
		status_t AudioPolicyService::AudioPolicyClient::closeInput(audio_io_handle_t input)
		{
		sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
		if (af == 0) {
		@@ -187,75 +122,66 @@ int aps_close_input(void *service __unused, audio_io_handle_t input)
		return af->closeInput(input);
		}

		int aps_invalidate_stream(void *service __unused, audio_stream_type_t stream)
		status_t AudioPolicyService::AudioPolicyClient::setStreamVolume(audio_stream_type_t stream,
		float volume, audio_io_handle_t output,
		int delay_ms)
		{
		sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
		if (af == 0) {
		return PERMISSION_DENIED;
		}

		return af->invalidateStream(stream);
		return mAudioPolicyService->setStreamVolume(stream, volume, output,
		delay_ms);
		}

		int aps_move_effects(void *service __unused, int session,
		audio_io_handle_t src_output,
		audio_io_handle_t dst_output)
		status_t AudioPolicyService::AudioPolicyClient::invalidateStream(audio_stream_type_t stream)
		{
		sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
		if (af == 0) {
		return PERMISSION_DENIED;
		}

		return af->moveEffects(session, src_output, dst_output);
		return af->invalidateStream(stream);
		}

		char * aps_get_parameters(void *service __unused, audio_io_handle_t io_handle,
		const char *keys)
		void AudioPolicyService::AudioPolicyClient::setParameters(audio_io_handle_t io_handle,
		const String8& keyValuePairs,
		int delay_ms)
		{
		String8 result = AudioSystem::getParameters(io_handle, String8(keys));
		return strdup(result.string());
		mAudioPolicyService->setParameters(io_handle, keyValuePairs.string(), delay_ms);
		}

		void aps_set_parameters(void *service, audio_io_handle_t io_handle,
		const char *kv_pairs, int delay_ms)
		String8 AudioPolicyService::AudioPolicyClient::getParameters(audio_io_handle_t io_handle,
		const String8& keys)
		{
		AudioPolicyService audioPolicyService = (AudioPolicyService )service;

		audioPolicyService->setParameters(io_handle, kv_pairs, delay_ms);
		String8 result = AudioSystem::getParameters(io_handle, keys);
		return result;
		}

		int aps_set_stream_volume(void *service, audio_stream_type_t stream,
		float volume, audio_io_handle_t output,
		int delay_ms)
		status_t AudioPolicyService::AudioPolicyClient::startTone(audio_policy_tone_t tone,
		audio_stream_type_t stream)
		{
		AudioPolicyService audioPolicyService = (AudioPolicyService )service;

		return audioPolicyService->setStreamVolume(stream, volume, output,
		delay_ms);
		return mAudioPolicyService->startTone(tone, stream);
		}

		int aps_start_tone(void *service, audio_policy_tone_t tone,
		audio_stream_type_t stream)
		status_t AudioPolicyService::AudioPolicyClient::stopTone()
		{
		AudioPolicyService audioPolicyService = (AudioPolicyService )service;

		return audioPolicyService->startTone(tone, stream);
		return mAudioPolicyService->stopTone();
		}

		int aps_stop_tone(void *service)
		status_t AudioPolicyService::AudioPolicyClient::setVoiceVolume(float volume, int delay_ms)
		{
		AudioPolicyService audioPolicyService = (AudioPolicyService )service;

		return audioPolicyService->stopTone();
		return mAudioPolicyService->setVoiceVolume(volume, delay_ms);
		}

		int aps_set_voice_volume(void *service, float volume, int delay_ms)
		status_t AudioPolicyService::AudioPolicyClient::moveEffects(int session,
		audio_io_handle_t src_output,
		audio_io_handle_t dst_output)
		{
		AudioPolicyService audioPolicyService = (AudioPolicyService )service;
		sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
		if (af == 0) {
		return PERMISSION_DENIED;
		}

		return audioPolicyService->setVoiceVolume(volume, delay_ms);
		return af->moveEffects(session, src_output, dst_output);
		}

		}; // extern "C"


		}; // namespace android

services/audiopolicy/AudioPolicyClientImplLegacy.cpp

0 → 100644

+261 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2009 The Android Open Source Project
		*
		* 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.
		*/

		#define LOG_TAG "AudioPolicyService"
		//#define LOG_NDEBUG 0

		#include "Configuration.h"
		#undef __STRICT_ANSI__
		#define __STDINT_LIMITS
		#define __STDC_LIMIT_MACROS
		#include <stdint.h>

		#include <sys/time.h>
		#include <binder/IServiceManager.h>
		#include <utils/Log.h>
		#include <cutils/properties.h>
		#include <binder/IPCThreadState.h>
		#include <utils/String16.h>
		#include <utils/threads.h>
		#include "AudioPolicyService.h"
		#include "ServiceUtilities.h"
		#include <hardware_legacy/power.h>
		#include <media/AudioEffect.h>
		#include <media/EffectsFactoryApi.h>
		//#include <media/IAudioFlinger.h>

		#include <hardware/hardware.h>
		#include <system/audio.h>
		#include <system/audio_policy.h>
		#include <hardware/audio_policy.h>
		#include <audio_effects/audio_effects_conf.h>
		#include <media/AudioParameter.h>


		namespace android {

		/* implementation of the interface to the policy manager */
		extern "C" {

		audio_module_handle_t aps_load_hw_module(void *service __unused,
		const char *name)
		{
		sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
		if (af == 0) {
		ALOGW("%s: could not get AudioFlinger", __func__);
		return 0;
		}

		return af->loadHwModule(name);
		}

		// deprecated: replaced by aps_open_output_on_module()
		audio_io_handle_t aps_open_output(void *service __unused,
		audio_devices_t *pDevices,
		uint32_t *pSamplingRate,
		audio_format_t *pFormat,
		audio_channel_mask_t *pChannelMask,
		uint32_t *pLatencyMs,
		audio_output_flags_t flags)
		{
		sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
		if (af == 0) {
		ALOGW("%s: could not get AudioFlinger", __func__);
		return 0;
		}

		return af->openOutput((audio_module_handle_t)0, pDevices, pSamplingRate, pFormat, pChannelMask,
		pLatencyMs, flags);
		}

		audio_io_handle_t aps_open_output_on_module(void *service __unused,
		audio_module_handle_t module,
		audio_devices_t *pDevices,
		uint32_t *pSamplingRate,
		audio_format_t *pFormat,
		audio_channel_mask_t *pChannelMask,
		uint32_t *pLatencyMs,
		audio_output_flags_t flags,
		const audio_offload_info_t *offloadInfo)
		{
		sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
		if (af == 0) {
		ALOGW("%s: could not get AudioFlinger", __func__);
		return 0;
		}
		return af->openOutput(module, pDevices, pSamplingRate, pFormat, pChannelMask,
		pLatencyMs, flags, offloadInfo);
		}

		audio_io_handle_t aps_open_dup_output(void *service __unused,
		audio_io_handle_t output1,
		audio_io_handle_t output2)
		{
		sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
		if (af == 0) {
		ALOGW("%s: could not get AudioFlinger", __func__);
		return 0;
		}
		return af->openDuplicateOutput(output1, output2);
		}

		int aps_close_output(void *service __unused, audio_io_handle_t output)
		{
		sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
		if (af == 0) {
		return PERMISSION_DENIED;
		}

		return af->closeOutput(output);
		}

		int aps_suspend_output(void *service __unused, audio_io_handle_t output)
		{
		sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
		if (af == 0) {
		ALOGW("%s: could not get AudioFlinger", __func__);
		return PERMISSION_DENIED;
		}

		return af->suspendOutput(output);
		}

		int aps_restore_output(void *service __unused, audio_io_handle_t output)
		{
		sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
		if (af == 0) {
		ALOGW("%s: could not get AudioFlinger", __func__);
		return PERMISSION_DENIED;
		}

		return af->restoreOutput(output);
		}

		// deprecated: replaced by aps_open_input_on_module(), and acoustics parameter is ignored
		audio_io_handle_t aps_open_input(void *service __unused,
		audio_devices_t *pDevices,
		uint32_t *pSamplingRate,
		audio_format_t *pFormat,
		audio_channel_mask_t *pChannelMask,
		audio_in_acoustics_t acoustics __unused)
		{
		sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
		if (af == 0) {
		ALOGW("%s: could not get AudioFlinger", __func__);
		return 0;
		}

		return af->openInput((audio_module_handle_t)0, pDevices, pSamplingRate, pFormat, pChannelMask);
		}

		audio_io_handle_t aps_open_input_on_module(void *service __unused,
		audio_module_handle_t module,
		audio_devices_t *pDevices,
		uint32_t *pSamplingRate,
		audio_format_t *pFormat,
		audio_channel_mask_t *pChannelMask)
		{
		sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
		if (af == 0) {
		ALOGW("%s: could not get AudioFlinger", __func__);
		return 0;
		}

		return af->openInput(module, pDevices, pSamplingRate, pFormat, pChannelMask);
		}

		int aps_close_input(void *service __unused, audio_io_handle_t input)
		{
		sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
		if (af == 0) {
		return PERMISSION_DENIED;
		}

		return af->closeInput(input);
		}

		int aps_invalidate_stream(void *service __unused, audio_stream_type_t stream)
		{
		sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
		if (af == 0) {
		return PERMISSION_DENIED;
		}

		return af->invalidateStream(stream);
		}

		int aps_move_effects(void *service __unused, int session,
		audio_io_handle_t src_output,
		audio_io_handle_t dst_output)
		{
		sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
		if (af == 0) {
		return PERMISSION_DENIED;
		}

		return af->moveEffects(session, src_output, dst_output);
		}

		char * aps_get_parameters(void *service __unused, audio_io_handle_t io_handle,
		const char *keys)
		{
		String8 result = AudioSystem::getParameters(io_handle, String8(keys));
		return strdup(result.string());
		}

		void aps_set_parameters(void *service, audio_io_handle_t io_handle,
		const char *kv_pairs, int delay_ms)
		{
		AudioPolicyService audioPolicyService = (AudioPolicyService )service;

		audioPolicyService->setParameters(io_handle, kv_pairs, delay_ms);
		}

		int aps_set_stream_volume(void *service, audio_stream_type_t stream,
		float volume, audio_io_handle_t output,
		int delay_ms)
		{
		AudioPolicyService audioPolicyService = (AudioPolicyService )service;

		return audioPolicyService->setStreamVolume(stream, volume, output,
		delay_ms);
		}

		int aps_start_tone(void *service, audio_policy_tone_t tone,
		audio_stream_type_t stream)
		{
		AudioPolicyService audioPolicyService = (AudioPolicyService )service;

		return audioPolicyService->startTone(tone, stream);
		}

		int aps_stop_tone(void *service)
		{
		AudioPolicyService audioPolicyService = (AudioPolicyService )service;

		return audioPolicyService->stopTone();
		}

		int aps_set_voice_volume(void *service, float volume, int delay_ms)
		{
		AudioPolicyService audioPolicyService = (AudioPolicyService )service;

		return audioPolicyService->setVoiceVolume(volume, delay_ms);
		}

		}; // extern "C"

		}; // namespace android

services/audiopolicy/AudioPolicyInterface.h

+3 −3

Original line number	Diff line number	Diff line
		@@ -14,8 +14,8 @@
		* limitations under the License.
		*/

		#ifndef ANDROID_AUDIOPOLICYINTERFACE_H
		#define ANDROID_AUDIOPOLICYINTERFACE_H
		#ifndef ANDROID_AUDIOPOLICY_INTERFACE_H
		#define ANDROID_AUDIOPOLICY_INTERFACE_H

		#include <media/AudioSystem.h>
		#include <utils/String8.h>
		@@ -254,4 +254,4 @@ extern "C" void destroyAudioPolicyManager(AudioPolicyInterface *interface);

		}; // namespace android

		#endif // ANDROID_AUDIOPOLICYINTERFACE_H
		#endif // ANDROID_AUDIOPOLICY_INTERFACE_H