Create native version of Thermal Throttling API.
Create native thermal manager API of thermal mananger service.
Export libthermal NDK library.
Bug: 137151587
Bug: 136285293
Test: build, atest thermalmanager-test
Change-Id: I1ec7c746f7e814c701b306e06fe08c3641c39e88
diff --git a/services/powermanager/Android.bp b/services/powermanager/Android.bp
index 7b3af70..3e0f136 100644
--- a/services/powermanager/Android.bp
+++ b/services/powermanager/Android.bp
@@ -1,11 +1,25 @@
cc_library_shared {
name: "libpowermanager",
- srcs: ["IPowerManager.cpp"],
+ srcs: [
+ "IPowerManager.cpp",
+ "Temperature.cpp",
+ "CoolingDevice.cpp",
+ ":libpowermanager_aidl",
+ ],
+
+ aidl: {
+ local_include_dirs: ["."],
+ include_dirs: [
+ "frameworks/base/core/java/android/os",
+ ],
+ export_aidl_headers: true
+ },
shared_libs: [
"libutils",
"libbinder",
+ "liblog"
],
cflags: [
@@ -15,3 +29,22 @@
"-Wunreachable-code",
],
}
+
+cc_test {
+ name: "thermalmanager-test",
+ srcs: ["IThermalManagerTest.cpp",
+ ],
+ cflags: [
+ "-Wall",
+ "-Werror",
+ "-Wextra",
+ ],
+ shared_libs: [
+ "libbase",
+ "libhidlbase",
+ "liblog",
+ "libpowermanager",
+ "libbinder",
+ "libutils",
+ ],
+}
diff --git a/services/powermanager/CoolingDevice.cpp b/services/powermanager/CoolingDevice.cpp
new file mode 100644
index 0000000..ebbc1b4
--- /dev/null
+++ b/services/powermanager/CoolingDevice.cpp
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2020 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 "CoolingDevice"
+
+#include <android/CoolingDevice.h>
+#include <binder/Parcel.h>
+#include <utils/Log.h>
+
+namespace android {
+namespace os {
+
+status_t CoolingDevice::readFromParcel(const android::Parcel *parcel) {
+ if (parcel == nullptr) {
+ ALOGE("%s: Null parcel", __FUNCTION__);
+ return BAD_VALUE;
+ }
+
+ parcel->readFloat(&mValue);
+ parcel->readUint32(&mType);
+ parcel->readString16(&mName);
+
+ return OK;
+}
+
+status_t CoolingDevice::writeToParcel(android::Parcel *parcel) const {
+ if (parcel == nullptr) {
+ ALOGE("%s: Null parcel", __FUNCTION__);
+ return BAD_VALUE;
+ }
+
+ parcel->writeFloat(mValue);
+ parcel->writeUint32(mType);
+ parcel->writeString16(mName);
+
+ return OK;
+}
+
+} // namespace os
+} // namespace android
\ No newline at end of file
diff --git a/services/powermanager/IThermalManagerTest.cpp b/services/powermanager/IThermalManagerTest.cpp
new file mode 100644
index 0000000..575b9ee
--- /dev/null
+++ b/services/powermanager/IThermalManagerTest.cpp
@@ -0,0 +1,158 @@
+/*
+ * Copyright (C) 2020 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 "ThermalManagerTest"
+//#define LOG_NDEBUG 0
+
+#include <thread>
+
+#include <android/os/BnThermalStatusListener.h>
+#include <android/os/IThermalService.h>
+#include <binder/IPCThreadState.h>
+#include <binder/IServiceManager.h>
+#include <binder/Parcel.h>
+#include <condition_variable>
+#include <gtest/gtest.h>
+#include <powermanager/PowerManager.h>
+#include <utils/Log.h>
+
+using namespace android;
+using namespace android::os;
+using namespace std::chrono_literals;
+
+class IThermalServiceTest : public testing::Test,
+ public BnThermalStatusListener{
+ public:
+ IThermalServiceTest();
+ void setThermalOverride(int level);
+ virtual binder::Status onStatusChange(int status) override;
+ int getStatusFromService();
+ void SetUp() override;
+ void TearDown() override;
+ protected:
+ sp<IThermalService> mThermalSvc;
+ std::condition_variable mCondition;
+ int mListenerStatus;
+ int mServiceStatus;
+ std::mutex mMutex;
+};
+
+IThermalServiceTest::IThermalServiceTest()
+ : mListenerStatus(0),
+ mServiceStatus(0) {
+}
+
+void IThermalServiceTest::setThermalOverride(int level) {
+ std::string cmdStr = "cmd thermalservice override-status " + std::to_string(level);
+ system(cmdStr.c_str());
+}
+
+binder::Status IThermalServiceTest::onStatusChange(int status) {
+ std::unique_lock<std::mutex> lock(mMutex);
+ mListenerStatus = status;
+ ALOGI("IThermalServiceTest::notifyListener %d", mListenerStatus);
+ mCondition.notify_all();
+ return binder::Status::ok();
+}
+
+int IThermalServiceTest::getStatusFromService() {
+ int status;
+ binder::Status ret = mThermalSvc->getCurrentThermalStatus(&status);
+ if (ret.isOk()) {
+ return status;
+ } else {
+ return BAD_VALUE;
+ }
+}
+
+void IThermalServiceTest::SetUp() {
+ setThermalOverride(0);
+ // use checkService() to avoid blocking if thermal service is not up yet
+ sp<IBinder> binder =
+ defaultServiceManager()->checkService(String16("thermalservice"));
+ EXPECT_NE(binder, nullptr);
+ mThermalSvc = interface_cast<IThermalService>(binder);
+ EXPECT_NE(mThermalSvc, nullptr);
+ bool success = false;
+ binder::Status ret = mThermalSvc->registerThermalStatusListener(this, &success);
+ ASSERT_TRUE(success);
+ ASSERT_TRUE(ret.isOk());
+ // Wait for listener called after registration, shouldn't timeout
+ std::unique_lock<std::mutex> lock(mMutex);
+ EXPECT_NE(mCondition.wait_for(lock, 1s), std::cv_status::timeout);
+}
+
+void IThermalServiceTest::TearDown() {
+ bool success = false;
+ binder::Status ret = mThermalSvc->unregisterThermalStatusListener(this, &success);
+ ASSERT_TRUE(success);
+ ASSERT_TRUE(ret.isOk());
+}
+
+class IThermalListenerTest : public IThermalServiceTest, public testing::WithParamInterface<int32_t> {
+ public:
+ static auto PrintParam(const testing::TestParamInfo<ParamType> &info) {
+ return std::to_string(info.param);
+ }
+};
+
+TEST_P(IThermalListenerTest, TestListener) {
+ int level = GetParam();
+ std::unique_lock<std::mutex> lock(mMutex);
+ // Set the override thermal status
+ setThermalOverride(level);
+ // Wait for listener called, shouldn't timeout
+ EXPECT_NE(mCondition.wait_for(lock, 1s), std::cv_status::timeout);
+ // Check the result
+ EXPECT_EQ(level, mListenerStatus);
+ ALOGI("Thermal listener status %d, expecting %d", mListenerStatus, level);
+}
+
+INSTANTIATE_TEST_SUITE_P(TestListenerLevels, IThermalListenerTest, testing::Range(
+ static_cast<int>(ThermalStatus::THERMAL_STATUS_LIGHT),
+ static_cast<int>(ThermalStatus::THERMAL_STATUS_SHUTDOWN)),
+ IThermalListenerTest::PrintParam);
+
+class IThermalLevelTest : public IThermalServiceTest, public testing::WithParamInterface<int32_t> {
+ public:
+ static auto PrintParam(const testing::TestParamInfo<ParamType> &info) {
+ return std::to_string(info.param);
+ }
+};
+
+TEST_P(IThermalLevelTest, TestGetStatusLevel) {
+ int level = GetParam();
+ setThermalOverride(level);
+ mServiceStatus = getStatusFromService();
+ EXPECT_EQ(level, mServiceStatus);
+}
+
+INSTANTIATE_TEST_SUITE_P(TestStatusLevels, IThermalLevelTest, testing::Range(
+ static_cast<int>(ThermalStatus::THERMAL_STATUS_NONE),
+ static_cast<int>(ThermalStatus::THERMAL_STATUS_SHUTDOWN)),
+ IThermalLevelTest::PrintParam);
+
+int main(int argc, char **argv) {
+ std::unique_ptr<std::thread> binderLoop;
+ binderLoop = std::make_unique<std::thread>(
+ [&] { IPCThreadState::self()->joinThreadPool(true); });
+
+ ::testing::InitGoogleTest(&argc, argv);
+ int status = RUN_ALL_TESTS();
+ ALOGV("Test result = %d\n", status);
+
+ return status;
+}
\ No newline at end of file
diff --git a/services/powermanager/Temperature.cpp b/services/powermanager/Temperature.cpp
new file mode 100644
index 0000000..8ec0a87
--- /dev/null
+++ b/services/powermanager/Temperature.cpp
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2020 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 "Temperature"
+
+#include <android/Temperature.h>
+#include <binder/Parcel.h>
+#include <utils/Log.h>
+
+namespace android {
+namespace os {
+
+status_t Temperature::readFromParcel(const android::Parcel *parcel) {
+ if (parcel == nullptr) {
+ ALOGE("%s: Null parcel", __FUNCTION__);
+ return BAD_VALUE;
+ }
+
+ parcel->readFloat(&mValue);
+ parcel->readInt32(&mType);
+ parcel->readString16(&mName);
+ parcel->readInt32(&mStatus);
+
+ return OK;
+}
+
+status_t Temperature::writeToParcel(android::Parcel *parcel) const {
+ if (parcel == nullptr) {
+ ALOGE("%s: Null parcel", __FUNCTION__);
+ return BAD_VALUE;
+ }
+
+ parcel->writeFloat(mValue);
+ parcel->writeInt32(mType);
+ parcel->writeString16(mName);
+ parcel->writeInt32(mStatus);
+
+ return OK;
+}
+
+} // namespace os
+} // namespace android
\ No newline at end of file