开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 移动开发 -> 【android】从零开始学习安卓回放程序制作需要多少天？ -> 正文阅读

[移动开发]【android】从零开始学习安卓回放程序制作需要多少天？

更新时间：2022-05-19（第8天）（完结）
终于做完了。

序

之前没做过安卓的开发，现在突然要搞这个东西，很是头大。
写篇记录性质的博客，看看到底多少天能实现。
期限三个星期，只想弄完赶紧跑路了。

功能需求

在这里插入图片描述
提示可以使用HOOK实现，但是我连HOOK是什么都不知道。。。先从最基本的概念开始吧。

2022-05-19 20:57
终于做完了，效果差不多了，来写总结，放前面。踩坑学习日志就放后面了。

总结

请添加图片描述

项目代码：github: android_replay_test

目标程序比较简单，就不上 github了。

目标程序：比较简单，主要就是几个组件的编写。
测试程序：在不改动目标程序代码的情况下，使用HOOK技术，完成需求。

环境：夜神模拟器7.0.2.7
额外模块：Xposed，需要使用到ROOT权限。

思路：
（1）HOOK 目标程序 的组件，使得我们点击组件后，能够广播信息到 测试程序，并保存起来。
（2）同时，为 目标程序 添加 接收广播类。
（3）回放的时候，我们将保存的信息广播给 目标程序，由 接收广播类，“回放” 动作。

为什么要使用广播？
答：广播是跨程序通信方式之一。当前其他方式也可以，只是广播比较简单而已。
Xposed模块可以传递变量吗？
答：Xposed模块在hook时（package加载时），存在于不同的进程中。即使定义static属性，也无法跨进程传递。
使用createPackageContext获得目标程序 Context，再获得View不行吗？
答：确实不行，获得Context不是Activity，无法获得View。（目前没有找到方法）

还有，Xposed在某个类中，无法“添加”一个属性。只能获取、修改已定义的属性。

编写目标程序

简单的需求分析：（后面慢慢详解）
我们需要两个程序。
（1）目标程序（被测程序）。我称为target app
（2）测试程序。我称为hook app。

为什么要编写目标程序？
因为，我们需要了解 被测程序 的源码。否则，后面的hook比较麻烦。

目标程序比较简单，主要是两个文件。

activity_main.xml

主要给组件添加了点击涟漪效果。为了后面的测试点击效果更加清晰。~~（其实没有清晰多少）~~

如何添加安卓原生点击效果？

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
        xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        tools:context=".MainActivity">
    <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="center_horizontal"
            android:layout_marginTop="100sp"
            android:text="Test1"
            android:textSize="50sp"
    />
    <LinearLayout
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginTop="100sp"
            android:orientation="horizontal"
            android:layout_gravity="center_horizontal">
        <TextView android:layout_width="wrap_content"
                  android:layout_height="wrap_content"
                  android:text="请输入："
                  android:textSize="30sp"/>
        <EditText android:id="@+id/edit11"
                  android:layout_width="match_parent"
                  android:layout_height="wrap_content"
                  android:hint="内容"
                  android:textSize="30sp"
                  android:width="235sp"
                  android:inputType="text"
                  android:background="?android:attr/selectableItemBackground"/>
    </LinearLayout>

    <LinearLayout
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginTop="20sp"
            android:orientation="horizontal"
            android:layout_gravity="center_horizontal">
        <Button android:id="@+id/button11"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_marginLeft="10sp"
                android:text="确认"
                android:textSize="40sp"
                android:foreground="?android:attr/selectableItemBackgroundBorderless"/>
        <Button android:id="@+id/button12"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_marginLeft="50sp"
                android:text="清空"
                android:textSize="40sp"
                android:foreground="?android:attr/selectableItemBackgroundBorderless"/>
    </LinearLayout>
    <RadioGroup
            android:id="@+id/radiogroup11"
            android:layout_height="wrap_content"
            android:layout_width="wrap_content"
            android:orientation="horizontal"
            android:layout_gravity="center_horizontal"
            android:layout_marginTop="20sp">

        <RadioButton
                android:id="@+id/radiobutton11"
                android:layout_height="wrap_content"
                android:layout_width="match_parent"
                android:textSize="30sp"
                android:text="是" />

        <RadioButton
                android:id="@+id/radiobutton12"
                android:layout_height="wrap_content"
                android:layout_width="match_parent"
                android:textSize="30sp"
                android:text="否"
                android:layout_marginLeft="50sp"/>

    </RadioGroup>
    <TextView
            android:id="@+id/text11"
            android:layout_height="wrap_content"
            android:layout_width="wrap_content"
            android:layout_marginTop="30sp"
            android:layout_marginLeft="10sp"
            android:hint="显示内容"
            android:textSize="30sp"
            android:textColor="#B10909"
            android:layout_marginStart="10sp"
            android:background="?android:attr/selectableItemBackgroundBorderless"/>
