Android外挂开发探索

/   今日科技快讯   /

近日，爱奇艺和抖音集团宣布达成合作，将围绕长视频内容的二次创作与推广等方面展开探索。依据合作，爱奇艺将向抖音集团授权其内容资产中拥有信息网络传播权及转授权的长视频内容，用于短视频创作。双方对解说、混剪、拆条等短视频二创形态做了具体约定，将共同推动长视频内容知识产权的规范使用。

/   作者简介   /

本篇文章来自wkxjc的投稿，文章主要分享了如何利用Android中辅助功能实现一个简单的外挂，相信会对大家有所帮助！同时也感谢作者贡献的精彩文章。

wkxjc的博客地址：

https://juejin.cn/user/1116759545357182

/   前言   /

在 Android 中，有个非常强大的功能，那就是辅助功能。

辅助功能本是用于服务残障人士的。比如对于视障人士来说，辅助功能可以帮助他们读出屏幕上的文字或图片（阅读图片时会播放其 ContentDescription 属性）。

除此之外，辅助功能还可以模拟点击，模拟手势等等，对于我这样的懒癌人士，辅助功能可以帮助我做一些重复、机械的点击操作。

模拟点击功能非常强大，它不局限于本应用内，它就像模拟出了一只手，可以在任何时刻帮助我们点击屏幕的任何位置。

比如我们可以开启一个循环，不断地点击某个位置，这在某些场景中可以解放我们的手指细胞。还可以实现类似这样的点击序列：等待 3s 点击位置 A，然后等待 2s 点击两次位置 B，等待 500ms 再点击 5 次位置 C 等等。以此完成一些日常的签到打卡等功能。

缺点是它不知道当前页面显示的内容是什么，这一点可以通过截图 + 图片识别来解决。

所以想要实现一个简单的外挂，可以分三步走：

• 模拟点击

• 应用外截屏

• 图片识别

接下来我们就来一步步地攻克这三个技术点。

/   模拟点击   /

新建 MyAccessibilityService 类

首先，新建一个 MyAccessibilityService 类，继承自系统的 AccessibilityService 类：

class MyAccessibilityService : AccessibilityService() {
    override fun onAccessibilityEvent(accessibilityEvent: AccessibilityEvent?) {
    }
 
    override fun onInterrupt() {
    }
}

继承 AccessibilityService 后，需要实现两个方法 onAccessibilityEvent 和 onInterrupt。

onAccessibilityEvent 方法中，带有一个参数 AccessibilityEvent，当界面发生改变时，这个方法就会被调用，界面改变的具体信息就会包含在这个参数中。onInterrupt 方法辅助服务被中断了。

我们暂时先在这两个方法中简单地打印一行日志，待会再在其中添加具体的功能。

注册 Service

写好 MyAccessibilityService 类后，需要在 AndroidManifest 中注册。注册辅助服务和注册一般的服务略有区别：

<service
    android:name=".MyAccessibilityService"
    android:description="@string/description_in_manifest"
    android:exported="true"
    android:label="@string/label_in_manifest"
    android:permission="android.permission.BIND_ACCESSIBILITY_SERVICE">
    <intent-filter>
        <action android:name="android.accessibilityservice.AccessibilityService" />
    </intent-filter>
    <meta-data
        android:name="android.accessibilityservice"
        android:resource="@xml/accessibility_config" />

• 首先是需要声明一个 label，这个 label 是在系统的辅助功能设置中显示的名字

• description 属性可以不写，指的是在辅助功能设置中显示的该辅助功能的描述

• permission 属性必须写，表示这个服务需要绑定 AccssibilityService

• 在这个 service 中，有一个 inter-filter，这个也是必须写的，不妨记作固定格式

• 还有一个 meta-data，其中的 resource 属性指向一个 xml 文件，这个文件中可以配置允许这个辅助功能做哪些事

xml 文件如下：

<?xml version="1.0" encoding="utf-8"?>
<accessibility-service xmlns:android="http://schemas.android.com/apk/res/android"
    android:accessibilityEventTypes="typeAllMask"
    android:accessibilityFeedbackType="feedbackGeneric"
    android:canPerformGestures="true"
    android:canRetrieveWindowContent="true"
    android:description="@string/description_in_xml"
    android:notificationTimeout="100" />

AndroidManifest 和 xml 中，用到的字符串资源文件如下：

<string name="label_in_manifest">Label in manifest</string>
<string name="description_in_manifest">Description in manifest</string>
<string name="description_in_xml">Description in xml</string>

这些都设置好之后，这个 Service 就注册成功了。

现在就可以运行一下看看效果了。

开启辅助服务

此时运行程序，会发现没有任何 onAccessibilityEvent 事件打出。这是因为辅助功能是一项比较危险的功能，默认是关闭的。需要到系统设置中手动打开才可以使用。

通过图中的三个步骤，确保 Use Label in manifest 的开关是打开的，我们的辅助功能就被正式启用了。从图中我们也可以看出注册 service 时写的字符串各自的使用场景。在程序中，也可以通过代码到达辅助功能设置页面，代码如下：

