Merge "StreamOut: use atomic_sp<> for callback thread safety"

        "libaudio_system_headers",

        "libhardware_headers",

        "libmedia_headers",

        "libmediautils_headers",

    ],

    export_header_lib_headers: [

        status_t status = EventFlag::deleteEventFlag(&mEfGroup);

        ALOGE_IF(status, "write MQ event flag deletion error: %s", strerror(-status));

    }

    mCallback.clear();

    mCallback = nullptr;

#if MAJOR_VERSION <= 5

    mDevice->closeOutputStream(mStream);

    // Closing the output stream in the HAL waits for the callback to finish,

Return<Result> StreamOut::clearCallback() {

    if (mStream->set_callback == NULL) return Result::NOT_SUPPORTED;

    mCallback.clear();

    mCallback = nullptr;

    return Result::OK;

}

    // It's correct to hold an sp<> to callback because the reference

    // in the StreamOut instance can be cleared in the meantime. There is

    // no difference on which thread to run IStreamOutCallback's destructor.

    sp<IStreamOutCallback> callback = self->mCallback;

    sp<IStreamOutCallback> callback = self->mCallback.load();

    if (callback.get() == nullptr) return 0;

    ALOGV("asyncCallback() event %d", event);

    Return<void> result;

#include <fmq/MessageQueue.h>

#include <hidl/MQDescriptor.h>

#include <hidl/Status.h>

#include <mediautils/Synchronization.h>

#include <utils/Thread.h>

namespace android {

    audio_stream_out_t* mStream;

    const sp<Stream> mStreamCommon;

    const sp<StreamMmap<audio_stream_out_t>> mStreamMmap;

    sp<IStreamOutCallback> mCallback;  // Callback for non-blocking write and drain

    mediautils::atomic_sp<IStreamOutCallback> mCallback;  // for non-blocking write and drain

#if MAJOR_VERSION >= 6

    sp<IStreamOutEventCallback> mEventCallback;

#endif