</LinearLayout>

MainActivity.java

package com.example.myapplication;

import android.view.View;
import android.widget.*;
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {
    EditText et11;
    TextView tv11;
    Button bt11;
    Button bt12;

    private RadioGroup rg11;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 通过id获取对应组件
        et11 = (EditText) this.findViewById(R.id.edit11);
        tv11 = (TextView) this.findViewById(R.id.text11);

        bt11 = (Button) this.findViewById(R.id.button11);
        bt12 = (Button) this.findViewById(R.id.button12);

        rg11 = (RadioGroup) this.findViewById(R.id.radiogroup11);

        // 绑定事件
        bt11.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                String s1 = et11.getText().toString();
                String text = "1输入的内容为:"+s1;
                tv11.setText(text);
            }
        });
        bt12.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                et11.setText("");
                tv11.setText("");
                Toast.makeText(MainActivity.this,"1清空",Toast.LENGTH_SHORT).show();
            }
        });
        rg11.setOnCheckedChangeListener(new RadioGroup.OnCheckedChangeListener() {
            @Override
            public void onCheckedChanged(RadioGroup group, int checkedId) {
                RadioButton rb = (RadioButton) findViewById(checkedId);
                Toast.makeText(getApplicationContext(), rb.getText(),Toast.LENGTH_SHORT).show();
            }
        });

    }
}

功能描述：
（1）【输入框】输入内容
（2）点击【确定】后，显示在【显示内容】处。
（3）点击【清空】后，清空【输入框】、【显示内容】。
（4）【单选框】暂时无效果（只可以点击）。

【单选框】怎么写，就自己查一下吧。

展示如下：
在这里插入图片描述

测试程序编写

主要代码量和问题都在这个程序上。

测试程序界面代码

MainAcitivity主要就是3个button。文章之后还会添加新的逻辑。

// com.example.hookreplay.MainActivity 
public class MainActivity extends AppCompatActivity {
    Button bt1,bt2,bt3;
    TextView tv1;
    static String TARGET_APP_NAME = "com.example.myapplication";
    static String HOOP_APP_NAME = "com.example.hookreplay";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 获取对象
        bt1 = (Button) this.findViewById(R.id.button1);
        bt2 = (Button) this.findViewById(R.id.button2);
        bt3 = (Button) this.findViewById(R.id.button3);
        tv1 = (TextView) this.findViewById(R.id.tv1);

        // 注册事件
        bt1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                tv1.setText("开始录制");
                jumpApp();
            }
        });

        bt2.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                tv1.setText("清空录制");
            }
        });

        bt3.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                tv1.setText("回放");

                jumpApp();
                performScript();
            }
        });
    }
}

activity_main.xml主要就是3个button。

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
        xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        xmlns:app="http://schemas.android.com/apk/res-auto"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        tools:context=".MainActivity">

    <LinearLayout
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:orientation="vertical"
            android:gravity="center"
            app:layout_constraintTop_toTopOf="parent"
            app:layout_constraintStart_toStartOf="parent"
            android:layout_marginTop="24dp"
            android:layout_marginLeft="24dp"
            android:layout_marginStart="24dp">

        <Button
                android:id="@+id/button1"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="开始录制"
                android:textSize="20sp"
        />
        <Button
                android:id="@+id/button2"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="清空录制"
                android:textSize="20sp"/>
        <Button
                android:id="@+id/button3"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="回放"
                android:textSize="20sp"/>
    </LinearLayout>
    <TextView
            android:id="@+id/tv1"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Hello World!"
            android:textSize="30sp"
            app:layout_constraintBottom_toBottomOf="parent"
            app:layout_constraintLeft_toLeftOf="parent"
            app:layout_constraintRight_toRightOf="parent"
            app:layout_constraintTop_toTopOf="parent"/>