object AccessibilitySettingUtils {
    fun jumpToAccessibilitySetting(context: Context) {
        val intent = Intent(Settings.ACTION_ACCESSIBILITY_SETTINGS)
        context.startActivity(intent)
    }
}

开启辅助功能后，点击桌面就会在 Log 控制台收到以下消息：

D/~~~: accessibilityEvent: EventType: TYPE_WINDOW_CONTENT_CHANGED; EventTime: 101990739; PackageName: com.google.android.apps.nexuslauncher; MovementGranularity: 0; Action: 0; ContentChangeTypes: [CONTENT_CHANGE_TYPE_SUBTREE]; WindowChangeTypes: [] [ ClassName: android.widget.FrameLayout; Text: []; ContentDescription: null; ItemCount: -1; CurrentItemIndex: -1; Enabled: true; Password: false; Checked: false; FullScreen: false; Scrollable: false; BeforeText: null; FromIndex: -1; ToIndex: -1; ScrollX: 0; ScrollY: 0; MaxScrollX: 0; MaxScrollY: 0; ScrollDeltaX: -1; ScrollDeltaY: -1; AddedCount: -1; RemovedCount: -1; ParcelableData: null ]; recordCount: 0

这表示我们接收到了一个 accessibilityEvent 消息，他的类型是 TYPE_WINDOW_CONTENT_CHANGED，意思是窗口内容发生了变化，PackageName 中表示这个变化的内容所在的包名。

说明我们的辅助功能已经开始工作了。

点击对应坐标

想要查看屏幕上的坐标，可以在开发人员选项中打开显示坐标的设置：

打开这个设置后，每次点击屏幕，都会在顶部显示当前点击的位置坐标。点击对应坐标的代码如下：

object ClickUtils {
    fun click(accessibilityService: AccessibilityService, x: Float, y: Float) {
        Log.d("~~~", "click: ($x, $y)")
        val builder = GestureDescription.Builder()
        val path = Path()
        path.moveTo(x, y)
        path.lineTo(x, y)
        builder.addStroke(GestureDescription.StrokeDescription(path, 0, 1))
        val gesture = builder.build()
        accessibilityService.dispatchGesture(gesture, object : AccessibilityService.GestureResultCallback() {
            override fun onCancelled(gestureDescription: GestureDescription) {
                super.onCancelled(gestureDescription)
            }
 
            override fun onCompleted(gestureDescription: GestureDescription) {
                super.onCompleted(gestureDescription)
            }
        }, null)
    }
}

在这个工具类中，我们将 AccessibilityService 和坐标传入。

通过 GestureDescription 的 Builder 构建一个手势，通过 Builder 的 addStoke 方法传入一条 path，这条 path 我们设置为从 (x, y) 坐标移动到 (x, y) 坐标。StrokeDescription 的后两个参数表示 startTime 和 duration，分别表示手势的开始时间以及持续时间，以毫秒为单位。我将其设置为 0 和 1，也就是 1ms 以内完成从 (x, y) 坐标移动到 (x, y) 坐标。

这样就模拟出了一个点击事件。通过 accessibilityService 的 dispatchGesture 方法触发这个手势，这个方法接收两个参数，第一个参数是手势的具体配置，第二个参数表示手势执行的结果，包含执行完成和取消两种结果。

测试

我们不妨写个简单的页面来测试一下。先写一个页面，包含两个按钮：

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">
 
    <Button
        android:id="@+id/btn_jump_to_settings"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Jump to Settings"
        android:textAllCaps="false"
        app:layout_constraintTop_toTopOf="parent" />
 
    <Button
        android:id="@+id/btn_test"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Test"
        app:layout_constraintTop_toBottomOf="@id/btn_jump_to_settings" />
 
</androidx.constraintlayout.widget.ConstraintLayout>

这个页面的效果图：

在 app/build.gradle 中，开启 ViewBinding，目的是使用这些按钮更方便：

buildFeatures {
    viewBinding true
}

在 MainActivity 中，设置按钮的点击事件：

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)
        binding.btnJumpToSettings.setOnClickListener {
            AccessibilitySettingUtils.jumpToAccessibilitySetting(this)
        }
        binding.btnTest.setOnClickListener {
            Toast.makeText(this, "I'm clicked", Toast.LENGTH_SHORT).show()
        }
    }
}

• 第一个按钮 btnJumpToSettings 的作用是点击跳转到辅助服务设置页

• 第二个按钮用来做测试，点击时会弹出 Toast："I'm clicked"。待会我们就模拟点击这个按钮。

查看一下第二个按钮的坐标位置：

从图中可以看出，第三个按钮的坐标大约是 (622,406)。在 MyAccessibilityService 的 onServiceConnected 方法中，模拟点击此坐标：

override fun onServiceConnected() {
    super.onServiceConnected()
    Log.d("~~~", "onServiceConnected")
    thread {
        Thread.sleep(5000)
        ClickUtils.click(this, 622f, 406f)
    }
}

可以看到，我们在 onServiceConnected 方法中，开启了一个线程，先睡眠 5s，再调用 ClickUtils.click(this, 622f, 406f) 方法点击 (622,406)。之所以要睡眠 5s，是因为在设置中开启了辅助服务后，onServiceConnected 方法就会立刻回调，而我们要从设置页面返回到此页面才能看到这个按钮被点击的效果，返回过程需要一点时间。

