Contexthub HAL default implementation and service. (1bec86a1) · Commits · e / os / android_hardware_interfaces

contexthub/1.0/default/Android.bp

0 → 100644

+33 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2016 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_library_shared {
		name: "android.hardware.contexthub@1.0-impl",
		relative_install_path: "hw",
		srcs: ["Contexthub.cpp"],
		shared_libs: [
		"liblog",
		"libcutils",
		"libhardware",
		"libhwbinder",
		"libbase",
		"libcutils",
		"libutils",
		"libhidlbase",
		"libhidltransport",
		"android.hardware.contexthub@1.0",
		],
		}

contexthub/1.0/default/Android.mk

0 → 100644

+23 −0

Original line number	Diff line number	Diff line
		LOCAL_PATH:= $(call my-dir)

		include $(CLEAR_VARS)
		LOCAL_MODULE_RELATIVE_PATH := hw
		LOCAL_MODULE := android.hardware.contexthub@1.0-service
		LOCAL_INIT_RC := android.hardware.contexthub@1.0-service.rc
		LOCAL_SRC_FILES := \
		service.cpp \

		LOCAL_SHARED_LIBRARIES := \
		libbase \
		libcutils \
		libdl \
		libhardware \
		libhardware_legacy \
		libhidlbase \
		libhidltransport \
		libhwbinder \
		liblog \
		libutils \
		android.hardware.contexthub@1.0 \

		include $(BUILD_EXECUTABLE)

contexthub/1.0/default/Contexthub.cpp

0 → 100644

