android模拟按键问题总结[使用IWindowManager.injectKeyEvent方法]

最新推荐文章于 2023-05-04 22:32:07 发布

mergerly

最新推荐文章于 2023-05-04 22:32:07 发布

阅读量2.2k

点赞数

分类专栏： android

android 专栏收录该内容

31 篇文章 1 订阅

订阅专栏

目的：在非源码环境下调用隐藏api实现模拟按键的功能。

首先需要下载在android4.0源码环境下编译出来的classes.jar，或者如果你有条件那么可以直接在源码环境下编译（此方法该文不讨论）。

因为我在ubuntu下没能下载完源代码，所以直接采用classes.jar导入到eclipse的方法。

1. classes.jar可以去我的资源中下载classes.jar

2. 有了classes.jar之后，在eclipse界面，拖拉jar进项目的libs目录，使用用户库的方式添加jar

可以参考Android中使用隐藏API(大量图解)

3. 导入之后隐藏的类和方法就能使用了，但是在编译时eclipse有可能会报错：Unable to execute dex: Java heap space

解决方法是修改eclipse.ini：参考博文

4. 更改了之后又可能会遇见eclipse报错： Unable to execute dex: Cannot merge new index 67208 into a non-jumbo instruction!

解决方法：project->clean；清理一下之后重新编译就好了

5. injectKeyEvent的具体用法可以参考：博文

别忘了在项目的manifest文件中添加：sharedUserId和INJECT_EVENTS权限

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.xxxx.packagename"
    android:sharedUserId="android.uid.system"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.WAKE_LOCK" />
    <uses-permission android:name="android.permission.INJECT_EVENTS" />

添加之后INJECT_EVENTS会报错，此时只要在菜单栏是点project->clean就可以去掉错误然后编译

6. 编译之后直接安装会安装失败，因为没有该apk没有系统权限

解决方法是：下载Signapk工具，可以去我的资源中下载

用法是在命令行下使用命令：java -jar SignApk.jar platform.x509.pem platform.pk8 app_unsigned.apk app_signed.apk

至此，终于在非源码环境下待用了隐藏api实现了模拟按键的功能，辛苦啊。

有任何疑问都可以留言或者发邮件给我263113565@qq.com，或者直接加这个QQ号一起讨论。

=============================分割线=====================================

Q:因为使用原生系统的签名，所以经常有朋友来问我厂商定制的ROM怎么办

A:我后来想到可以使用jni的方法跳过，下面是我找的一些资料，仅仅提供给大家一个更广的思路，这个方法我并没有实现，仅供参考，相信会是个更好的办法

参考一参考二


#include <stdlib.h>
#include <android/log.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/input.h>
#include <dirent.h>
#include <errno.h>
//#include "nativemethod.h"

#define LOGI(...)  __android_log_print(ANDROID_LOG_INFO, "EventEmulate", __VA_ARGS__)
#define LOGE(...)  __android_log_print(ANDROID_LOG_ERROR, "EventEmulate", __VA_ARGS__)

#define DEV_DIR "/dev/input"
#define sizeof_bit_array(bits)  ((bits + 7) / 8)
#define test_bit(bit, array)    (array[bit/8] & (1<<(bit%8)))
#define ABS_MT_POSITION_X 0x35
#define ABS_MT_POSITION_Y 0x36

struct EVENT_INFO
{
	int fd_touch;
	int fd_key;
	int screen_width;
	int screen_height;
	int abs_x_min;
	int abs_x_max;
	int abs_y_min;
	int abs_y_max;
};

int scan_dir(const char *dirname);
int open_dev(const char *deviceName);
int write_event(int fd, int type, int code, int value);
void calculateXY(float x, float y, int *abs_x, int *abs_y);
int containsNonZeroByte(const uint8_t* array, uint32_t startIndex, uint32_t endIndex);

struct EVENT_INFO ei;
int initEVT = 0;

int EVT_open(struct NATIVE_INFO *info)
{
	struct input_absinfo absinfo;

	if(initEVT)
		return 0;

	if(info == NULL)
	{
		LOGE("info null point.");
		goto fail;
	}

	if(info->FB_width == 0 || info->FB_height == 0)
	{
		LOGE("error width %d and height %d.", info->FB_width, info->FB_height);
		goto fail;
	}

	memset(&ei, 0, sizeof(ei));
	ei.screen_width = info->FB_width;
	ei.screen_height = info->FB_height;

	scan_dir(DEV_DIR);

	if(ioctl(ei.fd_touch, EVIOCGABS(ABS_X), &absinfo)) {
		LOGI("Error reading absolute controller ABS_X[%d]: %s", errno, strerror(errno));
		return;
	}
	ei.abs_x_min = absinfo.minimum;
	ei.abs_x_max = absinfo.maximum;

	if(ioctl(ei.fd_touch, EVIOCGABS(ABS_Y), &absinfo)) {
		LOGI("Error reading absolute controller ABS_Y[%d]: %s", errno, strerror(errno));
		return;
	}
	ei.abs_y_min = absinfo.minimum;
	ei.abs_y_max = absinfo.maximum;

	initEVT = 1;
	return 0;

fail:
	EVT_close();
	return -1;
}