开测

可以看到，我先点击了第一个按钮到达辅助服务设置页面，在开启辅助服务后，我立即返回了 MainActivity，等待几秒后，Test 按钮被自动点击了。说明我们的辅助点击功能已经正常工作了。

注：实际上这里的点击并不局限于本应用内，之所以要返回这个页面再点击，只是为了讲解时更方便，让大家能更清楚地看到效果。

/   应用外截屏   /

应用内截屏

在讲解 Android 应用外截屏之前，我们先看一下 Android 应用内截屏。在 Android 应用内截屏非常简单，只需要获取 View 的缓存即可：

fun screenShot(activity: Activity): Bitmap {
    return view2Bitmap(activity.window.decorView)
}
fun view2Bitmap(view: View): Bitmap {
    view.isDrawingCacheEnabled = true
    return view.drawingCache
}

本文重点讲述应用外截屏。应用外截屏其实也不复杂，只需要两步：

• 通过 MediaProjectionManager 的 getMediaProjection 方法获取到 MediaProjection 对象。

• 再通过 MediaProjection 的 createVirtualDisplay 方法就能截取屏幕了。

应用外截屏

构建 MediaProjectionManager 对象的方式非常简单，调用 getSystemService(MEDIA_PROJECTION_SERVICE) 方法就可以了：

private val mediaProjectionManager: MediaProjectionManager by lazy { getSystemService(MEDIA_PROJECTION_SERVICE) as MediaProjectionManager }

构建 MediaProjection 稍微复杂一点，构建 MediaProjection 对象需要两个参数，一个 resultCode，一个 resultData。

这两个参数什么意思呢，为什么需要它们呢？

这是因为截取应用外屏幕有侵犯用户隐私的风险，所以截屏之前需要获得用户的同意。所以在截屏前需要调用 startActivityForResult 方法询问用户：这个应用准备截屏了，你同意吗？

在用户同意后，onActivityResult 方法中就会携带 resultCode 和 resultData 参数。有了这两个参数，我们就可以构建 MediaProjection 对象了。

Talk is cheap, show me the code. 我们来一起写个 Demo。

首先是布局文件：

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">
 
    <SurfaceView
        android:id="@+id/surfaceView"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        app:layout_constraintBottom_toTopOf="@id/btnStart"
        app:layout_constraintTop_toTopOf="parent" />
 
    <Button
        android:id="@+id/btnStart"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Start Screen Capture"
        android:textAllCaps="false"
        app:layout_constraintBottom_toTopOf="@id/btnStop"
        app:layout_constraintTop_toBottomOf="@id/surfaceView" />
 
    <Button
        android:id="@+id/btnStop"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Stop Screen Capture"
        android:textAllCaps="false"
        app:layout_constraintBottom_toBottomOf="parent" />
 
</androidx.constraintlayout.widget.ConstraintLayout>

效果图：

布局文件中，有一个 SurfaceView，待会我们将用它来展示截图内容。底部有两个按钮，一个 Start Screen Capture，一个 Stop Screen Capture，分别表示开始截图和停止截图。在 build.gradle 中开启 ViewBinding，使得引用控件更加方便：

buildFeatures {
    viewBinding true
}

在 MainActivity 中：

const val REQUEST_MEDIA_PROJECTION = 1
 
class MainActivity : AppCompatActivity() {
    private val binding by lazy { ActivityMainBinding.inflate(layoutInflater) }
    private val mediaProjectionManager: MediaProjectionManager by lazy { getSystemService(MEDIA_PROJECTION_SERVICE) as MediaProjectionManager }
    private var mediaProjection: MediaProjection? = null
    private var virtualDisplay: VirtualDisplay? = null
 
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(binding.root)
        binding.btnStart.setOnClickListener {
            Log.d("~~~", "Requesting confirmation")
            startActivityForResult(mediaProjectionManager.createScreenCaptureIntent(), REQUEST_MEDIA_PROJECTION)
        }
        binding.btnStop.setOnClickListener {
            Log.d("~~~", "Stop screen capture")
            stopScreenCapture()
        }
    }
 
    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        if (requestCode == REQUEST_MEDIA_PROJECTION) {
            if (resultCode != RESULT_OK) {
                Log.d("~~~", "User cancelled")
                return
            }
            Log.d("~~~", "Starting screen capture")
            mediaProjection = mediaProjectionManager.getMediaProjection(resultCode, data!!)
            virtualDisplay = mediaProjection!!.createVirtualDisplay(
                "ScreenCapture",
                ScreenUtils.getScreenWidth(), ScreenUtils.getScreenHeight(), ScreenUtils.getScreenDensityDpi(),
                DisplayManager.VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR,
                binding.surfaceView.holder.surface, null, null
            )
        }
    }
 
    private fun stopScreenCapture() {
        Log.d("~~~", "stopScreenCapture, virtualDisplay = $virtualDisplay")
        virtualDisplay?.release()
        virtualDisplay = null
    }
}

其中，用到的 ScreenUtils 的作用是获取屏幕的宽高和密度。代码如下：

object ScreenUtils {
 
