release-request-01b39c26-bf86-40a5-a7bf-8eb15c488673-for-git_oc-mr1-release-40... (bd592eec) · Commits · e / os / android_hardware_interfaces

contexthub/1.0/default/Contexthub.cpp

+38 −3

Original line number	Diff line number	Diff line
		@@ -38,6 +38,7 @@ static constexpr uint64_t ALL_APPS = UINT64_C(0xFFFFFFFFFFFFFFFF);
		Contexthub::Contexthub()
		: mInitCheck(NO_INIT),
		mContextHubModule(nullptr),
		mDeathRecipient(new DeathRecipient(this)),
		mIsTransactionPending(false) {
		const hw_module_t *module;

		@@ -96,7 +97,7 @@ Return<void> Contexthub::getHubs(getHubs_cb _hidl_cb) {
		c.stoppedPowerDrawMw = hubArray[i].stopped_power_draw_mw;
		c.sleepPowerDrawMw = hubArray[i].sleep_power_draw_mw;

		info.callBack = nullptr;
		info.callback = nullptr;
		info.osAppName = hubArray[i].os_app_name;
		mCachedHubInfo[hubArray[i].hub_id] = info;

		@@ -110,6 +111,16 @@ Return<void> Contexthub::getHubs(getHubs_cb _hidl_cb) {
		return Void();
		}

		Contexthub::DeathRecipient::DeathRecipient(sp<Contexthub> contexthub)
		: mContexthub(contexthub) {}

		void Contexthub::DeathRecipient::serviceDied(
		uint64_t cookie,
		const wp<::android::hidl::base::V1_0::IBase>& /who/) {
		uint32_t hubId = static_cast<uint32_t>(cookie);
		mContexthub->handleServiceDeath(hubId);
		}

		bool Contexthub::isValidHubId(uint32_t hubId) {
		if (!mCachedHubInfo.count(hubId)) {
		ALOGW("Hub information not found for hubId %" PRIu32, hubId);
		@@ -123,7 +134,7 @@ sp<IContexthubCallback> Contexthub::getCallBackForHubId(uint32_t hubId) {
		if (!isValidHubId(hubId)) {
		return nullptr;
		} else {
		return mCachedHubInfo[hubId].callBack;
		return mCachedHubInfo[hubId].callback;
		}
		}

		@@ -193,8 +204,22 @@ Return<Result> Contexthub::registerCallback(uint32_t hubId,
		contextHubCb,
		this) == 0) {
		// Initialized && valid hub && subscription successful
		if (mCachedHubInfo[hubId].callback != nullptr) {
		ALOGD("Modifying callback for hubId %" PRIu32, hubId);
		mCachedHubInfo[hubId].callback->unlinkToDeath(mDeathRecipient);
		}

		mCachedHubInfo[hubId].callback = cb;
		if (cb != nullptr) {
		Return<bool> linkResult = cb->linkToDeath(mDeathRecipient, hubId);
		bool linkSuccess = linkResult.isOk() ?
		static_cast<bool>(linkResult) : false;
		if (!linkSuccess) {
		ALOGW("Couldn't link death recipient for hubId %" PRIu32,
		hubId);
		}
		}
		retVal = Result::OK;
		mCachedHubInfo[hubId].callBack = cb;
		} else {
		// Initalized && valid hubId - but subscription unsuccessful
		// This is likely an internal error in the HAL implementation, but we
		@@ -309,6 +334,16 @@ int Contexthub::handleOsMessage(sp<IContexthubCallback> cb,
		return retVal;
		}

		void Contexthub::handleServiceDeath(uint32_t hubId) {
		ALOGI("Callback/service died for hubId %" PRIu32, hubId);
		int ret = mContextHubModule->subscribe_messages(hubId, nullptr, nullptr);
		if (ret != 0) {
		ALOGW("Failed to unregister callback from hubId %" PRIu32 ": %d",
		hubId, ret);
		}
		mCachedHubInfo[hubId].callback.clear();
		}

		int Contexthub::contextHubCb(uint32_t hubId,
		const struct hub_message_t *rxMsg,
		void *cookie) {

contexthub/1.0/default/Contexthub.h

+17 −2

Original line number	Diff line number	Diff line
		@@ -66,14 +66,26 @@ private:

		struct CachedHubInformation{
		struct hub_app_name_t osAppName;
		sp<IContexthubCallback> callBack;
		sp<IContexthubCallback> callback;
		};

		class DeathRecipient : public hidl_death_recipient {
		public:
		DeathRecipient(const sp<Contexthub> contexthub);

		void serviceDied(
		uint64_t cookie,
		const wp<::android::hidl::base::V1_0::IBase>& who) override;

		private:
		sp<Contexthub> mContexthub;
		};

		status_t mInitCheck;
		const struct context_hub_module_t *mContextHubModule;
		std::unordered_map<uint32_t, CachedHubInformation> mCachedHubInfo;

		sp<IContexthubCallback> mCb;
		sp<DeathRecipient> mDeathRecipient;
		bool mIsTransactionPending;
		uint32_t mTransactionId;

		@@ -86,6 +98,9 @@ private:
		const uint8_t *msg,
		int msgLen);

		// Handle the case where the callback registered for the given hub ID dies
		void handleServiceDeath(uint32_t hubId);

		static int contextHubCb(uint32_t hubId,
		const struct hub_message_t *rxMsg,
		void *cookie);

current.txt

+4 −0

Original line number	Diff line number	Diff line
		@@ -186,3 +186,7 @@ d781c8d7e7b3fe5cca8cf6e1d8806e770982ae5358c7816ed51b0f0ec272e70d android.hardwar
		b12ef0bdd8a4d247a8a6e960b227ed32383f2b0241f55d67fcea6eff6a6737fa android.hardware.wifi.supplicant@1.0::ISupplicantStaNetwork
		d8f0877ae1d321c1d884c7631dfe36cab0ec8a4b2863d4b687f85d3549a63bcc android.hardware.wifi.supplicant@1.0::ISupplicantStaNetworkCallback
		fe3c3c2f572b72f15f8594c538b0577bd5c28722c31879cfe6231330cddb6747 android.hardware.wifi.supplicant@1.0::types

		# ABI preserving changes to HALs released in Android O

		28e929b453df3d9f5060af2764e6cdb123ddb893e3e86923c877f6ff7e5f02c9 android.hardware.wifi@1.0::types

dumpstate/1.0/vts/functional/Android.bp

0 → 100644

+32 −0

Original line number	Diff line number	Diff line
		//
		// Copyright (C) 2017 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_test {
		name: "VtsHalDumpstateV1_0TargetTest",
		defaults: ["hidl_defaults"],
		srcs: ["VtsHalDumpstateV1_0TargetTest.cpp"],
		shared_libs: [
		"android.hardware.dumpstate@1.0",
		"libcutils",
		"libhidlbase",
		"liblog",
		"libutils",
		],
		static_libs: ["VtsHalHidlTargetTestBase"],
		cflags: [
		"-O0",
		"-g",
		]
		}

dumpstate/1.0/vts/functional/VtsHalDumpstateV1_0TargetTest.cpp

0 → 100644

+88 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2017 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 "dumpstate_hidl_hal_test"

		#include <android/hardware/dumpstate/1.0/IDumpstateDevice.h>
		#include <cutils/native_handle.h>
		#include <log/log.h>

		#include <VtsHalHidlTargetTestBase.h>

		using ::android::hardware::dumpstate::V1_0::IDumpstateDevice;
		using ::android::hardware::Return;
		using ::android::sp;

		class DumpstateHidlTest : public ::testing::VtsHalHidlTargetTestBase {
		public:
		virtual void SetUp() override {
		dumpstate = ::testing::VtsHalHidlTargetTestBase::getService<IDumpstateDevice>();
		ASSERT_NE(dumpstate, nullptr) << "Could not get HIDL instance";
		}

		sp<IDumpstateDevice> dumpstate;
		};

		// Negative test: make sure dumpstateBoard() doesn't crash when passed a null pointer.
		TEST_F(DumpstateHidlTest, TestNullHandle) {
		Return<void> status = dumpstate->dumpstateBoard(nullptr);

		ASSERT_TRUE(status.isOk()) << "Status should be ok: " << status.description();
		}

		// Negative test: make sure dumpstateBoard() ignores a handle with no FD.
		TEST_F(DumpstateHidlTest, TestHandleWithNoFd) {
		native_handle_t* handle = native_handle_create(0, 0);
		ASSERT_NE(handle, nullptr) << "Could not create native_handle";

		Return<void> status = dumpstate->dumpstateBoard(handle);

		ASSERT_TRUE(status.isOk()) << "Status should be ok: " << status.description();

		native_handle_close(handle);
		native_handle_delete(handle);
		}

		// Positive test: make sure dumpstateBoard() writes something to the FD.
		TEST_F(DumpstateHidlTest, TestOk) {
		FILE* file = tmpfile();
		ASSERT_NE(nullptr, file) << "Could not create temp file: " << strerror(errno);

		native_handle_t* handle = native_handle_create(1, 0);
		ASSERT_NE(handle, nullptr) << "Could not create native_handle";
		handle->data[0] = fileno(file);

		Return<void> status = dumpstate->dumpstateBoard(handle);
		ASSERT_TRUE(status.isOk()) << "Status should be ok: " << status.description();

		// Check that at least one byte was written
		rewind(file); // can not fail
		char buff;
		int read = fread(&buff, sizeof(buff), 1, file);
		ASSERT_EQ(1, read) << "dumped nothing";

		EXPECT_EQ(0, fclose(file)) << errno;

		native_handle_close(handle);
		native_handle_delete(handle);
		}

		int main(int argc, char** argv) {
		::testing::InitGoogleTest(&argc, argv);
		int status = RUN_ALL_TESTS();
		ALOGI("Test result = %d", status);
		return status;
		}