Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 16fd945e authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Automerger Merge Worker
Browse files

Merge "AAudio: do not call to aaudio service when the binder has dead." into udc-dev am: 5dfb5c91 

Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/av/+/21725417



Change-Id: I4e7e6640f13e417a4857f57db4cf8440c3cb2007
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 4aba4069 5dfb5c91

media/libaaudio/src/binding/AAudioBinderAdapter.cpp

+53 −23
Original line number Diff line number Diff line
@@ -23,14 +23,15 @@ namespace aaudio { 
using android::aidl_utils::statusTFromBinderStatus;

using android::binder::Status;



AAudioBinderAdapter::AAudioBinderAdapter(IAAudioService* delegate)

        : mDelegate(delegate) {}

AAudioBinderAdapter::AAudioBinderAdapter(IAAudioService* delegate,

                                         int32_t serviceLifetimeId)

        : mDelegate(delegate), mServiceLifetimeId(serviceLifetimeId) {}



void AAudioBinderAdapter::registerClient(const android::sp<IAAudioClient>& client) {

    mDelegate->registerClient(client);

}



aaudio_handle_t AAudioBinderAdapter::openStream(const AAudioStreamRequest& request,

AAudioHandleInfo AAudioBinderAdapter::openStream(const AAudioStreamRequest& request,

                                                 AAudioStreamConfiguration& config) {

    aaudio_handle_t result;

    StreamParameters params;
@@ -41,23 +42,29 @@ aaudio_handle_t AAudioBinderAdapter::openStream(const AAudioStreamRequest& reque 
        result = AAudioConvert_androidToAAudioResult(statusTFromBinderStatus(status));

    }

    config = params;

    return result;

    return {mServiceLifetimeId, result};

}



aaudio_result_t AAudioBinderAdapter::closeStream(aaudio_handle_t streamHandle) {

aaudio_result_t AAudioBinderAdapter::closeStream(const AAudioHandleInfo& streamHandleInfo) {

    if (streamHandleInfo.getServiceLifetimeId() != mServiceLifetimeId) {

        return AAUDIO_ERROR_DISCONNECTED;

    }

    aaudio_result_t result;

    Status status = mDelegate->closeStream(streamHandle, &result);

    Status status = mDelegate->closeStream(streamHandleInfo.getHandle(), &result);

    if (!status.isOk()) {

        result = AAudioConvert_androidToAAudioResult(statusTFromBinderStatus(status));

    }

    return result;

}



aaudio_result_t AAudioBinderAdapter::getStreamDescription(aaudio_handle_t streamHandle,

aaudio_result_t AAudioBinderAdapter::getStreamDescription(const AAudioHandleInfo& streamHandleInfo,

                                                          AudioEndpointParcelable& endpointOut) {

    if (streamHandleInfo.getServiceLifetimeId() != mServiceLifetimeId) {

        return AAUDIO_ERROR_DISCONNECTED;

    }

    aaudio_result_t result;

    Endpoint endpoint;

    Status status = mDelegate->getStreamDescription(streamHandle,

    Status status = mDelegate->getStreamDescription(streamHandleInfo.getHandle(),

                                                    &endpoint,

                                                    &result);

    if (!status.isOk()) {
@@ -67,68 +74,91 @@ aaudio_result_t AAudioBinderAdapter::getStreamDescription(aaudio_handle_t stream 
    return result;

}



aaudio_result_t AAudioBinderAdapter::startStream(aaudio_handle_t streamHandle) {

aaudio_result_t AAudioBinderAdapter::startStream(const AAudioHandleInfo& streamHandleInfo) {

    if (streamHandleInfo.getServiceLifetimeId() != mServiceLifetimeId) {

        return AAUDIO_ERROR_DISCONNECTED;

    }

    aaudio_result_t result;

    Status status = mDelegate->startStream(streamHandle, &result);

    Status status = mDelegate->startStream(streamHandleInfo.getHandle(), &result);

    if (!status.isOk()) {

        result = AAudioConvert_androidToAAudioResult(statusTFromBinderStatus(status));

    }

    return result;

}



aaudio_result_t AAudioBinderAdapter::pauseStream(aaudio_handle_t streamHandle) {

aaudio_result_t AAudioBinderAdapter::pauseStream(const AAudioHandleInfo& streamHandleInfo) {

    if (streamHandleInfo.getServiceLifetimeId() != mServiceLifetimeId) {

        return AAUDIO_ERROR_DISCONNECTED;

    }

    aaudio_result_t result;

    Status status = mDelegate->pauseStream(streamHandle, &result);

    Status status = mDelegate->pauseStream(streamHandleInfo.getHandle(), &result);

    if (!status.isOk()) {

        result = AAudioConvert_androidToAAudioResult(statusTFromBinderStatus(status));

    }

    return result;

}



aaudio_result_t AAudioBinderAdapter::stopStream(aaudio_handle_t streamHandle) {

aaudio_result_t AAudioBinderAdapter::stopStream(const AAudioHandleInfo& streamHandleInfo) {

    if (streamHandleInfo.getServiceLifetimeId() != mServiceLifetimeId) {

        return AAUDIO_ERROR_DISCONNECTED;

    }

    aaudio_result_t result;

    Status status = mDelegate->stopStream(streamHandle, &result);

    Status status = mDelegate->stopStream(streamHandleInfo.getHandle(), &result);

    if (!status.isOk()) {

        result = AAudioConvert_androidToAAudioResult(statusTFromBinderStatus(status));

    }

    return result;

}



aaudio_result_t AAudioBinderAdapter::flushStream(aaudio_handle_t streamHandle) {

aaudio_result_t AAudioBinderAdapter::flushStream(const AAudioHandleInfo& streamHandleInfo) {

    if (streamHandleInfo.getServiceLifetimeId() != mServiceLifetimeId) {

        return AAUDIO_ERROR_DISCONNECTED;

    }

    aaudio_result_t result;

    Status status = mDelegate->flushStream(streamHandle, &result);

    Status status = mDelegate->flushStream(streamHandleInfo.getHandle(), &result);

    if (!status.isOk()) {

        result = AAudioConvert_androidToAAudioResult(statusTFromBinderStatus(status));

    }

    return result;

}



aaudio_result_t AAudioBinderAdapter::registerAudioThread(aaudio_handle_t streamHandle,

aaudio_result_t AAudioBinderAdapter::registerAudioThread(const AAudioHandleInfo& streamHandleInfo,

                                                         pid_t clientThreadId,

                                                         int64_t periodNanoseconds) {

    if (streamHandleInfo.getServiceLifetimeId() != mServiceLifetimeId) {

        return AAUDIO_ERROR_DISCONNECTED;

    }

    aaudio_result_t result;

    Status status = mDelegate->registerAudioThread(streamHandle, clientThreadId, periodNanoseconds, &result);

    Status status = mDelegate->registerAudioThread(

            streamHandleInfo.getHandle(), clientThreadId, periodNanoseconds, &result);

    if (!status.isOk()) {

        result = AAudioConvert_androidToAAudioResult(statusTFromBinderStatus(status));

    }

    return result;

}



aaudio_result_t AAudioBinderAdapter::unregisterAudioThread(aaudio_handle_t streamHandle,

aaudio_result_t AAudioBinderAdapter::unregisterAudioThread(const AAudioHandleInfo& streamHandleInfo,

                                                           pid_t clientThreadId) {

    if (streamHandleInfo.getServiceLifetimeId() != mServiceLifetimeId) {

        return AAUDIO_ERROR_DISCONNECTED;

    }

    aaudio_result_t result;

    Status status = mDelegate->unregisterAudioThread(streamHandle, clientThreadId, &result);

    Status status = mDelegate->unregisterAudioThread(

            streamHandleInfo.getHandle(), clientThreadId, &result);

    if (!status.isOk()) {

        result = AAudioConvert_androidToAAudioResult(statusTFromBinderStatus(status));

    }

    return result;

}



aaudio_result_t AAudioBinderAdapter::exitStandby(aaudio_handle_t streamHandle,

aaudio_result_t AAudioBinderAdapter::exitStandby(const AAudioHandleInfo& streamHandleInfo,

                                                 AudioEndpointParcelable &endpointOut) {

    if (streamHandleInfo.getServiceLifetimeId() != mServiceLifetimeId) {

        return AAUDIO_ERROR_DISCONNECTED;

    }

    aaudio_result_t result;

    Endpoint endpoint;

    Status status = mDelegate->exitStandby(streamHandle, &endpoint, &result);

    Status status = mDelegate->exitStandby(streamHandleInfo.getHandle(), &endpoint, &result);

    if (!status.isOk()) {

        result = AAudioConvert_androidToAAudioResult(statusTFromBinderStatus(status));

    }

media/libaaudio/src/binding/AAudioBinderAdapter.h

+14 −12
Original line number Diff line number Diff line
@@ -30,38 +30,40 @@ namespace aaudio { 
 */

class AAudioBinderAdapter : public AAudioServiceInterface {

public:

    explicit AAudioBinderAdapter(IAAudioService* delegate);

    AAudioBinderAdapter(IAAudioService* delegate, int32_t serviceLifetimeId);



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



    aaudio_handle_t openStream(const AAudioStreamRequest& request,

    AAudioHandleInfo openStream(const AAudioStreamRequest& request,

                                AAudioStreamConfiguration& configuration) override;



    aaudio_result_t closeStream(aaudio_handle_t streamHandle) override;

    aaudio_result_t closeStream(const AAudioHandleInfo& streamHandleInfo) override;



    aaudio_result_t getStreamDescription(aaudio_handle_t streamHandle,

    aaudio_result_t getStreamDescription(const AAudioHandleInfo& streamHandleInfo,

                                         AudioEndpointParcelable& endpoint) override;



    aaudio_result_t startStream(aaudio_handle_t streamHandle) override;

    aaudio_result_t startStream(const AAudioHandleInfo& streamHandleInfo) override;



    aaudio_result_t pauseStream(aaudio_handle_t streamHandle) override;

    aaudio_result_t pauseStream(const AAudioHandleInfo& streamHandleInfo) override;



    aaudio_result_t stopStream(aaudio_handle_t streamHandle) override;

    aaudio_result_t stopStream(const AAudioHandleInfo& streamHandleInfo) override;



    aaudio_result_t flushStream(aaudio_handle_t streamHandle) override;

    aaudio_result_t flushStream(const AAudioHandleInfo& streamHandleInfo) override;



    aaudio_result_t registerAudioThread(aaudio_handle_t streamHandle,

    aaudio_result_t registerAudioThread(const AAudioHandleInfo& streamHandleInfo,

                                        pid_t clientThreadId,

                                        int64_t periodNanoseconds) override;



    aaudio_result_t unregisterAudioThread(aaudio_handle_t streamHandle,

    aaudio_result_t unregisterAudioThread(const AAudioHandleInfo& streamHandleInfo,

                                          pid_t clientThreadId) override;



    aaudio_result_t exitStandby(aaudio_handle_t streamHandle,

    aaudio_result_t exitStandby(const AAudioHandleInfo& streamHandleInfo,

                                AudioEndpointParcelable &parcelable) override;



private:

    IAAudioService* const mDelegate;

    // A unique id to recognize the service that the adapter connected to.

    const int32_t mServiceLifetimeId;

};



}  // namespace aaudio

media/libaaudio/src/binding/AAudioBinderClient.cpp

+33 −28
Original line number Diff line number Diff line
@@ -90,7 +90,8 @@ std::shared_ptr<AAudioServiceInterface> AAudioBinderClient::getAAudioService() { 
                    ALOGE("%s() - linkToDeath() returned %d", __func__, status);

                }

                aaudioService = interface_cast<IAAudioService>(binder);

                mAdapter = std::make_shared<Adapter>(aaudioService, mAAudioClient);

                mAdapter = std::make_shared<Adapter>(

                        aaudioService, mAAudioClient, mAAudioClient->getServiceLifetimeId());

                needToRegister = true;

                // Make sure callbacks can be received by mAAudioClient

                ProcessState::self()->startThreadPool();
@@ -115,97 +116,101 @@ void AAudioBinderClient::dropAAudioService() { 
/**

* @param request info needed to create the stream

* @param configuration contains information about the created stream

* @return handle to the stream or a negative error

* @return an object for aaudio handle information, which includes the connected

*         aaudio service lifetime id to recognize the connected aaudio service

*         and aaudio handle to recognize the stream. If an error occurs, the

*         aaudio handle will be set as the negative error.

*/

aaudio_handle_t AAudioBinderClient::openStream(const AAudioStreamRequest &request,

AAudioHandleInfo AAudioBinderClient::openStream(const AAudioStreamRequest &request,

                                                AAudioStreamConfiguration &configuration) {

    aaudio_handle_t stream;

    for (int i = 0; i < 2; i++) {

        std::shared_ptr<AAudioServiceInterface> service = getAAudioService();

        if (service.get() == nullptr) return AAUDIO_ERROR_NO_SERVICE;

        if (service.get() == nullptr) {

            return {};

        }



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

        AAudioHandleInfo handleInfo = service->openStream(request, configuration);



        if (stream == AAUDIO_ERROR_NO_SERVICE) {

        if (handleInfo.getHandle() == AAUDIO_ERROR_NO_SERVICE) {

            ALOGE("openStream lost connection to AAudioService.");

            dropAAudioService(); // force a reconnect

        } else {

            break;

            return handleInfo;

        }

    }

    return stream;

    return {};

}



aaudio_result_t AAudioBinderClient::closeStream(aaudio_handle_t streamHandle) {

aaudio_result_t AAudioBinderClient::closeStream(const AAudioHandleInfo& streamHandleInfo) {

    std::shared_ptr<AAudioServiceInterface> service = getAAudioService();

    if (service.get() == nullptr) return AAUDIO_ERROR_NO_SERVICE;



    return service->closeStream(streamHandle);

    return service->closeStream(streamHandleInfo);

}



/* Get an immutable description of the in-memory queues

* used to communicate with the underlying HAL or Service.

*/

aaudio_result_t AAudioBinderClient::getStreamDescription(aaudio_handle_t streamHandle,

aaudio_result_t AAudioBinderClient::getStreamDescription(const AAudioHandleInfo& streamHandleInfo,

                                                         AudioEndpointParcelable& endpointOut) {

    std::shared_ptr<AAudioServiceInterface> service = getAAudioService();

    if (service.get() == nullptr) return AAUDIO_ERROR_NO_SERVICE;



    return service->getStreamDescription(streamHandle, endpointOut);

    return service->getStreamDescription(streamHandleInfo, endpointOut);

}



aaudio_result_t AAudioBinderClient::startStream(aaudio_handle_t streamHandle) {

aaudio_result_t AAudioBinderClient::startStream(const AAudioHandleInfo& streamHandleInfo) {

    std::shared_ptr<AAudioServiceInterface> service = getAAudioService();

    if (service.get() == nullptr) return AAUDIO_ERROR_NO_SERVICE;



    return service->startStream(streamHandle);

    return service->startStream(streamHandleInfo);

}



aaudio_result_t AAudioBinderClient::pauseStream(aaudio_handle_t streamHandle) {

aaudio_result_t AAudioBinderClient::pauseStream(const AAudioHandleInfo& streamHandleInfo) {

    std::shared_ptr<AAudioServiceInterface> service = getAAudioService();

    if (service.get() == nullptr) return AAUDIO_ERROR_NO_SERVICE;



    return service->pauseStream(streamHandle);

    return service->pauseStream(streamHandleInfo);

}



aaudio_result_t AAudioBinderClient::stopStream(aaudio_handle_t streamHandle) {

aaudio_result_t AAudioBinderClient::stopStream(const AAudioHandleInfo& streamHandleInfo) {

    std::shared_ptr<AAudioServiceInterface> service = getAAudioService();

    if (service.get() == nullptr) return AAUDIO_ERROR_NO_SERVICE;



    return service->stopStream(streamHandle);

    return service->stopStream(streamHandleInfo);

}



aaudio_result_t AAudioBinderClient::flushStream(aaudio_handle_t streamHandle) {

aaudio_result_t AAudioBinderClient::flushStream(const AAudioHandleInfo& streamHandleInfo) {

    std::shared_ptr<AAudioServiceInterface> service = getAAudioService();

    if (service.get() == nullptr) return AAUDIO_ERROR_NO_SERVICE;



    return service->flushStream(streamHandle);

    return service->flushStream(streamHandleInfo);

}



/**

* Manage the specified thread as a low latency audio thread.

*/

aaudio_result_t AAudioBinderClient::registerAudioThread(aaudio_handle_t streamHandle,

aaudio_result_t AAudioBinderClient::registerAudioThread(const AAudioHandleInfo& streamHandleInfo,

                                                        pid_t clientThreadId,

                                                        int64_t periodNanoseconds) {

    std::shared_ptr<AAudioServiceInterface> service = getAAudioService();

    if (service.get() == nullptr) return AAUDIO_ERROR_NO_SERVICE;



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

    return service->registerAudioThread(streamHandleInfo, clientThreadId, periodNanoseconds);

}



aaudio_result_t AAudioBinderClient::unregisterAudioThread(aaudio_handle_t streamHandle,

aaudio_result_t AAudioBinderClient::unregisterAudioThread(const AAudioHandleInfo& streamHandleInfo,

                                                          pid_t clientThreadId) {

    std::shared_ptr<AAudioServiceInterface> service = getAAudioService();

    if (service.get() == nullptr) return AAUDIO_ERROR_NO_SERVICE;



    return service->unregisterAudioThread(streamHandle, clientThreadId);

    return service->unregisterAudioThread(streamHandleInfo, clientThreadId);

}



aaudio_result_t AAudioBinderClient::exitStandby(aaudio_handle_t streamHandle,

aaudio_result_t AAudioBinderClient::exitStandby(const AAudioHandleInfo& streamHandleInfo,

                                                AudioEndpointParcelable &endpointOut) {

    std::shared_ptr<AAudioServiceInterface> service = getAAudioService();

    if (service.get() == nullptr) return AAUDIO_ERROR_NO_SERVICE;



    return service->exitStandby(streamHandle, endpointOut);

    return service->exitStandby(streamHandleInfo, endpointOut);

}

media/libaaudio/src/binding/AAudioBinderClient.h

+37 −21
Original line number Diff line number Diff line
@@ -17,6 +17,8 @@ 
#ifndef ANDROID_AAUDIO_AAUDIO_BINDER_CLIENT_H

#define ANDROID_AAUDIO_AAUDIO_BINDER_CLIENT_H



#include <mutex>



#include <utils/RefBase.h>

#include <utils/Singleton.h>
@@ -52,63 +54,66 @@ public: 
    /**

     * @param request info needed to create the stream

     * @param configuration contains resulting information about the created stream

     * @return handle to the stream or a negative error

     * @return an object for aaudio handle information, which includes the connected

     *         aaudio service lifetime id to recognize the connected aaudio service

     *         and aaudio handle to recognize the stream. If an error occurs, the

     *         aaudio handle will be set as the negative error.

     */

    aaudio_handle_t openStream(const AAudioStreamRequest &request,

    AAudioHandleInfo openStream(const AAudioStreamRequest &request,

                                AAudioStreamConfiguration &configurationOutput) override;



    aaudio_result_t closeStream(aaudio_handle_t streamHandle) override;

    aaudio_result_t closeStream(const AAudioHandleInfo& streamHandleInfo) override;



    /* Get an immutable description of the in-memory queues

    * used to communicate with the underlying HAL or Service.

    */

    aaudio_result_t getStreamDescription(aaudio_handle_t streamHandle,

    aaudio_result_t getStreamDescription(const AAudioHandleInfo& streamHandleInfo,

                                         AudioEndpointParcelable &endpointOut) override;



    /**

     * Start the flow of data.

     * This is asynchronous. When complete, the service will send a STARTED event.

     */

    aaudio_result_t startStream(aaudio_handle_t streamHandle) override;

    aaudio_result_t startStream(const AAudioHandleInfo& streamHandleInfo) override;



    /**

     * Stop the flow of data such that start() can resume without loss of data.

     * This is asynchronous. When complete, the service will send a PAUSED event.

     */

    aaudio_result_t pauseStream(aaudio_handle_t streamHandle) override;

    aaudio_result_t pauseStream(const AAudioHandleInfo& streamHandleInfo) override;



    aaudio_result_t stopStream(aaudio_handle_t streamHandle) override;

    aaudio_result_t stopStream(const AAudioHandleInfo& streamHandleInfo) override;



    /**

     *  Discard any data held by the underlying HAL or Service.

     * This is asynchronous. When complete, the service will send a FLUSHED event.

     */

    aaudio_result_t flushStream(aaudio_handle_t streamHandle) override;

    aaudio_result_t flushStream(const AAudioHandleInfo& streamHandleInfo) override;



    /**

     * Manage the specified thread as a low latency audio thread.

     * TODO Consider passing this information as part of the startStream() call.

     */

    aaudio_result_t registerAudioThread(aaudio_handle_t streamHandle,

    aaudio_result_t registerAudioThread(const AAudioHandleInfo& streamHandleInfo,

                                        pid_t clientThreadId,

                                        int64_t periodNanoseconds) override;



    aaudio_result_t unregisterAudioThread(aaudio_handle_t streamHandle,

    aaudio_result_t unregisterAudioThread(const AAudioHandleInfo& streamHandleInfo,

                                          pid_t clientThreadId) override;



    aaudio_result_t startClient(aaudio_handle_t streamHandle __unused,

    aaudio_result_t startClient(const AAudioHandleInfo& streamHandleInfo __unused,

                                const android::AudioClient& client __unused,

                                const audio_attributes_t *attr __unused,

                                audio_port_handle_t *clientHandle __unused) override {

        return AAUDIO_ERROR_UNAVAILABLE;

    }



    aaudio_result_t stopClient(aaudio_handle_t streamHandle __unused,

    aaudio_result_t stopClient(const AAudioHandleInfo& streamHandleInfo __unused,

                               audio_port_handle_t clientHandle __unused)  override {

        return AAUDIO_ERROR_UNAVAILABLE;

    }



    aaudio_result_t exitStandby(aaudio_handle_t streamHandle,

    aaudio_result_t exitStandby(const AAudioHandleInfo& streamHandleInfo,

                                AudioEndpointParcelable &endpointOut) override;



    void onStreamChange(aaudio_handle_t /*handle*/, int32_t /*opcode*/, int32_t /*value*/) {
@@ -117,6 +122,10 @@ public: 
        ALOGW("onStreamChange called!");

    }



    int32_t getServiceLifetimeId() const {

        return mAAudioClient->getServiceLifetimeId();

    }



    class AAudioClient : public android::IBinder::DeathRecipient, public BnAAudioClient {

    public:

        explicit AAudioClient(const android::wp<AAudioBinderClient>& aaudioBinderClient)
@@ -125,6 +134,7 @@ public: 


        // implement DeathRecipient

        virtual void binderDied(const android::wp<android::IBinder>& who __unused) {

            mServiceLifetimeId++;

            android::sp<AAudioBinderClient> client = mBinderClient.promote();

            if (client.get() != nullptr) {

                client->dropAAudioService();
@@ -141,8 +151,13 @@ public: 
            }

            return android::binder::Status::ok();

        }



        int32_t getServiceLifetimeId() const {

            return mServiceLifetimeId.load();

        }

    private:

        android::wp<AAudioBinderClient> mBinderClient;

        std::atomic_int                 mServiceLifetimeId{0};

    };



    // This adapter is used to convert the binder interface (delegate) to the AudioServiceInterface
@@ -153,8 +168,9 @@ public: 
    class Adapter : public AAudioBinderAdapter {

    public:

        Adapter(const android::sp<IAAudioService>& delegate,

                android::sp<AAudioClient> aaudioClient)

                : AAudioBinderAdapter(delegate.get()),

                android::sp<AAudioClient> aaudioClient,

                int32_t serviceLifetimeId)

                : AAudioBinderAdapter(delegate.get(), serviceLifetimeId),

                  mDelegate(delegate),

                  mAAudioClient(std::move(aaudioClient)) {}
@@ -165,7 +181,7 @@ public: 
        }



        // This should never be called (call is rejected at the AudioBinderClient level).

        aaudio_result_t startClient(aaudio_handle_t streamHandle __unused,

        aaudio_result_t startClient(const AAudioHandleInfo& streamHandle __unused,

                                    const android::AudioClient& client __unused,

                                    const audio_attributes_t* attr __unused,

                                    audio_port_handle_t* clientHandle __unused) override {
@@ -174,7 +190,7 @@ public: 
        }



        // This should never be called (call is rejected at the AudioBinderClient level).

        aaudio_result_t stopClient(aaudio_handle_t streamHandle __unused,

        aaudio_result_t stopClient(const AAudioHandleInfo& streamHandle __unused,

                                   audio_port_handle_t clientHandle __unused) override {

            LOG_ALWAYS_FATAL("Shouldn't get here");

            return AAUDIO_ERROR_UNAVAILABLE;

media/libaaudio/src/binding/AAudioServiceDefinitions.h

+17 −0
Original line number Diff line number Diff line
@@ -85,6 +85,23 @@ typedef struct EndpointDescriptor_s { 
    RingBufferDescriptor dataQueueDescriptor;    // playback or capture

} EndpointDescriptor;



static constexpr int32_t AAUDIO_SERVICE_LIFETIME_ID_INVALID = -1;



class AAudioHandleInfo {

public:

    AAudioHandleInfo()

            : AAudioHandleInfo(AAUDIO_SERVICE_LIFETIME_ID_INVALID, AAUDIO_HANDLE_INVALID) {}

    AAudioHandleInfo(int32_t serviceLifetimeId, aaudio_handle_t handle)

            : mServiceLifetimeId(serviceLifetimeId), mHandle(handle) {}



    int32_t getServiceLifetimeId() const { return mServiceLifetimeId; }

    aaudio_handle_t getHandle() const { return mHandle; }



private:

    int32_t mServiceLifetimeId;

    aaudio_handle_t mHandle;

};



} // namespace aaudio



#endif //BINDING_AAUDIOSERVICEDEFINITIONS_H