    fun getScreenWidth(): Int {
        return Resources.getSystem().displayMetrics.widthPixels
    }
 
    fun getScreenHeight(): Int {
        return Resources.getSystem().displayMetrics.heightPixels
    }
 
    fun getScreenDensityDpi(): Int {
        return Resources.getSystem().displayMetrics.densityDpi
    }
}

当点击 Start 按钮时，调用 startActivityForResult 询问用户是否同意截屏，这个方法中传入的 Intent 是 mediaProjectionManager.createScreenCaptureIntent()，这是专门用于询问用户是否同意截屏的 Intent，调用这行代码后，会弹出这样一个弹窗：

如果用户点了确认，也就是上图中的 “Start now” 按钮，onActivityResult 就会收到 resultCode == RESULT_OK，以及用户确认后的 data，通过这两个参数，我们就能构建出 mediaProjection 对象了。

获取到 mediaProjection 对象后，通过 createVirtualDisplay 方法开始截屏。这个方法接收多个参数，第一个参数表示 VirtualDisplay 的名字，随意传入一个字符串即可。

紧跟着的三个参数表示屏幕的宽高和密度。下一个参数 DisplayManager.VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR 表示 VirtualDisplay 的 flag，有多种值可选，我暂时不清楚几种 flag 的区别，不妨先记做固定写法。下一个参数表示展示截图结果的 Surface，这里传入 binding.surfaceView.holder.surface，截图结果就会展示到 SurfaceView 上了。最后两个参数一个是 callback，一个是 handler，是用来处理截图的回调的，我们暂时用不上，都传入 null 即可。

需要注意的是，当 createVirtualDisplay 方法调用后，设备就会不断地获取当前屏幕，直到 createVirtualDisplay 创建的 virtualDisplay 对象被 release 才会停止截屏。所以我们在 Stop 按钮的点击事件中，调用了 virtualDisplay 的 release 方法。

整体来说代码还是很简单的，我们运行一下试试：

可以看到，直接 crash 了...查看 Logcat 控制台：

java.lang.SecurityException: Media projections require a foreground service of type ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PROJECTION

报了一个 SecurityException，Media projections 需要一个带有 ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PROJECTION 类型的前台 Service。

前台 Service

我在编写这个 Demo 时，targetSdk 设置的是最新的版本：31，事实上，如果读者在编写此 Demo 时，targetSdk 的版本在 28 或以下，就不会遇到这个错误，此时就已经能正常截屏了。

只有 targetSdk 在 28 以上时，才会出现这个错误。SDK 28 代表 Android 9.0，在 Android 9.0 以后，才要求截屏时必须运行一个前台 Service。

所以修复这个 crash 有两种方案：

• 把 targetSdk 改成 28，

• 创建前台 Service，适配 Android 9.0 以上版本。

我更倾向于第二种方案，因为这个项目是我写给自己练手的，我希望用最新的 API；并且将截图功能放到 Service 中其实也更符合我的需求。

首先新建一个 Service：

class CaptureService : Service() {
 
    override fun onBind(intent: Intent?): IBinder? {
        return null
    }
}

在 AndroidManifest 中，添加 FOREGROUND_SERVICE 权限，注册此 Service：

<uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
<application
    ...>
    ...
    <service
        android:name=".CaptureService"
        android:foregroundServiceType="mediaProjection" />
</application>

此 Service 需要添加 android:foregroundServiceType="mediaProjection" 属性，表示这是用于截屏的 Service。

新建 MyApplication，注册前台 Notification Channel：

const val SCREEN_CAPTURE_CHANNEL_ID = "Screen Capture ID"
const val SCREEN_CAPTURE_CHANNEL_NAME = "Screen Capture"
 
class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        createScreenCaptureNotificationChannel()
    }
 
    private fun createScreenCaptureNotificationChannel() {
        val notificationManager = getSystemService(NOTIFICATION_SERVICE) as NotificationManager
        // Create the channel for the notification
        val screenCaptureChannel = NotificationChannel(SCREEN_CAPTURE_CHANNEL_ID, SCREEN_CAPTURE_CHANNEL_NAME, NotificationManager.IMPORTANCE_LOW)
        // Set the Notification Channel for the Notification Manager.
        notificationManager.createNotificationChannel(screenCaptureChannel)
    }
}

不要忘了在 AndroidManifest 中声明此 Application：

<application
    android:name=".MyApplication"
    .../>

然后，在 CaptureService 中，启用前台通知：

class CaptureService : Service() {
    override fun onCreate() {
        super.onCreate()
        startForeground(1, NotificationCompat.Builder(this, SCREEN_CAPTURE_CHANNEL_ID).build())
    }
 
    override fun onBind(intent: Intent?): IBinder? {
        return null
    }
}

这样就写好了一个前台 Service。

修改 MainActivity 中的代码，点击 Start 后，先启动 Service，再调用截屏：

binding.btnStart.setOnClickListener {
    startForegroundService(Intent(this, CaptureService::class.java))
    Log.d("~~~", "Requesting confirmation")
    startActivityForResult(mediaProjectionManager.createScreenCaptureIntent(), REQUEST_MEDIA_PROJECTION)
}

此时运行就不会报错了，效果如下：

