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

Commit d186cc87 authored by android-build-team Robot's avatar android-build-team Robot
Browse files

release-request-323db86e-b638-4d24-8eb1-d2e3bf4a9d1a-for-git_oc-mr1-release-40...

release-request-323db86e-b638-4d24-8eb1-d2e3bf4a9d1a-for-git_oc-mr1-release-4017779 snap-temp-L47900000064949209

Change-Id: Iec471c13115d242fee46cc0c3e18989bf4e93458
parents f245522e 33b92997
Loading
Loading
Loading
Loading
+1 −5
Original line number Diff line number Diff line
@@ -14,15 +14,11 @@
# limitations under the License.
#

#
# Below are some minor deviations from the default Google style to
# accommodate for handling of the large legacy code base.
#

BasedOnStyle: Google
CommentPragmas: NOLINT:.*
DerivePointerAlignment: false
AllowShortFunctionsOnASingleLine: Inline
ColumnLimit: 100
TabWidth: 4
UseTab: Never
IndentWidth: 4
+3 −0
Original line number Diff line number Diff line
@@ -52,3 +52,6 @@ $(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/bin/hw/android.hardware.blue
$(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/lib/hw/android.hardware.bluetooth*)
$(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/lib64/hw/android.hardware.bluetooth*)
$(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/etc/init/android.hardware.bluetooth*)
$(call add-clean-step, rm -rf $(OUT)/soong/.intermediates/)
$(call add-clean-step, rm -rf $(OUT_DIR)/soong/.intermediates/hardware/interfaces/)
$(call add-clean-step, rm -rf $(OUT_DIR)/soong/.intermediates/hardware/interfaces/)
+2 −4
Original line number Diff line number Diff line
@@ -17,7 +17,7 @@ filegroup {
genrule {
    name: "android.hardware.audio@2.0_genc++",
    tools: ["hidl-gen"],
    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.audio@2.0",
    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.audio@2.0",
    srcs: [
        ":android.hardware.audio@2.0_hal",
    ],
@@ -36,7 +36,7 @@ genrule {
genrule {
    name: "android.hardware.audio@2.0_genc++_headers",
    tools: ["hidl-gen"],
    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.audio@2.0",
    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.audio@2.0",
    srcs: [
        ":android.hardware.audio@2.0_hal",
    ],
@@ -95,7 +95,6 @@ cc_library_shared {
        "libutils",
        "libcutils",
        "android.hardware.audio.common@2.0",
        "android.hidl.base@1.0",
    ],
    export_shared_lib_headers: [
        "libhidlbase",
@@ -103,6 +102,5 @@ cc_library_shared {
        "libhwbinder",
        "libutils",
        "android.hardware.audio.common@2.0",
        "android.hidl.base@1.0",
    ],
}
+177 −110
Original line number Diff line number Diff line
@@ -17,9 +17,11 @@
#define LOG_TAG "DeviceHAL"
//#define LOG_NDEBUG 0

#include <algorithm>
#include <memory.h>
#include <string.h>
#include <algorithm>
#include <mutex>
#include <vector>

#include <android/log.h>

@@ -28,6 +30,7 @@
#include "HidlUtils.h"
#include "StreamIn.h"
#include "StreamOut.h"
#include "Util.h"

namespace android {
namespace hardware {
@@ -35,13 +38,63 @@ namespace audio {
namespace V2_0 {
namespace implementation {

Device::Device(audio_hw_device_t* device)
        : mDevice(device) {
namespace {

class Diagnostics {
   public:
    static Diagnostics& getInstance() {
        std::lock_guard<std::mutex> _(mLock);
        if (mInstance == nullptr) {
            mInstance = new Diagnostics;
        }
        return *mInstance;
    }

    void registerDevice(Device* dev) {
        std::lock_guard<std::mutex> _(mLock);
        mDevices.push_back(wp<Device>(dev));
    }

    void checkForErasedHalCblk(const Device* dev) {
        if (dev->version() != 0) return;  // all OK

        std::ostringstream ss;
        ss << "Zero HAL CB for " << dev->type() << ":" << std::hex
           << dev->device() << "; Others: ";
        {
            std::lock_guard<std::mutex> _(mLock);
            for (auto wp : mDevices) {
                sp<Device> other{wp.promote()};
                if (other.get() == nullptr || other.get() == dev) continue;
                ss << other->type() << ":" << other->version() << ":"
                   << std::hex << other->device() << "; ";
            }
        }
        ALOGE("%s", ss.str().c_str());
    }

   private:
    Diagnostics() {}

    static std::mutex mLock;
    static Diagnostics* mInstance;
    std::vector<wp<Device>> mDevices;
};

std::mutex Diagnostics::mLock;
Diagnostics* Diagnostics::mInstance{nullptr};

}  // namespace

Device::Device(audio_hw_device_t* device, const char* type)
    : mDevice{device}, mType{type} {
    Diagnostics::getInstance().registerDevice(this);
}

Device::~Device() {
    int status = audio_hw_device_close(mDevice);
    ALOGW_IF(status, "Error closing audio hw device %p: %s", mDevice, strerror(-status));
    ALOGW_IF(status, "Error closing audio hw device %p: %s", mDevice,
             strerror(-status));
    mDevice = nullptr;
}

@@ -50,12 +103,18 @@ Result Device::analyzeStatus(const char* funcName, int status) {
        ALOGW("Device %p %s: %s", mDevice, funcName, strerror(-status));
    }
    switch (status) {
        case 0: return Result::OK;
        case -EINVAL: return Result::INVALID_ARGUMENTS;
        case -ENODATA: return Result::INVALID_STATE;
        case -ENODEV: return Result::NOT_INITIALIZED;
        case -ENOSYS: return Result::NOT_SUPPORTED;
        default: return Result::INVALID_STATE;
        case 0:
            return Result::OK;
        case -EINVAL:
            return Result::INVALID_ARGUMENTS;
        case -ENODATA:
            return Result::INVALID_STATE;
        case -ENODEV:
            return Result::NOT_INITIALIZED;
        case -ENOSYS:
            return Result::NOT_SUPPORTED;
        default:
            return Result::INVALID_STATE;
    }
}

@@ -68,10 +127,12 @@ void Device::closeOutputStream(audio_stream_out_t* stream) {
}

char* Device::halGetParameters(const char* keys) {
    Diagnostics::getInstance().checkForErasedHalCblk(this);
    return mDevice->get_parameters(mDevice, keys);
}

int Device::halSetParameters(const char* keysAndValues) {
    Diagnostics::getInstance().checkForErasedHalCblk(this);
    return mDevice->set_parameters(mDevice, keysAndValues);
}

@@ -81,18 +142,23 @@ Return<Result> Device::initCheck() {
}

Return<Result> Device::setMasterVolume(float volume) {
    Result retval(Result::NOT_SUPPORTED);
    if (mDevice->set_master_volume != NULL) {
        retval = analyzeStatus("set_master_volume", mDevice->set_master_volume(mDevice, volume));
    if (mDevice->set_master_volume == NULL) {
        return Result::NOT_SUPPORTED;
    }
    return retval;
    if (!isGainNormalized(volume)) {
        ALOGW("Can not set a master volume (%f) outside [0,1]", volume);
        return Result::INVALID_ARGUMENTS;
    }
    return analyzeStatus("set_master_volume",
                         mDevice->set_master_volume(mDevice, volume));
}

Return<void> Device::getMasterVolume(getMasterVolume_cb _hidl_cb) {
    Result retval(Result::NOT_SUPPORTED);
    float volume = 0;
    if (mDevice->get_master_volume != NULL) {
        retval = analyzeStatus("get_master_volume", mDevice->get_master_volume(mDevice, &volume));
        retval = analyzeStatus("get_master_volume",
                               mDevice->get_master_volume(mDevice, &volume));
    }
    _hidl_cb(retval, volume);
    return Void();
@@ -104,7 +170,8 @@ Return<Result> Device::setMicMute(bool mute) {

Return<void> Device::getMicMute(getMicMute_cb _hidl_cb) {
    bool mute = false;
    Result retval = analyzeStatus("get_mic_mute", mDevice->get_mic_mute(mDevice, &mute));
    Result retval =
        analyzeStatus("get_mic_mute", mDevice->get_mic_mute(mDevice, &mute));
    _hidl_cb(retval, mute);
    return Void();
}
@@ -112,7 +179,8 @@ Return<void> Device::getMicMute(getMicMute_cb _hidl_cb) {
Return<Result> Device::setMasterMute(bool mute) {
    Result retval(Result::NOT_SUPPORTED);
    if (mDevice->set_master_mute != NULL) {
        retval = analyzeStatus("set_master_mute", mDevice->set_master_mute(mDevice, mute));
        retval = analyzeStatus("set_master_mute",
                               mDevice->set_master_mute(mDevice, mute));
    }
    return retval;
}
@@ -121,14 +189,15 @@ Return<void> Device::getMasterMute(getMasterMute_cb _hidl_cb) {
    Result retval(Result::NOT_SUPPORTED);
    bool mute = false;
    if (mDevice->get_master_mute != NULL) {
        retval = analyzeStatus("get_master_mute", mDevice->get_master_mute(mDevice, &mute));
        retval = analyzeStatus("get_master_mute",
                               mDevice->get_master_mute(mDevice, &mute));
    }
    _hidl_cb(retval, mute);
    return Void();
}

Return<void> Device::getInputBufferSize(
        const AudioConfig& config, getInputBufferSize_cb _hidl_cb)  {
Return<void> Device::getInputBufferSize(const AudioConfig& config,
                                        getInputBufferSize_cb _hidl_cb) {
    audio_config_t halConfig;
    HidlUtils::audioConfigToHal(config, &halConfig);
    size_t halBufferSize = mDevice->get_input_buffer_size(mDevice, &halConfig);
@@ -142,8 +211,7 @@ Return<void> Device::getInputBufferSize(
    return Void();
}

Return<void> Device::openOutputStream(
        int32_t ioHandle,
Return<void> Device::openOutputStream(int32_t ioHandle,
                                      const DeviceAddress& device,
                                      const AudioConfig& config,
                                      AudioOutputFlag flags,
@@ -151,19 +219,16 @@ Return<void> Device::openOutputStream(
    audio_config_t halConfig;
    HidlUtils::audioConfigToHal(config, &halConfig);
    audio_stream_out_t* halStream;
    ALOGV("open_output_stream handle: %d devices: %x flags: %#x "
    ALOGV(
        "open_output_stream handle: %d devices: %x flags: %#x "
        "srate: %d format %#x channels %x address %s",
            ioHandle,
            static_cast<audio_devices_t>(device.device), static_cast<audio_output_flags_t>(flags),
            halConfig.sample_rate, halConfig.format, halConfig.channel_mask,
        ioHandle, static_cast<audio_devices_t>(device.device),
        static_cast<audio_output_flags_t>(flags), halConfig.sample_rate,
        halConfig.format, halConfig.channel_mask,
        deviceAddressToHal(device).c_str());
    int status = mDevice->open_output_stream(
            mDevice,
            ioHandle,
            static_cast<audio_devices_t>(device.device),
            static_cast<audio_output_flags_t>(flags),
            &halConfig,
            &halStream,
        mDevice, ioHandle, static_cast<audio_devices_t>(device.device),
        static_cast<audio_output_flags_t>(flags), &halConfig, &halStream,
        deviceAddressToHal(device).c_str());
    ALOGV("open_output_stream status %d stream %p", status, halStream);
    sp<IStreamOut> streamOut;
@@ -172,33 +237,30 @@ Return<void> Device::openOutputStream(
    }
    AudioConfig suggestedConfig;
    HidlUtils::audioConfigFromHal(halConfig, &suggestedConfig);
    _hidl_cb(analyzeStatus("open_output_stream", status), streamOut, suggestedConfig);
    _hidl_cb(analyzeStatus("open_output_stream", status), streamOut,
             suggestedConfig);
    return Void();
}

Return<void> Device::openInputStream(
        int32_t ioHandle,
Return<void> Device::openInputStream(int32_t ioHandle,
                                     const DeviceAddress& device,
                                     const AudioConfig& config,
        AudioInputFlag flags,
        AudioSource source,
                                     AudioInputFlag flags, AudioSource source,
                                     openInputStream_cb _hidl_cb) {
    audio_config_t halConfig;
    HidlUtils::audioConfigToHal(config, &halConfig);
    audio_stream_in_t* halStream;
    ALOGV("open_input_stream handle: %d devices: %x flags: %#x "
    ALOGV(
        "open_input_stream handle: %d devices: %x flags: %#x "
        "srate: %d format %#x channels %x address %s source %d",
            ioHandle,
            static_cast<audio_devices_t>(device.device), static_cast<audio_input_flags_t>(flags),
            halConfig.sample_rate, halConfig.format, halConfig.channel_mask,
            deviceAddressToHal(device).c_str(), static_cast<audio_source_t>(source));
        ioHandle, static_cast<audio_devices_t>(device.device),
        static_cast<audio_input_flags_t>(flags), halConfig.sample_rate,
        halConfig.format, halConfig.channel_mask,
        deviceAddressToHal(device).c_str(),
        static_cast<audio_source_t>(source));
    int status = mDevice->open_input_stream(
            mDevice,
            ioHandle,
            static_cast<audio_devices_t>(device.device),
            &halConfig,
            &halStream,
            static_cast<audio_input_flags_t>(flags),
        mDevice, ioHandle, static_cast<audio_devices_t>(device.device),
        &halConfig, &halStream, static_cast<audio_input_flags_t>(flags),
        deviceAddressToHal(device).c_str(),
        static_cast<audio_source_t>(source));
    ALOGV("open_input_stream status %d stream %p", status, halStream);
@@ -208,7 +270,8 @@ Return<void> Device::openInputStream(
    }
    AudioConfig suggestedConfig;
    HidlUtils::audioConfigFromHal(halConfig, &suggestedConfig);
    _hidl_cb(analyzeStatus("open_input_stream", status), streamIn, suggestedConfig);
    _hidl_cb(analyzeStatus("open_input_stream", status), streamIn,
             suggestedConfig);
    return Void();
}

@@ -216,23 +279,21 @@ Return<bool> Device::supportsAudioPatches() {
    return version() >= AUDIO_DEVICE_API_VERSION_3_0;
}

Return<void> Device::createAudioPatch(
        const hidl_vec<AudioPortConfig>& sources,
Return<void> Device::createAudioPatch(const hidl_vec<AudioPortConfig>& sources,
                                      const hidl_vec<AudioPortConfig>& sinks,
                                      createAudioPatch_cb _hidl_cb) {
    Result retval(Result::NOT_SUPPORTED);
    AudioPatchHandle patch = 0;
    if (version() >= AUDIO_DEVICE_API_VERSION_3_0) {
        std::unique_ptr<audio_port_config[]> halSources(HidlUtils::audioPortConfigsToHal(sources));
        std::unique_ptr<audio_port_config[]> halSinks(HidlUtils::audioPortConfigsToHal(sinks));
        std::unique_ptr<audio_port_config[]> halSources(
            HidlUtils::audioPortConfigsToHal(sources));
        std::unique_ptr<audio_port_config[]> halSinks(
            HidlUtils::audioPortConfigsToHal(sinks));
        audio_patch_handle_t halPatch = AUDIO_PATCH_HANDLE_NONE;
        retval = analyzeStatus(
            "create_audio_patch",
                mDevice->create_audio_patch(
                        mDevice,
                        sources.size(), &halSources[0],
                        sinks.size(), &halSinks[0],
                        &halPatch));
            mDevice->create_audio_patch(mDevice, sources.size(), &halSources[0],
                                        sinks.size(), &halSinks[0], &halPatch));
        if (retval == Result::OK) {
            patch = static_cast<AudioPatchHandle>(halPatch);
        }
@@ -245,15 +306,18 @@ Return<Result> Device::releaseAudioPatch(int32_t patch) {
    if (version() >= AUDIO_DEVICE_API_VERSION_3_0) {
        return analyzeStatus(
            "release_audio_patch",
                mDevice->release_audio_patch(mDevice, static_cast<audio_patch_handle_t>(patch)));
            mDevice->release_audio_patch(
                mDevice, static_cast<audio_patch_handle_t>(patch)));
    }
    return Result::NOT_SUPPORTED;
}

Return<void> Device::getAudioPort(const AudioPort& port, getAudioPort_cb _hidl_cb)  {
Return<void> Device::getAudioPort(const AudioPort& port,
                                  getAudioPort_cb _hidl_cb) {
    audio_port halPort;
    HidlUtils::audioPortToHal(port, &halPort);
    Result retval = analyzeStatus("get_audio_port", mDevice->get_audio_port(mDevice, &halPort));
    Result retval = analyzeStatus("get_audio_port",
                                  mDevice->get_audio_port(mDevice, &halPort));
    AudioPort resultPort = port;
    if (retval == Result::OK) {
        HidlUtils::audioPortFromHal(halPort, &resultPort);
@@ -267,7 +331,8 @@ Return<Result> Device::setAudioPortConfig(const AudioPortConfig& config) {
        struct audio_port_config halPortConfig;
        HidlUtils::audioPortConfigToHal(config, &halPortConfig);
        return analyzeStatus(
                "set_audio_port_config", mDevice->set_audio_port_config(mDevice, &halPortConfig));
            "set_audio_port_config",
            mDevice->set_audio_port_config(mDevice, &halPortConfig));
    }
    return Result::NOT_SUPPORTED;
}
@@ -282,12 +347,14 @@ Return<Result> Device::setScreenState(bool turnedOn) {
    return setParam(AudioParameter::keyScreenState, turnedOn);
}

Return<void> Device::getParameters(const hidl_vec<hidl_string>& keys, getParameters_cb _hidl_cb)  {
Return<void> Device::getParameters(const hidl_vec<hidl_string>& keys,
                                   getParameters_cb _hidl_cb) {
    getParametersImpl(keys, _hidl_cb);
    return Void();
}

Return<Result> Device::setParameters(const hidl_vec<ParameterValue>& parameters)  {
Return<Result> Device::setParameters(
    const hidl_vec<ParameterValue>& parameters) {
    return setParametersImpl(parameters);
}

+5 −4
Original line number Diff line number Diff line
@@ -56,7 +56,7 @@ using ::android::hardware::hidl_string;
using ::android::sp;

struct Device : public IDevice, public ParametersUtil {
    explicit Device(audio_hw_device_t* device);
    Device(audio_hw_device_t* device, const char* type);

    // Methods from ::android::hardware::audio::V2_0::IDevice follow.
    Return<Result> initCheck()  override;
@@ -101,17 +101,18 @@ struct Device : public IDevice, public ParametersUtil {
    void closeInputStream(audio_stream_in_t* stream);
    void closeOutputStream(audio_stream_out_t* stream);
    audio_hw_device_t* device() const { return mDevice; }
    const char* type() const { return mType; }
    uint32_t version() const { return mDevice->common.version; }

   private:
    audio_hw_device_t *mDevice;
    const char* mType;

    virtual ~Device();

    // Methods from ParametersUtil.
    char* halGetParameters(const char* keys) override;
    int halSetParameters(const char* keysAndValues) override;

    uint32_t version() const { return mDevice->common.version; }
};

}  // namespace implementation
Loading