</androidx.constraintlayout.widget.ConstraintLayout>

功能描述：
（1）【开始录制】跳转到目标程序，开始录制操作。
（2）【清空录制】清空录制内容。
（3）【回放】跳转到 目标程序，回放，清空录制内容。

在这里插入图片描述
题目要求 “不能记录点击坐标”。所以我们采用HOOK的方法来实现。

我们需要使用到HOOK框架，Xposed。下面是一大堆参考资料：

Xposed学习

参考资料：
**github: XposedInstaller
**XposedInstaller — 安装Xposed
百度百科-钩子函数
 什么是钩子函数
 Android——Hook(钩子函数)动态注入代码
*Android Hook 技术
 Android 集成Xposed框架
*Android插件化原理解析——概要
 手把手教你Hook Android 点击事件
**抱歉，Xposed真的可以为所欲为——1.基础知识储备（上）
*抱歉，Xposed真的可以为所欲为——1.基础知识储备（下）
****Xposed的框架的使用 -----重点看这个
*初探Xposed，初学Xposed框架上手必看
*安卓Xposed简单实现

夜神模拟器下载安装

OK，因为Xposed是
（1）需要ROOT权限，并且
（2）需要安装在基于ARM架构的CPU上，
所以我们需要下载其他的安卓模拟器。

（1）IDEA自带的AVD，可以有基于x86的，也有基于ARM的。但是我试了下，基于ARM的运行太慢了。IDEA说，x86的比ARM的快10x。
但是我等了好久，始终没有启动成功基于ARM的AVD。
（2）Genymotion，很快，但是只支持x86。如需运行ARM程序，需要添加第三方插件—— github: Genymotion_ARM_Translation 。
但是，我试了很久，看上去Genymotion_ARM_Translation是安装成功了。但是ARM程序仍然无法安装。

（1）下载夜神模拟器。
（2）使用Xposed installer安装Xposed。
在这里插入图片描述
（3）下载后，直接拖入夜神模拟器，即开始安装。

测试程序Hook思路

有了Xposed，我们能怎么hook？我们能干嘛？
（1）AOP的思想。对一个方法进行 “增强”。
（2）反射的思想。反射调用类的方法，属性。

我们去hook目标程序的组件的事件，
（1）记录点击事件，
（2）将该信息发送（广播）给 测试程序。

编写HookTest类，实现IXposedHookLoadPackage接口，重写handleLoadPackage方法。

我们使用XposedHelpers.findAndHookMethodHook，被测程序的onCreate方法。通过反射获得所有组件。

有人可能会问：你这个所有组件都放在 被测程序的 MainActivity 属性 中，如果组件没有在MainActivity的属性中呢？
答：简单起见。。。如果不在的话，也可以通过其他方式获取，就更复杂了。

// com.example.hookreplay.HookTest.handleLoadPackage
// XposedHelpers.findAndHookMethod
XposedHelpers.findAndHookMethod(
TARGET_APP_NAME + ".MainActivity",
lpparam.classLoader, 
"onCreate", 
Bundle.class,
new XC_MethodHook() {
    @Override
    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
        Class<?> c = lpparam.classLoader.loadClass(TARGET_APP_NAME + ".MainActivity");
        
        Field field1 = c.getDeclaredField("et11");
        ...其他组件
        field1.setAccessible(true);
        ...其他组件
        EditText et11 = (EditText) field1.get(param.thisObject);
        ...其他组件
        ...其他代码
});

接下来hook修改组件的事件。

hook EditText

对于EditText。我们需要监听文本的变化。
查看源码可知TextChangedListener是可以添加多个，这里我们直接添加即可。

et11.addTextChangedListener(new TextWatcher() {
    @Override
    public void beforeTextChanged(CharSequence s, int start, int count, int after) {}
    @Override
    public void onTextChanged(CharSequence s, int start, int before, int count) {}
    @Override
    public void afterTextChanged(Editable s) {
        String ss = s.toString();
        XposedBridge.log("id: "+ et11.getId() + " text after change...");
        // action log
        makeActionLog(et11, ss);
    }
});

makeActionLog(et11, ss) 保存点击动作，并广播动作给 测试程序。后面还会提及。

hook click listener

