Merge "Move inputflinger process to host directory" (857a35d2) · Commits · e / os / android_frameworks_native

include/input/IInputFlinger.h

+0 −2

Original line number	Diff line number	Diff line
		@@ -31,8 +31,6 @@ namespace android {
		class IInputFlinger : public IInterface {
		public:
		DECLARE_META_INTERFACE(InputFlinger);

		virtual status_t doSomething() = 0;
		};

services/inputflinger/Android.mk

+2 −17

Original line number	Diff line number	Diff line
		@@ -22,8 +22,7 @@ LOCAL_SRC_FILES:= \
		InputListener.cpp \
		InputManager.cpp \
		InputReader.cpp \
		InputWindow.cpp \
		InputFlinger.cpp
		InputWindow.cpp

		LOCAL_SHARED_LIBRARIES := \
		libbinder \
		@@ -47,18 +46,4 @@ LOCAL_MODULE := libinputflinger

		include $(BUILD_SHARED_LIBRARY)

		########################################################################
		# build input flinger executable
		include $(CLEAR_VARS)

		LOCAL_SRC_FILES:= \
		main.cpp

		LOCAL_SHARED_LIBRARIES := \
		libbinder \
		libinputflinger \
		libutils

		LOCAL_MODULE := inputflinger

		include $(BUILD_EXECUTABLE)
		include $(call all-makefiles-under,$(LOCAL_PATH))

services/inputflinger/host/Android.mk

0 → 100644

+62 −0

Original line number	Diff line number	Diff line
		# Copyright (C) 2015 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.

		LOCAL_PATH:= $(call my-dir)
		include $(CLEAR_VARS)

		LOCAL_CLANG := true

		LOCAL_SRC_FILES:= \
		InputFlinger.cpp \
		InputDriver.cpp \
		InputHost.cpp

		LOCAL_SHARED_LIBRARIES := \
		libbinder \
		libcrypto \
		libcutils \
		libinput \
		liblog \
		libutils \
		libhardware


		# TODO: Move inputflinger to its own process and mark it hidden
		#LOCAL_CFLAGS += -fvisibility=hidden

		LOCAL_CFLAGS += -Wno-unused-parameter

		LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)

		LOCAL_MODULE := libinputflingerhost

		include $(BUILD_SHARED_LIBRARY)

		########################################################################
		# build input flinger executable
		include $(CLEAR_VARS)

		LOCAL_CLANG := true

		LOCAL_SRC_FILES:= \
		main.cpp

		LOCAL_SHARED_LIBRARIES := \
		libbinder \
		libinputflingerhost \
		libutils

		LOCAL_MODULE := inputflinger

		include $(BUILD_EXECUTABLE)

services/inputflinger/host/InputDriver.cpp

0 → 100644

