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

Commit 1784b9a3 authored by Steven Moreland's avatar Steven Moreland
Browse files

Remove vibrator@1.4 from VNDK. 

Because this HAL was converted to AIDL.

Can't be completely removed until frameworks/base is refactored not to
use it, but doing this so no more dependencies are accidentally taken
downstream.

Bug: 141828236
Test: N/A
Change-Id: Ic920f59a1a0ad933e5c80c468700ef4514b4a9c9
parent cb5d1077

compatibility_matrices/compatibility_matrix.current.xml

+1 −1
Original line number Diff line number Diff line
@@ -476,7 +476,7 @@ 
    </hal>

    <hal format="hidl" optional="true">

        <name>android.hardware.vibrator</name>

        <version>1.0-4</version>

        <version>1.0-3</version>

        <interface>

            <name>IVibrator</name>

            <instance>default</instance>

vibrator/1.4/Android.bp

+0 −3
Original line number Diff line number Diff line
@@ -3,9 +3,6 @@ 
hidl_interface {

    name: "android.hardware.vibrator@1.4",

    root: "android.hardware",

    vndk: {

        enabled: true,

    },

    srcs: [

        "types.hal",

        "IVibrator.hal",

vibrator/1.x/example/Android.bp

deleted100644 → 0
+0 −34
Original line number Diff line number Diff line 
//

// Copyright (C) 2019 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.



cc_binary {

    name: "android.hardware.vibrator@1.x-service.example",

    vendor: true,

    relative_install_path: "hw",

    init_rc: ["android.hardware.vibrator@1.x-service.example.rc"],

    vintf_fragments: ["android.hardware.vibrator@1.x-service.example.xml"],

    srcs: ["service.cpp", "Vibrator.cpp"],

    cflags: ["-Wall", "-Werror"],

    shared_libs: [

        "libhidlbase",

        "liblog",

        "libutils",

        "android.hardware.vibrator@1.0",

        "android.hardware.vibrator@1.1",

        "android.hardware.vibrator@1.2",

        "android.hardware.vibrator@1.3",

        "android.hardware.vibrator@1.4",

    ],

}

vibrator/1.x/example/OWNERS

deleted100644 → 0
+0 −2
Original line number Diff line number Diff line 
eliptus@google.com

michaelwr@google.com

vibrator/1.x/example/Vibrator.cpp

deleted100644 → 0
+0 −303
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2019 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 "VibratorService"



#include <log/log.h>



#include "Vibrator.h"



namespace android {

namespace hardware {

namespace vibrator {

namespace V1_4 {

namespace implementation {



static constexpr uint32_t MS_PER_S = 1000;

static constexpr uint32_t NS_PER_MS = 1000000;



Vibrator::Vibrator() {

    sigevent se{};

    se.sigev_notify = SIGEV_THREAD;

    se.sigev_value.sival_ptr = this;

    se.sigev_notify_function = timerCallback;

    se.sigev_notify_attributes = nullptr;



    if (timer_create(CLOCK_REALTIME, &se, &mTimer) < 0) {

        ALOGE("Can not create timer!%s", strerror(errno));

    }

}



// Methods from ::android::hardware::vibrator::V1_0::IVibrator follow.



Return<Status> Vibrator::on(uint32_t timeoutMs) {

    return activate(timeoutMs);

}



Return<Status> Vibrator::off() {

    return activate(0);

}



Return<bool> Vibrator::supportsAmplitudeControl() {

    return true;

}



Return<Status> Vibrator::setAmplitude(uint8_t amplitude) {

    if (!amplitude) {

        return Status::BAD_VALUE;

    }

    ALOGI("Amplitude: %u -> %u\n", mAmplitude, amplitude);

    mAmplitude = amplitude;

    return Status::OK;

}



Return<void> Vibrator::perform(V1_0::Effect effect, EffectStrength strength, perform_cb _hidl_cb) {

    return perform<decltype(effect)>(effect, strength, _hidl_cb);

}



// Methods from ::android::hardware::vibrator::V1_1::IVibrator follow.



Return<void> Vibrator::perform_1_1(V1_1::Effect_1_1 effect, EffectStrength strength,

                                   perform_cb _hidl_cb) {

    return perform<decltype(effect)>(effect, strength, _hidl_cb);

}



// Methods from ::android::hardware::vibrator::V1_2::IVibrator follow.



Return<void> Vibrator::perform_1_2(V1_2::Effect effect, EffectStrength strength,

                                   perform_cb _hidl_cb) {

    return perform<decltype(effect)>(effect, strength, _hidl_cb);

}



// Methods from ::android::hardware::vibrator::V1_3::IVibrator follow.



Return<bool> Vibrator::supportsExternalControl() {

    return true;

}



Return<Status> Vibrator::setExternalControl(bool enabled) {

    if (mEnabled) {

        ALOGW("Setting external control while the vibrator is enabled is unsupported!");

        return Status::UNSUPPORTED_OPERATION;

    } else {

        ALOGI("ExternalControl: %s -> %s\n", mExternalControl ? "true" : "false",

              enabled ? "true" : "false");

        mExternalControl = enabled;

        return Status::OK;

    }

}



Return<void> Vibrator::perform_1_3(V1_3::Effect effect, EffectStrength strength,

                                   perform_cb _hidl_cb) {

    return perform<decltype(effect)>(effect, strength, _hidl_cb);

}



// Methods from ::android::hardware::vibrator::V1_4::IVibrator follow.



Return<hidl_bitfield<Capabilities>> Vibrator::getCapabilities() {

    return Capabilities::ON_COMPLETION_CALLBACK | Capabilities::PERFORM_COMPLETION_CALLBACK;

}



Return<Status> Vibrator::on_1_4(uint32_t timeoutMs, const sp<IVibratorCallback>& callback) {

    mCallback = callback;

    return on(timeoutMs);

}



Return<void> Vibrator::perform_1_4(V1_3::Effect effect, EffectStrength strength,

                                   const sp<IVibratorCallback>& callback, perform_cb _hidl_cb) {

    mCallback = callback;

    return perform<decltype(effect)>(effect, strength, _hidl_cb);

}



// Private methods follow.



Return<void> Vibrator::perform(Effect effect, EffectStrength strength, perform_cb _hidl_cb) {

    uint8_t amplitude;

    uint32_t ms;

    Status status = Status::OK;



    ALOGI("Perform: Effect %s\n", effectToName(effect).c_str());



    amplitude = strengthToAmplitude(strength, &status);

    if (status != Status::OK) {

        _hidl_cb(status, 0);

        return Void();

    }

    setAmplitude(amplitude);



    ms = effectToMs(effect, &status);

    if (status != Status::OK) {

        _hidl_cb(status, 0);

        return Void();

    }

    status = activate(ms);



    _hidl_cb(status, ms);



    return Void();

}



template <typename T>

Return<void> Vibrator::perform(T effect, EffectStrength strength, perform_cb _hidl_cb) {

    auto validRange = hidl_enum_range<T>();

    if (effect < *validRange.begin() || effect > *std::prev(validRange.end())) {

        _hidl_cb(Status::UNSUPPORTED_OPERATION, 0);

        return Void();

    }

    return perform(static_cast<Effect>(effect), strength, _hidl_cb);

}



Status Vibrator::enable(bool enabled) {

    if (mExternalControl) {

        ALOGW("Enabling/disabling while the vibrator is externally controlled is unsupported!");

        return Status::UNSUPPORTED_OPERATION;

    } else {

        ALOGI("Enabled: %s -> %s\n", mEnabled ? "true" : "false", enabled ? "true" : "false");

        if (mEnabled && !enabled) {

            if (auto callback = mCallback) {

                mCallback = nullptr;

                if (auto ret = callback->onComplete(); !ret.isOk()) {

                    ALOGE("Failed completion callback: %s", ret.description().c_str());

                }

            }

        }

        mEnabled = enabled;

        return Status::OK;

    }

}



Status Vibrator::activate(uint32_t ms) {

    std::lock_guard<std::mutex> lock{mMutex};

    Status status = Status::OK;



    if (ms > 0) {

        status = enable(true);

        if (status != Status::OK) {

            return status;

        }

    }



    itimerspec ts{};

    ts.it_value.tv_sec = ms / MS_PER_S;

    ts.it_value.tv_nsec = ms % MS_PER_S * NS_PER_MS;



    if (timer_settime(mTimer, 0, &ts, nullptr) < 0) {

        ALOGE("Can not set timer!");

        status = Status::UNKNOWN_ERROR;

    }



    if ((status != Status::OK) || !ms) {

        Status _status;



        _status = enable(false);



        if (status == Status::OK) {

            status = _status;

        }

    }



    return status;

}



void Vibrator::timeout() {

    std::lock_guard<std::mutex> lock{mMutex};

    itimerspec ts{};



    if (timer_gettime(mTimer, &ts) < 0) {

        ALOGE("Can not read timer!");

    }



    if (ts.it_value.tv_sec == 0 && ts.it_value.tv_nsec == 0) {

        enable(false);

    }

}



void Vibrator::timerCallback(union sigval sigval) {

    static_cast<Vibrator*>(sigval.sival_ptr)->timeout();

}



const std::string Vibrator::effectToName(Effect effect) {

    return toString(effect);

}



uint32_t Vibrator::effectToMs(Effect effect, Status* status) {

    switch (effect) {

        case Effect::CLICK:

            return 10;

        case Effect::DOUBLE_CLICK:

            return 15;

        case Effect::TICK:

        case Effect::TEXTURE_TICK:

            return 5;

        case Effect::THUD:

            return 5;

        case Effect::POP:

            return 5;

        case Effect::HEAVY_CLICK:

            return 10;

        case Effect::RINGTONE_1:

            return 30000;

        case Effect::RINGTONE_2:

            return 30000;

        case Effect::RINGTONE_3:

            return 30000;

        case Effect::RINGTONE_4:

            return 30000;

        case Effect::RINGTONE_5:

            return 30000;

        case Effect::RINGTONE_6:

            return 30000;

        case Effect::RINGTONE_7:

            return 30000;

        case Effect::RINGTONE_8:

            return 30000;

        case Effect::RINGTONE_9:

            return 30000;

        case Effect::RINGTONE_10:

            return 30000;

        case Effect::RINGTONE_11:

            return 30000;

        case Effect::RINGTONE_12:

            return 30000;

        case Effect::RINGTONE_13:

            return 30000;

        case Effect::RINGTONE_14:

            return 30000;

        case Effect::RINGTONE_15:

            return 30000;

    }

    *status = Status::UNSUPPORTED_OPERATION;

    return 0;

}



uint8_t Vibrator::strengthToAmplitude(EffectStrength strength, Status* status) {

    switch (strength) {

        case EffectStrength::LIGHT:

            return 128;

        case EffectStrength::MEDIUM:

            return 192;

        case EffectStrength::STRONG:

            return 255;

    }

    *status = Status::UNSUPPORTED_OPERATION;

    return 0;

}



}  // namespace implementation

}  // namespace V1_4

}  // namespace vibrator

}  // namespace hardware

}  // namespace android