对于需要响应点击的事件，
这里分两种情况，
（1）对于绑定了onClickListener的组件，我们反射获得其onClickListener对象，并添加新的功能后放回。

见：手把手教你Hook Android 点击事件

（2）对于未绑定onClickListener的组件，我们直接添加新的onClickListener即可。

使用view.hasOnClickListeners判断是否存在onClickListener。

// et11, tv11, bt11, bt12
ArrayList<View> onClickList = new ArrayList<>(Arrays.asList(et11, tv11, bt11, bt12));
for(View v: onClickList){
    if(v.hasOnClickListeners()){
        Method method = View.class.getDeclaredMethod("getListenerInfo");
        method.setAccessible(true);
        Object mListenerInfo = method.invoke(v);

        Class<?> listenerInfoClz = Class.forName("android.view.View$ListenerInfo");
        Field field = listenerInfoClz.getDeclaredField("mOnClickListener");
        final View.OnClickListener onClickListenerInstance = (View.OnClickListener) field.get(mListenerInfo);
        View.OnClickListener proxyOnClickListener = v1 -> {
            XposedBridge.log("id1: "+ v1.getId());
            onClickListenerInstance.onClick(v1);

            // action log
            makeActionLog(v1);
        };
        // 设置代理类
        field.set(mListenerInfo, proxyOnClickListener);
    }else{
        //如果没有click listener，添加 onClickListeners
        v.setOnClickListener(v1->{
            XposedBridge.log("id2: " + v1.getId());

            // action log
            makeActionLog(v1);
        });
    }
}

java的lambda表达式别忘了。

() -> {
}

最近写Scala有点多，感觉Java的
（1）分号有点多余。（不过，也减轻了编译器压力？）
（2）代码有点冗长。（在其他语言，明明可以写得很简单，比如说这个lambda表达式）

hook radioGroup

对于【单选框】，原理也是一样的，查看其源码后，可以发现比onClickListener简单。
这里hook它的OnCheckedChangeListener。其中参数checkedId就是【单选框】button的ID。

// rg11
Class<?> radioGroupClz = Class.forName("android.widget.RadioGroup");
Field field = radioGroupClz.getDeclaredField("mOnCheckedChangeListener");
field.setAccessible(true);
RadioGroup.OnCheckedChangeListener onCheckedChangeListenerInstance = (RadioGroup.OnCheckedChangeListener) field.get(rg11);
RadioGroup.OnCheckedChangeListener proxyOnCheckedChangeListener = (group, checkedId) -> {
    XposedBridge.log("id3: " + checkedId);
    onCheckedChangeListenerInstance.onCheckedChanged(group, checkedId);

    // action log
    View v = ((Activity)param.thisObject).findViewById(checkedId);
    makeActionLog(v);
};
field.set(rg11, proxyOnCheckedChangeListener);

最后，别忘了把代理类放回。
field.set(rg11, proxyOnCheckedChangeListener);

广播

到目前为止，我们把组件的事件都hook了，添加上了自己的逻辑。
自己的逻辑就是，将组件的点击事件，发送给测试程序。

我们定义一个 action 为一个字符串，使用空格分割，分别为

组件ID 组件名称 点击时间 [文本]

目前，[文本]仅在组件为EditText中存在。

为什么需要【点击时间】？
因为我们需要 模拟触摸事件。使用view.performClick是不会触发点击动画的。所以需要模拟MotionEvent。
参考：
android MotionEvent.obtain模拟事件，自动触发
 Android模拟点击的四种方式 ---------第一种。

public void makeActionLog(View v){
makeActionLog(v,"");
}
public void makeActionLog(View v, String extra){
    long curTime = System.currentTimeMillis();
    String action = "";
    if(v instanceof EditText){
        action = v.getId() + " " +  EDIT_TEXT + " " +  Long.toString(curTime) + " " +  extra;
    }else if(v instanceof Button){
        action = v.getId() + " " + BUTTON + " " + Long.toString(curTime);
    }else if(v instanceof TextView){
        action = v.getId() + " " + TEXT_VIEW + " " + Long.toString(curTime);
    }
    XposedBridge.log("make log...: " + action);

    // 发送广播
    Intent intent = new Intent(TARGET_APP_NAME);
    intent.putExtra("action", action);
    v.getContext().sendBroadcast(intent);
}

下面讲一下广播。
广播是安卓跨程序通信的一种方式。