+112 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2015 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 <stdint.h>
		#include <sys/types.h>

		#define LOG_TAG "InputDriver"

		#define LOG_NDEBUG 0

		#include "InputDriver.h"
		#include "InputHost.h"

		#include <hardware/input.h>
		#include <utils/Log.h>
		#include <utils/String8.h>

		#define INDENT2 " "

		namespace android {

		static input_host_callbacks_t kCallbacks = {
		.create_device_identifier = create_device_identifier,
		.create_device_definition = create_device_definition,
		.create_input_report_definition = create_input_report_definition,
		.create_output_report_definition = create_output_report_definition,
		.input_device_definition_add_report = input_device_definition_add_report,
		.input_report_definition_add_collection = input_report_definition_add_collection,
		.input_report_definition_declare_usage_int = input_report_definition_declare_usage_int,
		.input_report_definition_declare_usages_bool = input_report_definition_declare_usages_bool,
		.register_device = register_device,
		.input_allocate_report = input_allocate_report,
		.report_event = report_event,
		};

		InputDriver::InputDriver(const char* name) : mName(String8(name)) {
		const hw_module_t* module;
		int err = input_open(&module, name);
		LOG_ALWAYS_FATAL_IF(err != 0, "Input module %s not found", name);
		mHal = reinterpret_cast<const input_module_t*>(module);
		}

		void InputDriver::init(InputHostInterface* host) {
		mHal->init(mHal, static_cast<input_host_t*>(host), kCallbacks);
		}

		void InputDriver::dump(String8& result) {
		result.appendFormat(INDENT2 "HAL Input Driver (%s)\n", mName.string());
		}


		// HAL wrapper functions

		input_device_identifier_t* create_device_identifier(input_host_t* host,
		const char* name, int32_t product_id, int32_t vendor_id,
		input_bus_t bus, const char* unique_id) {
		return nullptr;
		}

		input_device_definition_t* create_device_definition(input_host_t* host) {
		return nullptr;
		}

		input_report_definition_t* create_input_report_definition(input_host_t* host) {
		return nullptr;
		}

		input_report_definition_t* create_output_report_definition(input_host_t* host) {
		return nullptr;
		}

		void input_device_definition_add_report(input_host_t* host,
		input_device_definition_t* d, input_report_definition_t* r) { }

		void input_report_definition_add_collection(input_host_t* host,
		input_report_definition_t* report, input_collection_id_t id, int32_t arity) { }

		void input_report_definition_declare_usage_int(input_host_t* host,
		input_report_definition_t* report, input_collection_id_t id,
		input_usage_t usage, int32_t min, int32_t max, float resolution) { }

		void input_report_definition_declare_usages_bool(input_host_t* host,
		input_report_definition_t* report, input_collection_id_t id,
		input_usage_t* usage, size_t usage_count) { }


		input_device_handle_t* register_device(input_host_t* host,
		input_device_identifier_t* id, input_device_definition_t* d) {
		return nullptr;
		}

		input_report_t* input_allocate_report(input_host_t* host, input_report_definition_t* r) {
		return nullptr;
		}

		void report_event(input_host_t* host, input_device_handle_t* d, input_report_t* report) { }


		} // namespace android

services/inputflinger/host/InputDriver.h

0 → 100644

+98 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2015 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_INPUT_DRIVER_H
		#define ANDROID_INPUT_DRIVER_H

		#include <stdint.h>
		#include <sys/types.h>

		#include "InputHost.h"

		#include <hardware/input.h>
		#include <utils/RefBase.h>
		#include <utils/String8.h>

		namespace android {

		class InputHostInterface;

		class InputDriverInterface : public virtual RefBase {
		protected:
		InputDriverInterface() = default;
		virtual ~InputDriverInterface() = default;

		public:
		virtual void init(InputHostInterface* host) = 0;

		virtual void dump(String8& result) = 0;
		};

		class InputDriver : public InputDriverInterface {
		public:
		InputDriver(const char* name);
		virtual ~InputDriver() = default;

		virtual void init(InputHostInterface* host) override;

		virtual void dump(String8& result) override;

		private:
		String8 mName;
		const input_module_t* mHal;
		};


		extern "C" {

		input_device_identifier_t* create_device_identifier(input_host_t* host,
		const char* name, int32_t product_id, int32_t vendor_id,
		input_bus_t bus, const char* unique_id);

		input_device_definition_t* create_device_definition(input_host_t* host);

		input_report_definition_t* create_input_report_definition(input_host_t* host);

		input_report_definition_t* create_output_report_definition(input_host_t* host);

		void input_device_definition_add_report(input_host_t* host,
		input_device_definition_t* d, input_report_definition_t* r);

		void input_report_definition_add_collection(input_host_t* host,
		input_report_definition_t* report, input_collection_id_t id, int32_t arity);

		void input_report_definition_declare_usage_int(input_host_t* host,
		input_report_definition_t* report, input_collection_id_t id,
		input_usage_t usage, int32_t min, int32_t max, float resolution);

		void input_report_definition_declare_usages_bool(input_host_t* host,
		input_report_definition_t* report, input_collection_id_t id,
		input_usage_t* usage, size_t usage_count);


		input_device_handle_t* register_device(input_host_t* host,
		input_device_identifier_t* id, input_device_definition_t* d);

		void unregister_device(input_host_t* host, input_device_handle_t* handle);

		input_report_t* input_allocate_report(input_host_t* host, input_report_definition_t* r);

		void report_event(input_host_t* host, input_device_handle_t* d, input_report_t* report);

		}

		} // namespace android
		#endif // ANDROID_INPUT_DRIVER_H