platform_hardware_libhardware_legacy/power.cpp

/*
 * Copyright (C) 2018 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 "power"
#define ATRACE_TAG ATRACE_TAG_POWER

#include <hardware_legacy/power.h>
#include <wakelock/wakelock.h>

#include <android-base/logging.h>
#include <android/system/suspend/1.0/ISystemSuspend.h>
#include <utils/Trace.h>

#include <mutex>
#include <string>
#include <thread>
#include <unordered_map>

using android::sp;
using android::system::suspend::V1_0::ISystemSuspend;
using android::system::suspend::V1_0::IWakeLock;
using android::system::suspend::V1_0::WakeLockType;

static std::mutex gLock;
static std::unordered_map<std::string, sp<IWakeLock>> gWakeLockMap;

static const sp<ISystemSuspend>& getSystemSuspendServiceOnce() {
    static sp<ISystemSuspend> suspendService = ISystemSuspend::getService();
    return suspendService;
}

int acquire_wake_lock(int, const char* id) {
    ATRACE_CALL();
    const auto& suspendService = getSystemSuspendServiceOnce();
    if (!suspendService) {
        LOG(ERROR) << "ISystemSuspend::getService() failed.";
        return -1;
    }

    std::lock_guard<std::mutex> l{gLock};
    if (!gWakeLockMap[id]) {
        auto ret = suspendService->acquireWakeLock(WakeLockType::PARTIAL, id);
        // It's possible that during device shutdown SystemSuspend service has already exited. In
        // these situations HIDL calls to it will result in a DEAD_OBJECT transaction error. We
        // check for DEAD_OBJECT so that libpower clients can shutdown cleanly.
        if (ret.isDeadObject()) {
            return -1;
        } else {
            gWakeLockMap[id] = ret;
        }
    }
    return 0;
}

int release_wake_lock(const char* id) {
    ATRACE_CALL();
    std::lock_guard<std::mutex> l{gLock};
    if (gWakeLockMap[id]) {
        // Ignore errors on release() call since hwbinder driver will clean up the underlying object
        // once we clear the corresponding strong pointer.
        auto ret = gWakeLockMap[id]->release();
        if (!ret.isOk()) {
            LOG(ERROR) << "IWakeLock::release() call failed: " << ret.description();
        }
        gWakeLockMap[id].clear();
        return 0;
    }
    return -1;
}

namespace android {
namespace wakelock {

class WakeLock::WakeLockImpl {
  public:
    WakeLockImpl(const std::string& name);
    ~WakeLockImpl();
    bool acquireOk();

  private:
    sp<IWakeLock> mWakeLock;
};

std::optional<WakeLock> WakeLock::tryGet(const std::string& name) {
    std::unique_ptr<WakeLockImpl> wlImpl = std::make_unique<WakeLockImpl>(name);
    if (wlImpl->acquireOk()) {
        return { std::move(wlImpl) };
    } else {
        LOG(ERROR) << "Failed to acquire wakelock: " << name;
        return {};
    }
}

WakeLock::WakeLock(std::unique_ptr<WakeLockImpl> wlImpl) : mImpl(std::move(wlImpl)) {}

WakeLock::~WakeLock() = default;

WakeLock::WakeLockImpl::WakeLockImpl(const std::string& name) : mWakeLock(nullptr) {
    static sp<ISystemSuspend> suspendService = ISystemSuspend::getService();
    auto ret = suspendService->acquireWakeLock(WakeLockType::PARTIAL, name);
    // It's possible that during device SystemSuspend service is not avaiable. In these
    // situations HIDL calls to it will result in a DEAD_OBJECT transaction error.
    if (ret.isDeadObject()) {
        LOG(ERROR) << "ISuspendService::acquireWakeLock() call failed: " << ret.description();
    } else {
        mWakeLock = ret;
    }
}

WakeLock::WakeLockImpl::~WakeLockImpl() {
    if (!acquireOk()) {
        return;
    }
    auto ret = mWakeLock->release();
    if (!ret.isOk()) {
        LOG(ERROR) << "IWakeLock::release() call failed: " << ret.description();
    }
}

bool WakeLock::WakeLockImpl::acquireOk() {
    return mWakeLock != nullptr;
}

}  // namespace wakelock
}  // namespace android