参考：
Android跨进程通信广播（Broadcast）
Android 进程间通信IPC（二）—— Broadcast广播

广播是一种被动跨进程通讯的方式。当某个程序向系统发送广播时，其他的应用程序只能被动地接收广播数据。

在应用程序中发送广播比较简单。只需要调用sendBroadcast方法即可。该方法需要一个Intent对象。通过Intent对象可以发送需要广播的数据。

接收广播需要继承BroadcastReceiver类，并重写onReceive方法。
该接收广播类，还需要在Context中注册。

注册又分为，静态注册 和 动态注册。

这里，我们需要把接收的action保存起来。所以，选择动态注册的方式。

Save data in Broadcast receiver

我们新建一个类MyBroadcastReceiver。将得到的action保存在，静态的actionList中。

实现单例只是为了方便操作。。不是必须的。

public class MyBroadcastReceiver extends BroadcastReceiver {
    public static final String SENDER_NAME = "com.example.myapplication";
    public static ArrayList<String> actionList = new ArrayList<>();
	// 单例
    private static MyBroadcastReceiver myBroadcastReceiver = null;
    public static MyBroadcastReceiver getInstance(){
        if(myBroadcastReceiver == null){
            myBroadcastReceiver = new MyBroadcastReceiver();
        }
        return myBroadcastReceiver;
    }
    @Override
    public void onReceive(Context context, Intent intent) {
        if(!SENDER_NAME.equals(intent.getAction())){
            return;
        }
        Bundle bundle = intent.getExtras();
        if(bundle == null){
            return;
        }
        String action = bundle.getString("action");
        System.out.println("MyReceiver: " + action);
        actionList.add(action);
    }
}

之后，在测试程序的onCreate方法注册该接收广播类。

// com.example.hookreplay.MainActivity
// 动态注册广播接收器
BroadcastReceiver myReceiver = MyBroadcastReceiver.getInstance();
IntentFilter intentFilter = new IntentFilter();
intentFilter.addAction(MyBroadcastReceiver.SENDER_NAME);
registerReceiver(myReceiver, intentFilter);

注意，onCreate中只会注册一次。在其他方法，如onResume，可能多次注册，广播将接收多次。

到目前为止，
我们点击 目标程序 的组件之后，会向 测试程序 发送广播。
测试程序接收广播，并存储起来。

应用跳转

功能需求：在我们点击【开始录制】后，我们需要跳转到 目标程序。

How to switch between Android apps programmatically
**Android 必知必会 - 使用 Intent 打开第三方应用及验证可用性

使用startActivity方法。
（1）使用ComponentName指定，跳转程序的入口。
（2）Intent.FLAG_ACTIVITY_NEW_TASK，指明该Flag之后，会新启一个“页面”。

// com.example.hookreplay.MainActivity
public void jumpApp(){
    String packageName = HookTest.TARGET_APP_NAME;
    String activityName = HookTest.TARGET_APP_NAME +".MainActivity";
    Intent intent = new Intent();
    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    ComponentName componentName = new ComponentName(packageName, activityName);
    intent.setComponent(componentName);
    startActivity(intent);
}

回放功能的实现

我们将MyBroadcastReceiver接收广播类中，保存的actionList广播给 目标程序，又目标程序执行记录的动作。

// com.example.hookreplay.MainActivity
public void performScript(){
    // 广播 在该app中存储的动作列表
    Intent intent = new Intent(HOOP_APP_NAME);
    intent.putExtra("actionArray", MyBroadcastReceiver.actionList.toArray(new String[0]));
    this.sendBroadcast(intent);
}

有同学可能会问：接收广播类不是需要注册吗？
是的，所以我们需要在 目标程序 中，动态注册一个广播接收类。

接着之前的代码，hook目标程序的onCreate方法。

我们解析action，并按照点击的时间进行延迟执行。使用handler.postDelayed。

long curTime = Long.parseLong(e[2]) + ACTION_DELAY;  // 所有动作延后ACTION_DELAY

设第一个action的时间为基准（为0），之后的动作的时间都减去第一的动作的时间。同时，我们将所有动作延迟ACTION_DELAY。~~不延迟也行~~