+528 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2016 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.
		*/

		#include "Contexthub.h"

		#include <inttypes.h>

		#include <android/log.h>
		#include <android/hardware/contexthub/1.0/IContexthub.h>
		#include <hardware/context_hub.h>

		#undef LOG_TAG
		#define LOG_TAG "ContextHubHalAdapter"

		namespace android {
		namespace hardware {
		namespace contexthub {
		namespace V1_0 {
		namespace implementation {

		static constexpr uint64_t ALL_APPS = UINT64_C(0xFFFFFFFFFFFFFFFF);

		Contexthub::Contexthub()
		: mInitCheck(NO_INIT),
		mContextHubModule(nullptr),
		mIsTransactionPending(false) {
		const hw_module_t *module;

		mInitCheck = hw_get_module(CONTEXT_HUB_MODULE_ID, &module);

		if (mInitCheck != OK) {
		ALOGE("Could not load %s module: %s", CONTEXT_HUB_MODULE_ID, strerror(-mInitCheck));
		} else if (module == nullptr) {
		ALOGE("hal returned succes but a null module!");
		// Assign an error, this should not really happen...
		mInitCheck = UNKNOWN_ERROR;
		} else {
		ALOGI("Loaded Context Hub module");
		mContextHubModule = reinterpret_cast<const context_hub_module_t *>(module);
		}
		}

		bool Contexthub::setOsAppAsDestination(hub_message_t *msg, int hubId) {
		if (!isValidHubId(hubId)) {
		ALOGW("%s: Hub information is null for hubHandle %d",
		__FUNCTION__,
		hubId);
		return false;
		} else {
		msg->app_name = mCachedHubInfo[hubId].osAppName;
		return true;
		}
		}

		Return<void> Contexthub::getHubs(getHubs_cb _hidl_cb) {
		std::vector<ContextHub> hubs;
		if (isInitialized()) {
		const context_hub_t *hubArray = nullptr;
		size_t numHubs;

		// Explicitly discarding const. HAL method discards it.
		numHubs = mContextHubModule->get_hubs(const_cast<context_hub_module_t *>(mContextHubModule),
		&hubArray);
		ALOGI("Context Hub Hal Adapter reports %zu hubs", numHubs);

		mCachedHubInfo.clear();

		for (size_t i = 0; i < numHubs; i++) {
		CachedHubInformation info;
		ContextHub c;

		c.hubId = hubArray[i].hub_id;
		c.name = hubArray[i].name;
		c.vendor = hubArray[i].vendor;
		c.toolchain = hubArray[i].toolchain;
		c.toolchainVersion = hubArray[i].toolchain_version;
		c.platformVersion = hubArray[i].platform_version;
		c.maxSupportedMsgLen = hubArray[i].max_supported_msg_len;
		c.peakMips = hubArray[i].peak_mips;
		c.peakPowerDrawMw = hubArray[i].peak_power_draw_mw;
		c.stoppedPowerDrawMw = hubArray[i].stopped_power_draw_mw;
		c.sleepPowerDrawMw = hubArray[i].sleep_power_draw_mw;

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

		hubs.push_back(c);
		}
		} else {
		ALOGW("Context Hub Hal Adapter not initialized");
		}

		_hidl_cb(hubs);
		return Void();
		}

		bool Contexthub::isValidHubId(uint32_t hubId) {
		if (!mCachedHubInfo.count(hubId)) {
		ALOGW("Hub information not found for hubId %" PRIu32, hubId);
		return false;
		} else {
		return true;
		}
		}

		sp<IContexthubCallback> Contexthub::getCallBackForHubId(uint32_t hubId) {
		if (!isValidHubId(hubId)) {
		return nullptr;
		} else {
		return mCachedHubInfo[hubId].callBack;
		}
		}

		Return<Result> Contexthub::sendMessageToHub(uint32_t hubId,
		const ContextHubMsg &msg) {
		if (!isInitialized()) {
		return Result::NOT_INIT;
		}

		if (!isValidHubId(hubId) \|\| msg.msg.size() > UINT32_MAX) {
		return Result::BAD_PARAMS;
		}

		hub_message_t txMsg = {
		.app_name.id = msg.appName,
		.message_type = msg.msgType,
		.message_len = static_cast<uint32_t>(msg.msg.size()), // Note the check above
		.message = static_cast<const uint8_t *>(msg.msg.data()),
		};

		ALOGI("Sending msg of type %" PRIu32 ", size %" PRIu32 " to app 0x%" PRIx64,
		txMsg.message_type,
		txMsg.message_len,
		txMsg.app_name.id);

		if(mContextHubModule->send_message(hubId, &txMsg) != 0) {
		return Result::TRANSACTION_FAILED;
		}

		return Result::OK;
		}

		Return<Result> Contexthub::reboot(uint32_t hubId) {
		if (!isInitialized()) {
		return Result::NOT_INIT;
		}

		hub_message_t msg;

		if (setOsAppAsDestination(&msg, hubId) == false) {
		return Result::BAD_PARAMS;
		}

		msg.message_type = CONTEXT_HUB_OS_REBOOT;
		msg.message_len = 0;
		msg.message = nullptr;

		if(mContextHubModule->send_message(hubId, &msg) != 0) {
		return Result::TRANSACTION_FAILED;
		} else {
		return Result::OK;
		}
		}

		Return<Result> Contexthub::registerCallback(uint32_t hubId,
		const sp<IContexthubCallback> &cb) {
		Return<Result> retVal = Result::BAD_PARAMS;

		if (!isInitialized()) {
		// Not initilalized
		ALOGW("Context hub not initialized successfully");
		retVal = Result::NOT_INIT;
		} else if (!isValidHubId(hubId)) {
		// Initialized, but hubId is not valid
		retVal = Result::BAD_PARAMS;
		} else if (mContextHubModule->subscribe_messages(hubId,
		contextHubCb,
		this) == 0) {
		// Initialized && valid hub && subscription successful
		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
		// cannot add more information.
		ALOGW("Could not subscribe to the hub for callback");
		retVal = Result::UNKNOWN_FAILURE;
		}

		return retVal;
		}

		static bool isValidOsStatus(const uint8_t *msg,
		size_t msgLen,
		status_response_t *rsp) {
		// Workaround a bug in some HALs
		if (msgLen == 1) {
		rsp->result = msg[0];
		return true;
		}

		if (msg == nullptr \|\| msgLen != sizeof(*rsp)) {
		ALOGI("Received invalid response (is null : %d, size %zu)",
		msg == nullptr ? 1 : 0,
		msgLen);
		return false;
		}

		memcpy(rsp, msg, sizeof(*rsp));

		// No sanity checks on return values
		return true;
		}

		int Contexthub::handleOsMessage(sp<IContexthubCallback> cb,
		uint32_t msgType,
		const uint8_t *msg,
		int msgLen) {
		int retVal = -1;


		switch(msgType) {
		case CONTEXT_HUB_APPS_ENABLE:
		case CONTEXT_HUB_APPS_DISABLE:
		case CONTEXT_HUB_LOAD_APP:
		case CONTEXT_HUB_UNLOAD_APP:
		{
		struct status_response_t rsp;
		TransactionResult result;
		if (isValidOsStatus(msg, msgLen, &rsp) && rsp.result == 0) {
		retVal = 0;
		result = TransactionResult::SUCCESS;
		} else {
		result = TransactionResult::FAILURE;
		}

		if (cb != nullptr) {
		cb->handleTxnResult(mTransactionId, result);
		}
		retVal = 0;
		mIsTransactionPending = false;
		break;
		}

		case CONTEXT_HUB_QUERY_APPS:
		{
		std::vector<HubAppInfo> apps;
		int numApps = msgLen / sizeof(hub_app_info);
		const hub_app_info unalignedInfoAddr = reinterpret_cast<const hub_app_info >(msg);

		for (int i = 0; i < numApps; i++) {
		hub_app_info query_info;
		memcpy(&query_info, &unalignedInfoAddr[i], sizeof(query_info));
		HubAppInfo app;
		app.appId = query_info.app_name.id;
		app.version = query_info.version;
		// TODO :: Add memory ranges

		apps.push_back(app);
		}

		if (cb != nullptr) {
		cb->handleAppsInfo(apps);
		}
		retVal = 0;
		break;
		}

		case CONTEXT_HUB_QUERY_MEMORY:
		{
		// Deferring this use
		retVal = 0;
		break;
		}

		case CONTEXT_HUB_OS_REBOOT:
		{
		mIsTransactionPending = false;
		if (cb != nullptr) {
		cb->handleHubEvent(AsyncEventType::RESTARTED);
		}
		retVal = 0;
		break;
		}

		default:
		{
		retVal = -1;
		break;
		}
		}

		return retVal;
		}

		int Contexthub::contextHubCb(uint32_t hubId,
		const struct hub_message_t *rxMsg,
		void *cookie) {
		Contexthub obj = static_cast<Contexthub >(cookie);

		if (rxMsg == nullptr) {
		ALOGW("Ignoring NULL message");
		return -1;
		}

		if (!obj->isValidHubId(hubId)) {
		ALOGW("Invalid hub Id %" PRIu32, hubId);
		return -1;
		}

		sp<IContexthubCallback> cb = obj->getCallBackForHubId(hubId);

		if (cb == nullptr) {
		// This should not ever happen
		ALOGW("No callback registered, returning");
		return -1;
		}

		if (rxMsg->message_type < CONTEXT_HUB_TYPE_PRIVATE_MSG_BASE) {
		obj->handleOsMessage(cb,
		rxMsg->message_type,
		static_cast<const uint8_t *>(rxMsg->message),
		rxMsg->message_len);
		} else {
		ContextHubMsg msg;

		msg.appName = rxMsg->app_name.id;
		msg.msgType = rxMsg->message_type;
		msg.msg = std::vector<uint8_t>(static_cast<const uint8_t *>(rxMsg->message),
		static_cast<const uint8_t *>(rxMsg->message) +
		rxMsg->message_len);

		cb->handleClientMsg(msg);
		}

		return 0;
		}

		Return<Result> Contexthub::unloadNanoApp(uint32_t hubId,
		uint64_t appId,
		uint32_t transactionId) {
		if (!isInitialized()) {
		return Result::NOT_INIT;
		}

		if (mIsTransactionPending) {
		return Result::TRANSACTION_PENDING;
		}

		hub_message_t msg;

		if (setOsAppAsDestination(&msg, hubId) == false) {
		return Result::BAD_PARAMS;
		}

		struct apps_disable_request_t req;

		msg.message_type = CONTEXT_HUB_UNLOAD_APP;
		msg.message_len = sizeof(req);
		msg.message = &req;
		req.app_name.id = appId;

		if(mContextHubModule->send_message(hubId, &msg) != 0) {
		return Result::TRANSACTION_FAILED;
		} else {
		mTransactionId = transactionId;
		mIsTransactionPending = true;
		return Result::OK;
		}
		}

		Return<Result> Contexthub::loadNanoApp(uint32_t hubId,
		const ::android::hardware::hidl_vec<uint8_t>& appBinary,
		uint32_t transactionId) {
		if (!isInitialized()) {
		return Result::NOT_INIT;
		}

		if (mIsTransactionPending) {
		return Result::TRANSACTION_PENDING;
		}

		hub_message_t hubMsg;

		if (setOsAppAsDestination(&hubMsg, hubId) == false) {
		return Result::BAD_PARAMS;
		}

		hubMsg.message_type = CONTEXT_HUB_LOAD_APP;
		hubMsg.message_len = appBinary.size();
		hubMsg.message = appBinary.data();

		if(mContextHubModule->send_message(hubId, &hubMsg) != 0) {
		return Result::TRANSACTION_FAILED;
		} else {
		mTransactionId = transactionId;
		mIsTransactionPending = true;
		return Result::OK;
		}
		}

		Return<Result> Contexthub::enableNanoApp(uint32_t hubId,
		uint64_t appId,
		uint32_t transactionId) {
		if (!isInitialized()) {
		return Result::NOT_INIT;
		}

		if (mIsTransactionPending) {
		return Result::TRANSACTION_PENDING;
		}

		hub_message_t msg;

		if (setOsAppAsDestination(&msg, hubId) == false) {
		return Result::BAD_PARAMS;
		}

		struct apps_enable_request_t req;

		msg.message_type = CONTEXT_HUB_APPS_ENABLE;
		msg.message_len = sizeof(req);
		req.app_name.id = appId;
		msg.message = &req;

		if(mContextHubModule->send_message(hubId, &msg) != 0) {
		return Result::TRANSACTION_FAILED;
		} else {
		mTransactionId = transactionId;
		mIsTransactionPending = true;
		return Result::OK;
		}
		}

		Return<Result> Contexthub::disableNanoApp(uint32_t hubId,
		uint64_t appId,
		uint32_t transactionId) {
		if (!isInitialized()) {
		return Result::NOT_INIT;
		}

		if (mIsTransactionPending) {
		return Result::TRANSACTION_PENDING;
		}

		hub_message_t msg;

		if (setOsAppAsDestination(&msg, hubId) == false) {
		return Result::BAD_PARAMS;
		}

		struct apps_disable_request_t req;

		msg.message_type = CONTEXT_HUB_APPS_DISABLE;
		msg.message_len = sizeof(req);
		req.app_name.id = appId;
		msg.message = &req;

		if(mContextHubModule->send_message(hubId, &msg) != 0) {
		return Result::TRANSACTION_FAILED;
		} else {
		mTransactionId = transactionId;
		mIsTransactionPending = true;
		return Result::OK;
		}
		}

		Return<Result> Contexthub::queryApps(uint32_t hubId) {
		if (!isInitialized()) {
		return Result::NOT_INIT;
		}

		hub_message_t msg;

		if (setOsAppAsDestination(&msg, hubId) == false) {
		ALOGW("Could not find hubId %" PRIu32, hubId);
		return Result::BAD_PARAMS;
		}

		query_apps_request_t payload;
		payload.app_name.id = ALL_APPS; // TODO : Pass this in as a parameter
		msg.message = &payload;
		msg.message_len = sizeof(payload);
		msg.message_type = CONTEXT_HUB_QUERY_APPS;

		if(mContextHubModule->send_message(hubId, &msg) != 0) {
		ALOGW("Query Apps sendMessage failed");
		return Result::TRANSACTION_FAILED;
		}

		return Result::OK;
		}

		bool Contexthub::isInitialized() {
		return (mInitCheck == OK && mContextHubModule != nullptr);
		}

		IContexthub HIDL_FETCH_IContexthub(const char halName) {
		ALOGI("%s Called for %s", __FUNCTION__, halName);
		Contexthub *contexthub = new Contexthub;

		if (!contexthub->isInitialized()) {
		delete contexthub;
		contexthub = nullptr;
		}

		return contexthub;
		}

		} // namespace implementation
		} // namespace V1_0
		} // namespace contexthub
		} // namespace hardware
		} // namespace android