可以看到，已经可以成功截图了，前文说过，当 createVirtualDisplay 方法调用后，设备就会不断地获取当前屏幕，所以才会看到截图画面层层叠叠的效果。

在 Google 官方提供的截图 Demo 中，运行效果也是类似的，感兴趣的读者可以在 github 上查看 Google 官方的 Demo：

https://github.com/android/media-samples/tree/main/ScreenCapture

注：只要启动了这样一个前台 Service，即使没有把截屏逻辑移到 Service 中，也已经可以正常截屏了。但更好的做法是把截图逻辑移到 Service 中，感兴趣的读者可以自行实现。

截图一次并取其 Bitmap

虽然现在截图成功了，但运行效果并不是我们想要的。一般我们想要的效果是，截图一次并取其 Bitmap。

为了实现这个效果，我们需要使用一个新的类：ImageReader。ImageReader 中包含一个 Surface 对象，在 createVirtualDisplay 方法中，将 binding.surfaceView.holder.surface 替换成 ImageReader 的 Surface 对象，就可以将截图结果记录到 ImageReader 中了。

创建 ImageReader：

private val imageReader by lazy { ImageReader.newInstance(ScreenUtils.getScreenWidth(), ScreenUtils.getScreenHeight(), PixelFormat.RGBA_8888, 1) }

创建时需要传入屏幕的宽高，第三个参数表示图片的格式，这里传入的是 PixelFormat.RGBA_8888。

注：实际上写 PixelFormat.RGBA_8888 时，Android Studio 会报错，因为它预期的是传入一个 ImageFormat。PixelFormat.RGBA_8888 对应的常量是 1，但 ImageFormat 中没有对应常量 1 的格式。我尝试过换成 ImageFormat 中的其他格式，但换了之后始终运行不了。而这里的报错却并不影响程序运行，所以我就任由它报红了。如果读者有更好的方案，望不吝赐教：

最后一个参数表示最多保存几张图片，我们传入 1 就可以了。

创建好 ImageReader 后，接下来替换掉 createVirtualDisplay 方法中的参数，并获取 imageReader 中的截图结果：

virtualDisplay = mediaProjection!!.createVirtualDisplay(
    "ScreenCapture",
    ScreenUtils.getScreenWidth(), ScreenUtils.getScreenHeight(), ScreenUtils.getScreenDensityDpi(),
    DisplayManager.VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR,
    imageReader.surface, null, null
)
Handler(Looper.getMainLooper()).postDelayed({
    val image = imageReader.acquireLatestImage()
    if (image != null) {
        Log.d("~~~", "get image: $image")
    } else {
        Log.d("~~~", "image == null")
    }
    stopScreenCapture()
}, 1000)

可以看到，代码中先是将 imageReader.surface 传入了 createVirtualDisplay 方法中，使得截图结果记录到 ImageReader 中。再等待了 1s 钟，然后调用 imageReader.acquireLatestImage() 获取 imageReader 中记录的截图结果，它是一个 Image 对象。之所以等待 1s 是因为截图需要一定的时间，并且在获取到截图结果后，我们需要调用 stopScreenCapture 将 virtualDisplay 对象释放掉，否则这里会一直截图。并且如果不释放的话，在下一次截图时会报以下错误：

java.lang.IllegalStateException: maxImages (1) has already been acquired, call #close before acquiring more.

获取到 Image 对象后，可以将其转换成 Bitmap 对象，转换工具类如下：

object ImageUtils {
    fun imageToBitmap(image: Image): Bitmap {
        val bitmap = Bitmap.createBitmap(image.width, image.height, Bitmap.Config.ARGB_8888)
        bitmap.copyPixelsFromBuffer(image.planes[0].buffer)
        image.close()
        return bitmap
    }
}

这样我们就实现了截图一次并取其 Bitmap。不妨将这个 Bitmap 设置到 ImageView 上，看看效果。首先修改布局文件：

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">
 
    <ImageView
        android:id="@+id/iv"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        app:layout_constraintBottom_toTopOf="@id/btnStart"
        app:layout_constraintTop_toTopOf="parent" />
 
    <Button
        android:id="@+id/btnStart"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Start Screen Capture"
        android:textAllCaps="false"
        app:layout_constraintBottom_toTopOf="@id/btnStop"
        app:layout_constraintTop_toBottomOf="@id/iv" />
 
    <Button
        android:id="@+id/btnStop"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Stop Screen Capture"
        android:textAllCaps="false"
        app:layout_constraintBottom_toBottomOf="parent" />
 
</androidx.constraintlayout.widget.ConstraintLayout>

唯一的修改是把之前布局文件中的 SurfaceView 换成了 ImageView，id 也对应换成了 iv。然后将获取到的 Image 转成 Bitmap，并设置到 ImageView 上：

binding.iv.setImageBitmap(ImageUtils.imageToBitmap(image))

运行效果如下：

可以看到，点击 Start 按钮后，等待 1s 后，就完成了截图，并且展示到了 ImageView 上。这里的截图并不局限于本应用内，不妨看一个截取应用外屏幕的效果：（注：我在录制这个效果时将截图等待时间延长到了 3s，以保证截图时完全退到了桌面）

