Merge changes from topic "aaudio_aidl" (8b2314c8) · Commits · e / os / android_frameworks_av

media/libaaudio/Android.bp

+2 −1

Original line number	Diff line number	Diff line
		@@ -32,5 +32,6 @@ ndk_library {
		cc_library_headers {
		name: "libaaudio_headers",
		export_include_dirs: ["include"],
		export_header_lib_headers: ["aaudio-aidl-cpp"],
		header_libs: ["aaudio-aidl-cpp"],
		}

media/libaaudio/src/Android.bp

+32 −2

Original line number	Diff line number	Diff line
		@@ -85,6 +85,7 @@ cc_library {
		"libcutils",
		"libutils",
		"libbinder",
		"aaudio-aidl-cpp",
		],

		cflags: [
		@@ -114,11 +115,10 @@ cc_library {
		"client/AudioStreamInternalPlay.cpp",
		"client/IsochronousClockModel.cpp",
		"binding/AudioEndpointParcelable.cpp",
		"binding/AAudioBinderAdapter.cpp",
		"binding/AAudioBinderClient.cpp",
		"binding/AAudioStreamRequest.cpp",
		"binding/AAudioStreamConfiguration.cpp",
		"binding/IAAudioClient.cpp",
		"binding/IAAudioService.cpp",
		"binding/RingBufferParcelable.cpp",
		"binding/SharedMemoryParcelable.cpp",
		"binding/SharedRegionParcelable.cpp",
		@@ -138,3 +138,33 @@ cc_library {
		misc_undefined: ["bounds"],
		},
		}

		aidl_interface {
		name: "aaudio-aidl",
		unstable: true,
		local_include_dir: "binding/aidl",
		srcs: [
		"binding/aidl/aaudio/Endpoint.aidl",
		"binding/aidl/aaudio/RingBuffer.aidl",
		"binding/aidl/aaudio/SharedRegion.aidl",
		"binding/aidl/aaudio/StreamParameters.aidl",
		"binding/aidl/aaudio/StreamRequest.aidl",
		"binding/aidl/aaudio/IAAudioClient.aidl",
		"binding/aidl/aaudio/IAAudioService.aidl",
		],
		imports: [
		"audio_common-aidl",
		"shared-file-region-aidl",
		],
		backend:
		{
		cpp: {
		enabled: true,
		},
		java: {
		// TODO: need to have audio_common-aidl available in Java to enable
		// this.
		enabled: false,
		},
		},
		}

media/libaaudio/src/binding/AAudioBinderAdapter.cpp

0 → 100644

+125 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2020 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.
		*/

		#include <binding/AAudioBinderAdapter.h>
		#include <utility/AAudioUtilities.h>

		namespace aaudio {

		using android::binder::Status;

		AAudioBinderAdapter::AAudioBinderAdapter(IAAudioService* delegate)
		: mDelegate(delegate) {}

		void AAudioBinderAdapter::registerClient(const android::sp<IAAudioClient>& client) {
		mDelegate->registerClient(client);
		}

		aaudio_handle_t AAudioBinderAdapter::openStream(const AAudioStreamRequest& request,
		AAudioStreamConfiguration& config) {
		aaudio_handle_t result;
		StreamParameters params;
		Status status = mDelegate->openStream(request.parcelable(),
		&params,
		&result);
		if (!status.isOk()) {
		result = AAudioConvert_androidToAAudioResult(status.transactionError());
		}
		config = params;
		return result;
		}

		aaudio_result_t AAudioBinderAdapter::closeStream(aaudio_handle_t streamHandle) {
		aaudio_result_t result;
		Status status = mDelegate->closeStream(streamHandle, &result);
		if (!status.isOk()) {
		result = AAudioConvert_androidToAAudioResult(status.transactionError());
		}
		return result;
		}

		aaudio_result_t AAudioBinderAdapter::getStreamDescription(aaudio_handle_t streamHandle,
		AudioEndpointParcelable& endpointOut) {
		aaudio_result_t result;
		Endpoint endpoint;
		Status status = mDelegate->getStreamDescription(streamHandle,
		&endpoint,
		&result);
		if (!status.isOk()) {
		result = AAudioConvert_androidToAAudioResult(status.transactionError());
		}
		endpointOut = std::move(endpoint);
		return result;
		}

		aaudio_result_t AAudioBinderAdapter::startStream(aaudio_handle_t streamHandle) {
		aaudio_result_t result;
		Status status = mDelegate->startStream(streamHandle, &result);
		if (!status.isOk()) {
		result = AAudioConvert_androidToAAudioResult(status.transactionError());
		}
		return result;
		}

		aaudio_result_t AAudioBinderAdapter::pauseStream(aaudio_handle_t streamHandle) {
		aaudio_result_t result;
		Status status = mDelegate->pauseStream(streamHandle, &result);
		if (!status.isOk()) {
		result = AAudioConvert_androidToAAudioResult(status.transactionError());
		}
		return result;
		}

		aaudio_result_t AAudioBinderAdapter::stopStream(aaudio_handle_t streamHandle) {
		aaudio_result_t result;
		Status status = mDelegate->stopStream(streamHandle, &result);
		if (!status.isOk()) {
		result = AAudioConvert_androidToAAudioResult(status.transactionError());
		}
		return result;
		}

		aaudio_result_t AAudioBinderAdapter::flushStream(aaudio_handle_t streamHandle) {
		aaudio_result_t result;
		Status status = mDelegate->flushStream(streamHandle, &result);
		if (!status.isOk()) {
		result = AAudioConvert_androidToAAudioResult(status.transactionError());
		}
		return result;
		}

		aaudio_result_t AAudioBinderAdapter::registerAudioThread(aaudio_handle_t streamHandle,
		pid_t clientThreadId,
		int64_t periodNanoseconds) {
		aaudio_result_t result;
		Status status = mDelegate->registerAudioThread(streamHandle, clientThreadId, periodNanoseconds, &result);
		if (!status.isOk()) {
		result = AAudioConvert_androidToAAudioResult(status.transactionError());
		}
		return result;
		}

		aaudio_result_t AAudioBinderAdapter::unregisterAudioThread(aaudio_handle_t streamHandle,
		pid_t clientThreadId) {
		aaudio_result_t result;
		Status status = mDelegate->unregisterAudioThread(streamHandle, clientThreadId, &result);
		if (!status.isOk()) {
		result = AAudioConvert_androidToAAudioResult(status.transactionError());
		}
		return result;
		}

		} // namespace aaudio

media/libaaudio/src/binding/AAudioBinderAdapter.h

0 → 100644

+64 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2020 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.
		*/

		#pragma once

		#include <aaudio/IAAudioService.h>
		#include <binding/AAudioServiceInterface.h>

		namespace aaudio {

		/**
		* An adapter that takes in an underlying IAAudioService and exposes an
		* AAudioServiceInterface.
		*
		* This class is abstract: the client is expected to inherit from this class and implement those
		* methods from AAudioServiceInterface that don't have counterparts in IAAudioService.
		*/
		class AAudioBinderAdapter : public AAudioServiceInterface {
		public:
		explicit AAudioBinderAdapter(IAAudioService* delegate);

		void registerClient(const android::sp<IAAudioClient>& client) override;

		aaudio_handle_t openStream(const AAudioStreamRequest& request,
		AAudioStreamConfiguration& configuration) override;

		aaudio_result_t closeStream(aaudio_handle_t streamHandle) override;

		aaudio_result_t getStreamDescription(aaudio_handle_t streamHandle,
		AudioEndpointParcelable& endpoint) override;

		aaudio_result_t startStream(aaudio_handle_t streamHandle) override;

		aaudio_result_t pauseStream(aaudio_handle_t streamHandle) override;

		aaudio_result_t stopStream(aaudio_handle_t streamHandle) override;

		aaudio_result_t flushStream(aaudio_handle_t streamHandle) override;

		aaudio_result_t registerAudioThread(aaudio_handle_t streamHandle,
		pid_t clientThreadId,
		int64_t periodNanoseconds) override;

		aaudio_result_t unregisterAudioThread(aaudio_handle_t streamHandle,
		pid_t clientThreadId) override;

		private:
		IAAudioService* const mDelegate;
		};

		} // namespace aaudio

media/libaaudio/src/binding/AAudioBinderClient.cpp

+35 −36

Original line number	Diff line number	Diff line
		@@ -19,35 +19,30 @@
		//#define LOG_NDEBUG 0
		#include <utils/Log.h>

		#include <binder/IInterface.h>
		#include <binder/IServiceManager.h>
		#include <binder/ProcessState.h>
		#include <utils/Mutex.h>
		#include <utils/RefBase.h>
		#include <utils/Singleton.h>
		#include <media/AudioSystem.h>

		#include <aaudio/AAudio.h>

		#include "AudioEndpointParcelable.h"

		#include "binding/AAudioBinderClient.h"
		//#include "binding/AAudioStreamRequest.h"
		//#include "binding/AAudioStreamConfiguration.h"
		//#include "binding/IAAudioService.h"
		//#include "binding/AAudioServiceMessage.h"

		//#include "AAudioServiceInterface.h"
		#define AAUDIO_SERVICE_NAME "media.aaudio"

		using android::String16;
		using android::IServiceManager;
		using android::defaultServiceManager;
		using android::interface_cast;
		using android::IInterface;
		using android::IAAudioService;
		using android::Mutex;
		using android::ProcessState;
		using android::sp;
		using android::status_t;
		using android::wp;
		using android::binder::Status;

		using namespace aaudio;

		@@ -67,20 +62,18 @@ AAudioBinderClient::AAudioBinderClient()
		AAudioBinderClient::~AAudioBinderClient() {
		ALOGV("%s - destroying %p", __func__, this);
		Mutex::Autolock _l(mServiceLock);
		if (mAAudioService != 0) {
		IInterface::asBinder(mAAudioService)->unlinkToDeath(mAAudioClient);
		}
		}

		// TODO Share code with other service clients.
		// Helper function to get access to the "AAudioService" service.
		// This code was modeled after frameworks/av/media/libaudioclient/AudioSystem.cpp
		const sp<IAAudioService> AAudioBinderClient::getAAudioService() {
		std::shared_ptr<AAudioServiceInterface> AAudioBinderClient::getAAudioService() {
		std::shared_ptr<AAudioServiceInterface> result;
		sp<IAAudioService> aaudioService;
		bool needToRegister = false;
		{
		Mutex::Autolock _l(mServiceLock);
		if (mAAudioService.get() == nullptr) {
		if (mAdapter == nullptr) {
		sp<IBinder> binder;
		sp<IServiceManager> sm = defaultServiceManager();
		// Try several times to get the service.
		@@ -99,7 +92,8 @@ const sp<IAAudioService> AAudioBinderClient::getAAudioService() {
		if (status != NO_ERROR) {
		ALOGE("%s() - linkToDeath() returned %d", __func__, status);
		}
		mAAudioService = interface_cast<IAAudioService>(binder);
		aaudioService = interface_cast<IAAudioService>(binder);
		mAdapter.reset(new Adapter(aaudioService, mAAudioClient));
		needToRegister = true;
		// Make sure callbacks can be received by mAAudioClient
		ProcessState::self()->startThreadPool();
		@@ -107,18 +101,18 @@ const sp<IAAudioService> AAudioBinderClient::getAAudioService() {
		ALOGE("AAudioBinderClient could not connect to %s", AAUDIO_SERVICE_NAME);
		}
		}
		aaudioService = mAAudioService;
		result = mAdapter;
		}
		// Do this outside the mutex lock.
		if (needToRegister && aaudioService.get() != nullptr) { // new client?
		aaudioService->registerClient(mAAudioClient);
		}
		return aaudioService;
		return result;
		}

		void AAudioBinderClient::dropAAudioService() {
		Mutex::Autolock _l(mServiceLock);
		mAAudioService.clear(); // force a reconnect
		mAdapter.reset();
		}

		/**
		@@ -127,13 +121,13 @@ void AAudioBinderClient::dropAAudioService() {
		* @return handle to the stream or a negative error
		*/
		aaudio_handle_t AAudioBinderClient::openStream(const AAudioStreamRequest &request,
		AAudioStreamConfiguration &configurationOutput) {
		AAudioStreamConfiguration &configuration) {
		aaudio_handle_t stream;
		for (int i = 0; i < 2; i++) {
		const sp<IAAudioService> &service = getAAudioService();
		std::shared_ptr<AAudioServiceInterface> service = getAAudioService();
		if (service.get() == nullptr) return AAUDIO_ERROR_NO_SERVICE;

		stream = service->openStream(request, configurationOutput);
		stream = service->openStream(request, configuration);

		if (stream == AAUDIO_ERROR_NO_SERVICE) {
		ALOGE("openStream lost connection to AAudioService.");
		@@ -146,8 +140,9 @@ aaudio_handle_t AAudioBinderClient::openStream(const AAudioStreamRequest &reques
		}

		aaudio_result_t AAudioBinderClient::closeStream(aaudio_handle_t streamHandle) {
		const sp<IAAudioService> service = getAAudioService();
		std::shared_ptr<AAudioServiceInterface> service = getAAudioService();
		if (service.get() == nullptr) return AAUDIO_ERROR_NO_SERVICE;

		return service->closeStream(streamHandle);
		}

		@@ -155,33 +150,38 @@ aaudio_result_t AAudioBinderClient::closeStream(aaudio_handle_t streamHandle) {
		* used to communicate with the underlying HAL or Service.
		*/
		aaudio_result_t AAudioBinderClient::getStreamDescription(aaudio_handle_t streamHandle,
		AudioEndpointParcelable &parcelable) {
		const sp<IAAudioService> service = getAAudioService();
		AudioEndpointParcelable& endpointOut) {
		std::shared_ptr<AAudioServiceInterface> service = getAAudioService();
		if (service.get() == nullptr) return AAUDIO_ERROR_NO_SERVICE;
		return service->getStreamDescription(streamHandle, parcelable);

		return service->getStreamDescription(streamHandle, endpointOut);
		}

		aaudio_result_t AAudioBinderClient::startStream(aaudio_handle_t streamHandle) {
		const sp<IAAudioService> service = getAAudioService();
		std::shared_ptr<AAudioServiceInterface> service = getAAudioService();
		if (service.get() == nullptr) return AAUDIO_ERROR_NO_SERVICE;

		return service->startStream(streamHandle);
		}

		aaudio_result_t AAudioBinderClient::pauseStream(aaudio_handle_t streamHandle) {
		const sp<IAAudioService> service = getAAudioService();
		std::shared_ptr<AAudioServiceInterface> service = getAAudioService();
		if (service.get() == nullptr) return AAUDIO_ERROR_NO_SERVICE;

		return service->pauseStream(streamHandle);
		}

		aaudio_result_t AAudioBinderClient::stopStream(aaudio_handle_t streamHandle) {
		const sp<IAAudioService> service = getAAudioService();
		std::shared_ptr<AAudioServiceInterface> service = getAAudioService();
		if (service.get() == nullptr) return AAUDIO_ERROR_NO_SERVICE;

		return service->stopStream(streamHandle);
		}

		aaudio_result_t AAudioBinderClient::flushStream(aaudio_handle_t streamHandle) {
		const sp<IAAudioService> service = getAAudioService();
		std::shared_ptr<AAudioServiceInterface> service = getAAudioService();
		if (service.get() == nullptr) return AAUDIO_ERROR_NO_SERVICE;

		return service->flushStream(streamHandle);
		}

		@@ -191,17 +191,16 @@ aaudio_result_t AAudioBinderClient::flushStream(aaudio_handle_t streamHandle) {
		aaudio_result_t AAudioBinderClient::registerAudioThread(aaudio_handle_t streamHandle,
		pid_t clientThreadId,
		int64_t periodNanoseconds) {
		const sp<IAAudioService> service = getAAudioService();
		std::shared_ptr<AAudioServiceInterface> service = getAAudioService();
		if (service.get() == nullptr) return AAUDIO_ERROR_NO_SERVICE;
		return service->registerAudioThread(streamHandle,
		clientThreadId,
		periodNanoseconds);

		return service->registerAudioThread(streamHandle, clientThreadId, periodNanoseconds);
		}

		aaudio_result_t AAudioBinderClient::unregisterAudioThread(aaudio_handle_t streamHandle,
		pid_t clientThreadId) {
		const sp<IAAudioService> service = getAAudioService();
		std::shared_ptr<AAudioServiceInterface> service = getAAudioService();
		if (service.get() == nullptr) return AAUDIO_ERROR_NO_SERVICE;
		return service->unregisterAudioThread(streamHandle,
		clientThreadId);

		return service->unregisterAudioThread(streamHandle, clientThreadId);
		}