contexthub/1.0/default/Contexthub.h

0 → 100644

+105 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2016 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.
		*/

		#ifndef ANDROID_HARDWARE_CONTEXTHUB_V1_0_CONTEXTHUB_H_
		#define ANDROID_HARDWARE_CONTEXTHUB_V1_0_CONTEXTHUB_H_

		#include <unordered_map>

		#include <android/hardware/contexthub/1.0/IContexthub.h>
		#include <hardware/context_hub.h>

		namespace android {
		namespace hardware {
		namespace contexthub {
		namespace V1_0 {
		namespace implementation {

		struct Contexthub : public ::android::hardware::contexthub::V1_0::IContexthub {
		Contexthub();

		Return<void> getHubs(getHubs_cb _hidl_cb) override;

		Return<Result> registerCallback(uint32_t hubId,
		const sp<IContexthubCallback> &cb) override;

		Return<Result> sendMessageToHub(uint32_t hubId,
		const ContextHubMsg &msg) override;

		Return<Result> loadNanoApp(uint32_t hubId,
		const ::android::hardware::hidl_vec<uint8_t>& appBinary,
		uint32_t transactionId) override;

		Return<Result> unloadNanoApp(uint32_t hubId,
		uint64_t appId,
		uint32_t transactionId) override;

		Return<Result> enableNanoApp(uint32_t hubId,
		uint64_t appId,
		uint32_t transactionId) override;

		Return<Result> disableNanoApp(uint32_t hubId,
		uint64_t appId,
		uint32_t transactionId) override;

		Return<Result> queryApps(uint32_t hubId) override;

		Return<Result> reboot(uint32_t hubId);

		bool isInitialized();

		private:

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

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

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

		bool isValidHubId(uint32_t hubId);

		sp<IContexthubCallback> getCallBackForHubId(uint32_t hubId);

		int handleOsMessage(sp<IContexthubCallback> cb,
		uint32_t msgType,
		const uint8_t *msg,
		int msgLen);

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

		bool setOsAppAsDestination(hub_message_t *msg, int hubId);

		DISALLOW_COPY_AND_ASSIGN(Contexthub);
		};

		extern "C" IContexthub HIDL_FETCH_IContexthub(const char name);

		} // namespace implementation
		} // namespace V1_0
		} // namespace contexthub
		} // namespace hardware
		} // namespace android

		#endif // ANDROID_HARDWARE_CONTEXTHUB_V1_0_CONTEXTHUB_H_

contexthub/1.0/default/android.hardware.contexthub@1.0-service.rc

0 → 100644

+4 −0

Original line number	Diff line number	Diff line
		service contexthub-hal-1-0 /system/bin/hw/android.hardware.contexthub@1.0-service
		class hal
		user system
		group system