可以看到，确实可以截取到应用外的屏幕。

只让用户同意一次

现在的截图还有一个问题，每次截图前都会询问用户是否同意截图。虽然我们可以通过上文介绍的模拟点击帮用户点同意，但更好的做法是将用户同意的结果保存起来，下次截图前直接使用即可。我们修改一下 Demo 看看效果。

MainActivity 修改如下：

const val REQUEST_MEDIA_PROJECTION = 1
 
class MainActivity : AppCompatActivity() {
    private val binding by lazy { ActivityMainBinding.inflate(layoutInflater) }
    private val mediaProjectionManager: MediaProjectionManager by lazy { getSystemService(MEDIA_PROJECTION_SERVICE) as MediaProjectionManager }
    private var mediaProjection: MediaProjection? = null
    private var virtualDisplay: VirtualDisplay? = null
    private val handler by lazy { Handler(Looper.getMainLooper()) }
    private val imageReader by lazy { ImageReader.newInstance(ScreenUtils.getScreenWidth(), ScreenUtils.getScreenHeight(), PixelFormat.RGBA_8888, 1) }
 
 
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(binding.root)
        binding.btnStart.setOnClickListener {
            startForegroundService(Intent(this, CaptureService::class.java))
            startScreenCapture()
        }
        binding.btnStop.setOnClickListener {
            Log.d("~~~", "Stop screen capture")
            stopScreenCapture()
        }
    }
 
    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        if (requestCode == REQUEST_MEDIA_PROJECTION) {
            if (resultCode != RESULT_OK) {
                Log.d("~~~", "User cancelled")
                return
            }
            Log.d("~~~", "Starting screen capture")
            mediaProjection = mediaProjectionManager.getMediaProjection(resultCode, data!!)
            setUpVirtualDisplay()
        }
    }
 
    private fun startScreenCapture() {
        if (mediaProjection == null) {
            Log.d("~~~", "Requesting confirmation")
            // This initiates a prompt dialog for the user to confirm screen projection.
            startActivityForResult(mediaProjectionManager.createScreenCaptureIntent(), REQUEST_MEDIA_PROJECTION)
        } else {
            Log.d("~~~", "mediaProjection != null")
            setUpVirtualDisplay()
        }
    }
 
    private fun setUpVirtualDisplay() {
        Log.d("~~~", "setUpVirtualDisplay")
        virtualDisplay = mediaProjection!!.createVirtualDisplay(
            "ScreenCapture",
            ScreenUtils.getScreenWidth(), ScreenUtils.getScreenHeight(), ScreenUtils.getScreenDensityDpi(),
            DisplayManager.VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR,
            imageReader.surface, null, null
        )
        handler.postDelayed({
            val image = imageReader.acquireLatestImage()
            if (image != null) {
                Log.d("~~~", "get image: $image")
                binding.iv.setImageBitmap(ImageUtils.imageToBitmap(image))
            } else {
                Log.d("~~~", "image == null")
            }
            stopScreenCapture()
        }, 1000)
    }
 
    private fun stopScreenCapture() {
        Log.d("~~~", "stopScreenCapture, virtualDisplay = $virtualDisplay")
        virtualDisplay?.release()
        virtualDisplay = null
    }
}

主要修改在于多了一个 startScreenCapture 方法，在这个方法中，先判断 mediaProjection 是否已经存在，如果不存在，则执行刚才的逻辑，调用 startActivityForResult 请求用户同意截屏。如果已经存在，则直接调用 createVirtualDisplay 截屏即可。

运行效果：

这样就实现了用户只需同意一次截屏权限，应用就能多次截屏的功能。

通过上文介绍的模拟点击，在获取截屏权限时，可以实现自动点击同意。然后就可以愉快地多次截屏了。

由于这种截屏方式不局限于本应用内，所以可以在后台默默地不断截取屏幕。接下来我们再学习一点基本的图像识别技术，把截取到的屏幕利用起来。

/   图片识别   /

我采用的方式是对比图片的相似度，以达到知道当前在哪一屏的效果，然后就能通过辅助功能点击这一屏中设定好的坐标了

第一种对比方式

第一种对比方式是：取出两张 bitmap 中的所有像素，然后一一进行对比。匹配的点除以总点数就能得到一个相似度。代码如下：

object SimilarityUtils {
    fun similarity(bitmap1: Bitmap, bitmap2: Bitmap): Double {
        // 获取图片所有的像素
        val pixels1 = getPixels(bitmap1)
        val pixels2 = getPixels(bitmap2)
        // 总的像素点数以较大图片为准
        val totalCount = pixels1.size.coerceAtLeast(pixels2.size)
        if (totalCount == 0) return 0.00
        var matchCount = 0
        var i = 0
        while (i < pixels1.size && i < pixels2.size) {
            if (pixels1[i] == pixels2[i]) {
                // 统计相同的像素点数量
                matchCount++
            }
            i++
        }
        // 相同的像素点数量除以总的像素点数，得到相似比例。
        return String.format("%.2f", matchCount.toDouble() / totalCount).toDouble()
    }
 