int EVT_close()
{
	if(ei.fd_key > 0)
		close(ei.fd_key);
	if(ei.fd_touch > 0)
		close(ei.fd_touch);

	initEVT = 0;
	return 0;
}

int EVT_touch(int action, float x, float y)
{
	int abs_x, abs_y;

	if(initEVT == 0)
	{
		LOGE("event not inital");
		return -1;
	}

	switch(action)
	{
	case ACTION_DOWN:
		calculateXY(x, y, &abs_x, &abs_y);
		write_event(ei.fd_touch, 3, 0, abs_x);
		write_event(ei.fd_touch, 3, 1, abs_y);
		write_event(ei.fd_touch, 1, 330, 1);
		write_event(ei.fd_touch, 0, 0, 0);
		break;
	case ACTION_UP:
		write_event(ei.fd_touch, 1, 330, 0);
		write_event(ei.fd_touch, 0, 0, 0);
		break;
	case ACTION_MOVE:
		calculateXY(x, y, &abs_x, &abs_y);
		write_event(ei.fd_touch, 3, 0, abs_x);
		write_event(ei.fd_touch, 3, 1, abs_y);
		write_event(ei.fd_touch, 0, 0, 0);
		break;
	}
	return 0;
}

int EVT_key(int action, int key)
{
	if(initEVT == 0)
	{
		LOGE("event not inital");
		return -1;
	}

	switch(action)
	{
	case ACTION_DOWN:
		write_event(ei.fd_key, 1, key, 1);
		break;
	case ACTION_UP:
		write_event(ei.fd_key, 1, key, 0);
		break;
	}
	return 0;
}


int scan_dir(const char *dirname)
{
	char devname[PATH_MAX];
	char *filename;
	DIR *dir;
	struct dirent *de;
	dir = opendir(dirname);
	if(dir == NULL)
		return -1;
	strcpy(devname, dirname);
	filename = devname + strlen(devname);
	*filename++ = '/';
	while((de = readdir(dir))) {
		if(de->d_name[0] == '.' &&
		   (de->d_name[1] == '\0' ||
			(de->d_name[1] == '.' && de->d_name[2] == '\0')))
			continue;
		strcpy(filename, de->d_name);
		open_dev(devname);
	}
	closedir(dir);
	return 0;
}

int open_dev(const char *deviceName)
{
	int fd;
	int version;
	uint8_t key_bitmask[sizeof_bit_array(KEY_MAX + 1)];
	uint8_t abs_bitmask[sizeof_bit_array(ABS_MAX + 1)];

	fd = open(deviceName, O_RDWR);
	if(fd < 0) {
		LOGI("could not open device[%d]: %s", errno, strerror(errno));
		return -1;
	}

	if(ioctl(fd, EVIOCGVERSION, &version)) {
		return -1;
	}

	memset(key_bitmask, 0, sizeof(key_bitmask));
	if (ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(key_bitmask)), key_bitmask) >= 0) {
		if (containsNonZeroByte(key_bitmask, 0, sizeof_bit_array(BTN_MISC))
				|| containsNonZeroByte(key_bitmask, sizeof_bit_array(BTN_GAMEPAD),
						sizeof_bit_array(BTN_DIGI))
				|| containsNonZeroByte(key_bitmask, sizeof_bit_array(KEY_OK),
						sizeof_bit_array(KEY_MAX + 1))) {
			ei.fd_key = fd;
			LOGI("get key input device: %s", deviceName);
		}
	}

	memset(abs_bitmask, 0, sizeof(abs_bitmask));
	if (ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(abs_bitmask)), abs_bitmask) >= 0) {
		// Is this a new modern multi-touch driver?
		if (test_bit(ABS_MT_POSITION_X, abs_bitmask)
				&& test_bit(ABS_MT_POSITION_Y, abs_bitmask)) {
			ei.fd_touch = fd;
			LOGI("get multi-touch input device: %s", deviceName);

		// Is this an old style single-touch driver?
		} else if (test_bit(BTN_TOUCH, key_bitmask)
				&& test_bit(ABS_X, abs_bitmask) && test_bit(ABS_Y, abs_bitmask)) {
			ei.fd_touch = fd;
			LOGI("get single-touch input device: %s", deviceName);
		}
	}
}

int write_event(int fd, int type, int code, int value)
{
	struct input_event event;

	memset(&event, 0, sizeof(event));
	event.type = type;
	event.code = code;
	event.value = value;
	if(write(fd, &event, sizeof(event)) < sizeof(event)) {
		LOGI("write event failed[%d]: %s", errno, strerror(errno));
		return -1;
	}
	return 0;
}

void calculateXY(float x, float y, int *abs_x, int *abs_y)
{
	*abs_x = ei.abs_x_min +
			(int)((x * (float)(ei.abs_x_max - ei.abs_x_min)) / ei.screen_width + 0.5);
	*abs_y = ei.abs_y_min +
			(int)((y * (float)(ei.abs_y_max - ei.abs_y_min)) / ei.screen_height + 0.5);
}

int containsNonZeroByte(const uint8_t* array, uint32_t startIndex, uint32_t endIndex)
{
    const uint8_t* end = array + endIndex;
    array += startIndex;
    while (array != end) {
        if (*(array++) != 0) {
            return 1;
        }
    }
    return 0;
}