// com.example.hookreplay.HookTest
// handleLoadPackage.XposedHelpers.findAndHookMethod
// add a broadcast receiver to target app
class TargetReceiver extends BroadcastReceiver{
     public static final String SENDER_NAME = "com.example.hookreplay";
     public static final long ACTION_DELAY = 1000;
     private void performTouch(View v){
         long downTime = SystemClock.uptimeMillis();
         MotionEvent downEvent = MotionEvent.obtain(downTime, downTime+200, MotionEvent.ACTION_DOWN, 0, 0 , 0);
         downTime += 600;
         MotionEvent upEvent = MotionEvent.obtain(downTime, downTime+100, MotionEvent.ACTION_UP, 0, 0 , 0);
         v.onTouchEvent(downEvent);
         v.onTouchEvent(upEvent);
         upEvent.recycle();
         downEvent.recycle();
     }
     @Override
     public void onReceive(Context context, Intent intent) {
         if(!SENDER_NAME.equals(intent.getAction())){
             return;
         }
         Bundle bundle = intent.getExtras();
         if(bundle == null){
             return;
         }
         String[] actionArray = bundle.getStringArray("actionArray");

         if(actionArray.length == 0){
             Toast.makeText((Activity)param.thisObject,"请先录制",Toast.LENGTH_SHORT).show();
             return;
         }
         // 遍历action列表，每隔ACTION_DELAY执行一次动作
         Toast.makeText((Activity)param.thisObject,"开始播放",Toast.LENGTH_SHORT).show();
         final Handler handler = new Handler(Looper.getMainLooper());
         long startTime = Long.parseLong(actionArray[0].split(" ")[2]);
         long endTime = Long.parseLong(actionArray[actionArray.length-1].split(" ")[2]);
         for(String action: actionArray) {
             System.out.println("perform script:  "+ action);
             String[] e = action.split(" ");
             if (e.length == 0) {
                 continue;
             }
             int id = Integer.parseInt(e[0]);
             String compName = e[1];
             long curTime = Long.parseLong(e[2]) + ACTION_DELAY;  // 所有动作延后ACTION_DELAY

             View v = ((Activity)context).findViewById(id);
             handler.postDelayed(() -> {
                 System.out.println("execute action: " + action);
                 switch (compName) {
                     case HookTest.BUTTON:
                         performTouch(v);
                         break;
                     case HookTest.TEXT_VIEW:
                         performTouch(v);
                         break;
                     case HookTest.EDIT_TEXT:
                         if(e.length >= 4){
                             String text = e[3];
                             ((EditText) v).setText(text);
                         }else{
                             performTouch(v);
                         }
                         break;
                     default:
                         break;
                 }
             }, (curTime - startTime));
         }

         handler.postDelayed(()->{
             Toast.makeText((Activity)param.thisObject,"回放结束",Toast.LENGTH_SHORT).show();
         }, (endTime-startTime) + ACTION_DELAY*2);
     }
 };

为什么不用view.performClick？
参考：
android MotionEvent.obtain模拟事件，自动触发
 Android模拟点击的四种方式 ---------第一种。

因为我们需要 模拟触摸事件。使用view.performClick是不会触发点击动画的。所以需要模拟MotionEvent。
*
需要注意的是，MotionEvent的时间需要是SystemClock.uptimeMillis()中获得的。

如何实现【延迟】执行代码？
How to delay a loop in android without using thread.sleep?
[solve] How to delay a loop in android without using thread.sleep?

最后，别忘记注册了。

// 注册receiver
BroadcastReceiver bcr = new TargetReceiver();
IntentFilter intentFilter = new IntentFilter();
intentFilter.addAction(TargetReceiver.SENDER_NAME);
((Activity)param.thisObject).registerReceiver(bcr,intentFilter);

OK，至此，我们已经完成所有逻辑的编写。

下面是这几天的学习踩坑。仅作为记录，思路不完成正确。

2022-05-（12-13）

HOOK是什么？

参考：
百度百科
 什么是钩子函数

钩子函数是Windows消息处理机制的一部分，通过设置“钩子”，应用程序可以在系统级对所有消息、事件进行过滤，访问在正常情况下无法访问的消息。钩子的本质是一段用以处理系统消息的程序，通过系统调用，把它挂入系统。

钩子函数：钩子函数是在一个事件触发的时候，在系统级捕获到了他，然后做一些操作。一段用以处理系统消息的程序。“钩子”就是在某个阶段给你一个做某些处理的机会。