    private fun getPixels(bitmap: Bitmap): IntArray {
        val pixels = IntArray(bitmap.width * bitmap.height)
        // 获取每个像素的 RGB 值
        bitmap.getPixels(pixels, 0, bitmap.width, 0, 0, bitmap.width, bitmap.height)
        return pixels
    }
}

可以看到，similarity 函数接收两个 Bitmap，返回一个 Double 值，这个值的取值范围是 0.00~1.00，表示相似度。

首先通过 bitmap.getPixels 取出所有的像素点，以其中较多的像素点作为总点数。

然后通过 pixels1[i] == pixels2[i] 对比每个像素点，如果相同则 matchCount 加一，最后用 matchCount / totalCount 计算出相似度。

这种比较方式特别直观，容易理解，通过每个像素点依次比较得出相似度。我们也很容易想到它的缺点：如果第二张图片是由第一张图片缩放、变形、旋转等变换得来的，那么每个像素点可能都无法匹配上，所以相似度会很低很低。

也就是说，这个算法几乎只能用于比较图片是否一模一样，只要两张图的像素点有细微的错位，比较结果就会完全不准确。

不过其实这种算法已经能够满足我们的需求了，只要我们每次都取一样的 Bitmap 进行比较就可以了。只要保证整张图都一样，或者从 Bitmap 裁剪出的固定区域一样就可以了。此时比较结果可以供我们正常使用。

但更好的做法是通过 SIFT 算法计算相似度。

通过 SIFT 算法计算相似度

SIFT 算法指的是尺度不变特征转换 (Scale Invariant Feature Transform)。它是计算机视觉领域中描述图片特征的一种算法，应用非常广泛。

这个算法是由一些大神们研究出来的，由于本文不是在写论文，所以我也不会对这个算法进行深究，简单介绍一下它的大概原理：

先将图片映射为空间中的坐标：

再从所有坐标中过滤出其中的特征点：

再为特征点分配一个方向值，使得图片变形后仍然能够正确匹配：

将这些信息转换成数学描述：

注：算法原理的这段内容，只是我个人一点粗浅的理解，可能和算法的实际实现有出入。但这个算法的实现不是本文的重点，重点在于这个算法可以用于对比两张图片的相似度。所以于我而言，我愿将其称之为魔法。

这个算法被封装在 OpenCV 库中，所以使用前需要导入 OpenCV 库。

OpenCV 官方没有提供 gradle 导入的方式，所以网上有许多导入 OpenCV 库的教程，讲的都是去下载 OpenCV 的源码，再通过 Module 的方式加入项目中。

但国外有民间大佬为我们封装了 gradle 导入的方式，大佬封装的 github 地址：

https://github.com/quickbirdstudios/opencv-android

所以现在我们可以直接在 build.gradle 中直接导入 OpenCV 库：

implementation 'com.quickbirdstudios:opencv:4.5.3.0'

需要注意的是，OpenCV 库非常大，导入这个库会让 apk 的体积增加 100 多 M，所以要慎用。

有了 OpenCV 库，就可以编写图片相似度对比工具类了：

object SIFTUtils {
    // SIFT detector
    private val siftDetector by lazy { SIFT.create() }
 
    fun similarity(bitmap1: Bitmap, bitmap2: Bitmap): Double {
        // 计算每张图片的特征点
        val descriptors1 = computeDescriptors(bitmap1)
        val descriptors2 = computeDescriptors(bitmap2)
        // 比较两张图片的特征点
        val descriptorMatcher = DescriptorMatcher.create(DescriptorMatcher.FLANNBASED)
        val matches: List<MatOfDMatch> = ArrayList()
        // 计算大图中包含多少小图的特征点。
        // 如果计算小图中包含多少大图的特征点，结果会不准确。
        // 比如：若小图中的 50 个点都包含在大图中的 100 个特征点中，则计算出的相似度为 100%，显然不符合我们的预期
        if (bitmap1.byteCount > bitmap2.byteCount) {
            descriptorMatcher.knnMatch(descriptors1, descriptors2, matches, 2)
        } else {
            descriptorMatcher.knnMatch(descriptors2, descriptors1, matches, 2)
        }
        Log.i("~~~", "matches.size: ${matches.size}")
        if (matches.isEmpty()) return 0.00
        // 获取匹配的特征点数量
        var matchCount = 0
        // 邻近距离阀值，这里设置为 0.7，该值可自行调整
        val nndrRatio = 0.7f
        matches.forEach { match ->
            val array = match.toArray()
            // 用邻近距离比值法(NNDR)计算匹配点数
            if (array[0].distance <= array[1].distance * nndrRatio) {
                matchCount++
            }
        }
        Log.i("~~~", "matchCount: $matchCount")
        return String.format("%.2f", matchCount.toDouble() / matches.size).toDouble()
    }
 
    private fun computeDescriptors(bitmap: Bitmap): MatOfKeyPoint {
        val mat = Mat()
        Utils.bitmapToMat(bitmap, mat)
        val keyPoints = MatOfKeyPoint()
        siftDetector.detect(mat, keyPoints)
        val descriptors = MatOfKeyPoint()
        // 计算图片的特征点
        siftDetector.compute(mat, keyPoints, descriptors)
        return descriptors
    }
}

在这个类中，同样有一个 similarity 方法，接收两个 Bitmap，返回一个 0.00~1.00 的 Double 型数据，表示图片的相似度。

首先通过 SIFT.create() 构建出用 SIFT 算法实现的图片检测器 siftDetector，再通过 siftDetector.compute 计算出图片的特征点。

再通过 DescriptorMatcher.create 构建出 descriptorMatcher 对象，通过 descriptorMatcher.knnMatch 方法比较出两张图片相似的特征点数量。

这里比较时有一个 if 条件判断，它的作用是保证比较的是大图中包含多少小图中的特征点。因为如果计算小图中包含多少大图的特征点，结果会不准确。

比如：若小图中的 50 个点都包含在大图中的 100 个特征点中，则计算出的相似度为 100%，显然不符合我们的预期。

最后通过 array[0].distance <= array[1].distance * nndrRatio 判断特征点是否相似，统计出相似的特征点数量后，通过 matchCount / matches.size 计算出相似度。

测试

先在 res/drawable 文件夹下放一张图片，比如我放了一张我的头像，命名为 img.png：

然后修改 MainActivity 中的代码：

class MainActivity : AppCompatActivity() {
 
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
 
        val bitmap1 = BitmapFactory.decodeResource(resources, R.drawable.img)
        val bitmap2 = Bitmap.createBitmap(bitmap1, 0, 0, bitmap1.width / 2, bitmap1.height / 2)
        Log.d("~~~", "similarity: ${SIFTUtils.similarity(bitmap1, bitmap2)}")
    }
}

首先通过 BitmapFactory.decodeResource 将 res/drawable 文件夹中的图片取出来，转换成 Bitmap，构建出 bitmap1。bitmap2 由 bitmap1 裁剪而来，通过 Bitmap.createBitmap 方法，从 bitmap1 的 (0, 0) 位置开始，裁剪出宽为原图一半、高为原图一半的 Bitmap。然后调用 SIFTUtils.similarity(bitmap1, bitmap2) 比较两张图片的相似度。

非常完美！

运行代码，立马 crash：

E/AndroidRuntime: FATAL EXCEPTION: main
    Process: com.example.imagesimilarity, PID: 21924
    java.lang.UnsatisfiedLinkError: No implementation found for long org.opencv.core.Mat.n_Mat() (tried Java_org_opencv_core_Mat_n_1Mat and Java_org_opencv_core_Mat_n_1Mat__)
        at org.opencv.core.Mat.n_Mat(Native Method)
        at org.opencv.core.Mat.<init>(Mat.java:23)
        at com.example.imagesimilarity.SIFTUtils.computeDescriptors(SIFTUtils.kt:50)
        at com.example.imagesimilarity.SIFTUtils.similarity(SIFTUtils.kt:19)
        at com.example.imagesimilarity.MainActivity.onCreate(MainActivity.kt:38)
        at android.app.Activity.performCreate(Activity.java:8000)

果然凡事都没有一帆风顺的。这个报错大致意思是没有找到 OpenCV 中的某个方法的具体实现。奇了怪了，我们明明已经导入过 OpenCV 库了。

查询一番后，在 StackOverflow 上找到了答案，原因是 OpenCV 使用前需要先初始化。

MainActivity 代码修改如下：

class MainActivity : AppCompatActivity() {
 
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        val loaded = OpenCVLoader.initDebug()
        Log.d("~~~", "loaded: $loaded")
        if (loaded) {
            val bitmap1 = BitmapFactory.decodeResource(resources, R.drawable.img)
            val bitmap2 = Bitmap.createBitmap(bitmap1, 0, 0, bitmap1.width / 2, bitmap1.height / 2)
            Log.d("~~~", "similarity: ${SIFTUtils.similarity(bitmap1, bitmap2)}")
        }
    }
}

在 onCreate 方法中，先调用 OpenCVLoader.initDebug 方法初始化 OpenCV，通过其返回值判断是否加载成功，当加载成功后再执行我们刚才的比较相似度逻辑。

运行程序，Logcat 控制台输出如下：

D/~~~: loaded: true
I/~~~: matches.size: 190
I/~~~: matchCount: 88
D/~~~: similarity: 0.46

表示两张图片的相似度为 46%，说明我们的程序已经正常工作了。

/   后记   /

到这里，我们的外挂三部曲就完结了。这三章讲述了三个独立的技术点：模拟点击、应用外截屏、图像识别。这些技术对用户而言有些风险，所以通常都需要用户手动授权。比如模拟点击前需要用户开启辅助功能，截取屏幕前需要用户同意应用读取屏幕。

为什么没有讲他们的综合运用呢？这实际上是我无奈之举。这些技术综合运用起来像是黑魔法，有些黑科技成分，不便细讲，我平时也只运用在自己的个人手机上，让它们帮我做一些机械的重复工作。这几篇文章只是给大家介绍锤子、钉子、板子，如何用它们制作桌椅板凳还需要读者亲自动手。

推荐阅读：

我的新书，《第一行代码 第3版》已出版！

我为Android版Microsoft Edge所带来的变化

安卓13来了，快！扶起我来！

欢迎关注我的公众号

学习技术或投稿

长按上图，识别图中二维码即可关注