钩子函数： 1、是个函数，在系统消息触发时被系统调用 2、不是用户自己触发的

钩子函数的名称是确定的，当系统消息触发，自动会调用。例如react的componentWillUpdate函数，用户只需要编写componentWillUpdate的函数体，当组件状态改变要更新时，系统就会调用componentWillUpdate。

简单地说，钩子函数是处理系统消息的机制。
~~但是上面说的都是桌面window的钩子函数吧，有没有安卓的？~~

一段简单的HOOK的例子

Android——Hook(钩子函数)动态注入代码

总结一下，HOOK对关键组件进行代理、替换，并增加新的功能，实现我们的目的。
HOOK用到的技术思想：AOP、代理、反射。

IDEA安卓开发

如何用idea进行安卓开发

遇到的问题：
（1）bulid工程失败？
对build.gradle添加

dependencies {
    implementation 'androidx.appcompat:appcompat:1.2.0'
    implementation 'com.google.android.material:material:1.3.0'
    implementation 'androidx.constraintlayout:constraintlayout:2.0.4'
    testImplementation 'junit:junit:4.+'
    androidTestImplementation 'androidx.test.ext:junit:1.1.2'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'
    androidTestImplementation "androidx.test.ext:junit:1.1.3"
    androidTestImplementation "androidx.test:core:1.4.0"
    androidTestImplementation "androidx.fragment:fragment-testing:1.4.1"
}

同时修改android.compileSdk=31，android.defaultConfig.targetSdk=31

目标程序编写

因为功能简单（其实是不懂）所以就简单的写一个程序。

参考：
通过实例学Android应用开发01 - 根据此改写。
Android应用程序结构及运行原理

安卓模拟器genymotion

各位应该注意到了，idea自带的AVD模拟器很卡。为了进一步增加开发体验，我决定下一个安卓模拟器genymotion。

参考：
Genymotion配置及使用教程（最新最完整版附各部分下载地址）
Android模拟器Genymotion使用详解
 genymotion官网

genymotion官网下载，注意选择下载with virtual box。

genymotion下载完成后，点击右上角的+，下载安装安卓镜像。
在这里插入图片描述

idea打包apk

将之前写好的目标程序打包成apk，拖入模拟器中。

IntelliJ IDEA 如何导出安卓（Android）apk文件详细教程

将得到的apk文件，直接拖入genymotion模拟器中即可自动安装。
在这里插入图片描述
向上滑，打开应用程序目录。

在这里插入图片描述

不得不说，卡顿感明显少了许多。接下来是回放程序的制作。应该就是难点了。

genymotion不支持ARM？

解决Genymotion不兼容arm框架的问题

拖拽Genymotion-ARM-Translation.zip无法直接安装？

github: Genymotion_ARM_Translation

找到adb工具，genymotion应该自带，比如说我的位置在E:\genymotion\tools。

  1. adb shell
  2. cd /sdcard/Download/
  3. sh /system/bin/flash-archive.sh /sdcard/Download/Genymotion-ARM-Translation.zip
  4. adb reboot

执行后，会出现错误。一看，上传上去的文件名字不对。
自己上去修改。修改名字之后，再进行上面的命令。

cd /sdcard/Download/
mv ??? Genymotion-ARM-Translation.zip

2022-05-14

之前提到了HOOK。为什么要用到它，从功能是实现上来讲，我们需要做的是两部分功能。
（1）使用HOOK监听用户操作，并将操作记录存储起来。
（2）读取操作记录，实现用户操作。
（3）HOOK程序，和目标程序应该是两个程序。

操作记录的存储可以使用文件，不过这样会更复杂一点。
（1）大概了解了，是使用HOOK实现。
（2）到底要怎么实现呢？
（3）两个程序是需要考虑进程之间的通信？

HOOK框架？

*Android Hook 技术
 Android 集成Xposed框架

好像目前HOOK框架，比如说Xposed这种，都需要ROOT权限，有没有更简单的方法？？？

VirtualXposed
epic 可以实现任意方法 Hook，但只能对同一个 uid 的进程生效，VA 可以运行任意 APP，使其与自己使用同一个 uid。结合上面两种技术，有没有想到什么？
是的，这就是 VirtualXposed，结合了 epic 与 VA 的终极框架。无需 root，类 Xposed 的 API，可以说是一个相当完善的方案了。