Android截屏方法总结

最近研究了一些Android的截屏方法，做一个总结。

图片剪裁方法
使用View.getDrawingCache()得到Bitmap。非常简单但是只能截图本应用的图片，并且没办法控制截图的范围。
对Bitmap进行截屏。可以方便的操作截取大小，但是需要提前截取整个屏幕，然后再处理生成的Bitmap。截取屏幕流程：打开一个新的Window全屏展示，上面包含一个CropView->操作CropView选择区域->根据选择区域截取Bitmap。
代码调用
一般需求用来从相册选择或者从相册发送图片。
(1).选择图片。打开系统选择图片的Activity并设置相应的参数。

// 打开选择的Activity.
private void selectPic(){
Intent intent = new Intent("android.intent.action.PICK");
intent.setDataAndType(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, "image/*");
startActivityForResult(intent, REQUEST_PICK_IMG);
}
1
2
3
4
5
6
(2).截切图片。选择图片成功(onActivityResult)以后，设置相应参数开始裁剪图片。

// 截取图片
public void cutImage(Uri uri){
try {
Intent intent = new Intent("com.android.camera.action.CROP");
intent.setDataAndType(uri, "image/*");
intent.putExtra("crop", "true");
intent.putExtra("aspectX", 1);
intent.putExtra("aspectY", 1);
intent.putExtra("outputX", width);
intent.putExtra("outputY", height);
// 不返回bitmap，全使用uri来传递，防止图片使用内存太大
intent.putExtra("return-data", false);
intent.putExtra("output", outputUri);
intent.putExtra("outputFormat", Bitmap.CompressFormat.JPEG.toString());
intent.putExtra("scale", true);
intent.putExtra("scaleUpIfNeeded", true);
intent.putExtra("noFaceDetection", true);
startActivityForResult(intent, REQUEST_CUT_IMG);
}
catch (Exception e) {
Log.e("Test", "com.android.camera.action.CROP error");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
(3).onActivityResult处理裁剪图片成功以后回调。

流程分析(基于api25)
系统从相册打开图片，然后截取图片。源码在com.android.gallery3d包下，com.android.gallery3d是一个单独的应用(进程)。
(1).打开相册com.android.gallery3d/.app.GalleryActivity，选择图片，略过。
(2).打开截图界面com.android.gallery3d/.filtershow.crop.CropActivity。
(3).执行BitmapIOTask.doInBackground，对sourceUri进行操作，保存在dstUri中。
(4).执行CropActivity.getCroppedImage进行截图。

protected static Bitmap getCroppedImage(Bitmap image, RectF cropBounds, RectF photoBounds) {
// cropBounds：截取大小。photoBounds：图片大小。
RectF imageBounds = new RectF(0, 0, image.getWidth(), image.getHeight());
RectF crop = CropMath.getScaledCropBounds(cropBounds, photoBounds, imageBounds);
if (crop == null) {
return null;
}
Rect intCrop = new Rect();
crop.roundOut(intCrop);

// 相当于直接对Bitmap 进行截取。
return Bitmap.createBitmap(image, intCrop.left, intCrop.top, intCrop.width(),
intCrop.height());
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
api21以上使用MediaProjectionManager，MediaProjection，VirtualDisplay，ImageReader。
代码调用
(1).申请权限

private void requestCapturePermission() {
MediaProjectionManager mediaProjectionManager = (MediaProjectionManager)
getSystemService(Context.MEDIA_PROJECTION_SERVICE);
startActivityForResult(mediaProjectionManager.createScreenCaptureIntent(),
REQUEST_MEDIA_PROJECTION);
}
1
2
3
4
5
6
获取权限以后，获取MediaProjection对象。

MediaProjection mMediaProjection;
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
switch (requestCode) {
case REQUEST_MEDIA_PROJECTION:
mMediaProjection = ((MediaProjectionManager) getSystemService(Context.MEDIA_PROJECTION_SERVICE))
.getMediaProjection(Activity.RESULT_OK, data);
}
}
1
2
3
4
5
6
7
8
(2).获取屏幕内容

// 获取屏幕内容
VirtualDisplay mVirtualDisplay;
private void virtualDisplay() {
mVirtualDisplay = mMediaProjection.createVirtualDisplay("screen-mirror",
mScreenWidth, mScreenHeight, mScreenDensity,
DisplayManager.VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR,
mImageReader.getSurface(), null, null);
}
1
2
3
4
5
6
7
8
(3).截图，android.media.Image可以拿到相应的Bitmap信息。

ImageReader.OnImageAvailableListener() {
// 每当生成一个新的Image 的时候都会回调onImageAvailable
@Override
public void onImageAvailable(ImageReader reader) {
if (reader == null) {
return;
}
// 最终会调用native方法
Image image = reader.acquireLatestImage();
if (image == null) {
startScreenShot();
} else {
if (mCropView != null) {
int width = image.getWidth();
int height = image.getHeight();
final Image.Plane[] planes = image.getPlanes();
final ByteBuffer buffer = planes[0].getBuffer();
int pixelStride = planes[0].getPixelStride();
int rowStride = planes[0].getRowStride();
int rowPadding = rowStride - pixelStride * width;
Bitmap bitmap = Bitmap.createBitmap(width + (pixelStride == 0 ? 0 : rowPadding / pixelStride), height, Bitmap.Config.ARGB_8888);
// 最终生成了Bitmap保存了图片
bitmap.copyPixelsFromBuffer(buffer);
}
}

if (image != null) {
// 注意需要调用close
image.close();
}

// 防止多次回调onImageAvailable
reader.close();

}
}, mMainHandler);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
利用ddmlib(DDMS的ddmlib.jar)截屏。
代码调用
(1).创建Java工程，并导入ddmlib.jar，ddms.jar和ddmuilib.jar。在Android SDK的tools/lib目录下面。
(2).直接完整代码了，注意getDevice中的createBridge需要改成自己电脑adb的路径。takeScreenshot中保存的路径需要设置成自己的路径。main中调用的getDevice需要改成自己手机的id。

public class MyClass {

private static void waitDeviceList(AndroidDebugBridge bridge) {
int count = 0;
while (bridge.hasInitialDeviceList() == false) {
try {
Thread.sleep(100); // 如果没有获得设备列表，则等待
count++;
} catch (InterruptedException e) {
}
if (count > 300) {
// 设定时间超过300×100 ms的时候为连接超时
System.err.print("Time out");
break;
}
}
}

/**
* 连接device
*/
private static IDevice getDevice(String id) {
AndroidDebugBridge.init(false); // 需要初始化 false
AndroidDebugBridge bridge = AndroidDebugBridge
.createBridge("/Users/Egos/Library/Android/sdk/platform-tools/adb", false);
waitDeviceList(bridge);
IDevice devices[] = bridge.getDevices();

for (IDevice onlinedeivce : devices) {
if (onlinedeivce.getSerialNumber().equals(id))
return onlinedeivce;
}

return null;
}

/**
* 截取屏幕
*/
private static void takeScreenshot(IDevice device) {
try {
RawImage rawScreen = device.getScreenshot();
if (rawScreen != null) {
int width = rawScreen.width;
int height = rawScreen.height;
BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
int index = 0;
int indexInc = rawScreen.bpp >> 3;
for (int y = 0; y < rawScreen.height; y++) {
for (int x = 0; x < rawScreen.width; x++, index += indexInc) {
int value = rawScreen.getARGB(index);
image.setRGB(x, y, value);
}
}
ImageIO.write(image, "PNG", new File("/Users/Egos/Downloads/test.png"));
}
} catch (Exception e) {
e.printStackTrace();
}
}

public static void main(String[] args) {
IDevice device = getDevice("03f37b9af0c746f4");
takeScreenshot(device);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
adb shell screencap -p filepath。使用adb截图保存在手机上面，没有具体分析调用流程。
执行adb shell input keyevent 120，相当于调用的系统截屏（手机组合键截图）。
流程分析(基于api25)
(1).按下组合键以后，执行到PhoneWindowManager.interceptKeyBeforeDispatching()

// PhoneWindowManager.java
public long interceptKeyBeforeDispatching(WindowState win, KeyEvent event, int policyFlags) {
// 省略代码
else if (keyCode == KeyEvent.KEYCODE_S && event.isMetaPressed()
&& event.isCtrlPressed()) {
if (down && repeatCount == 0) {
int type = event.isShiftPressed() ? TAKE_SCREENSHOT_SELECTED_REGION
: TAKE_SCREENSHOT_FULLSCREEN;
mScreenshotRunnable.setScreenshotType(type);
mHandler.post(mScreenshotRunnable);
return -1;
}
}

// 省略代码
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
(2).执行到PhoneWindowManager.ScreenshotRunnable.run()

// PhoneWindowManager.java
private class ScreenshotRunnable implements Runnable {
private int mScreenshotType = TAKE_SCREENSHOT_FULLSCREEN;
public void setScreenshotType(int screenshotType) {
mScreenshotType = screenshotType;
}

@Override
public void run() {
takeScreenshot(mScreenshotType);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
(3).执行到takeScreenshot

// PhoneWindowManager.java
private void takeScreenshot(final int screenshotType) {
// SYSUI_SCREENSHOT_SERVICE = "com.android.systemui.screenshot.TakeScreenshotService"
final ComponentName serviceComponent = new ComponentName(SYSUI_PACKAGE,
SYSUI_SCREENSHOT_SERVICE);
// 省略代码
final Intent serviceIntent = new Intent();
serviceIntent.setComponent(serviceComponent);
ServiceConnection conn = new ServiceConnection() {
// 省略代码
}
if (mContext.bindServiceAsUser(serviceIntent, conn,
Context.BIND_AUTO_CREATE | Context.BIND_FOREGROUND_SERVICE_WHILE_AWAKE,
UserHandle.CURRENT)) {
mScreenshotConnection = conn;
mHandler.postDelayed(mScreenshotTimeout, 10000);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
(4).com.android.systemui.screenshot.TakeScreenshotService

private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
final Messenger callback = msg.replyTo;
// 省略代码
if (mScreenshot == null) {
mScreenshot = new GlobalScreenshot(TakeScreenshotService.this);
}

switch (msg.what) {
// 截取全屏
case WindowManager.TAKE_SCREENSHOT_FULLSCREEN:
mScreenshot.takeScreenshot(finisher, msg.arg1 > 0, msg.arg2 > 0);
break;
// 截取指定区域
case WindowManager.TAKE_SCREENSHOT_SELECTED_REGION:
mScreenshot.takeScreenshotPartial(finisher, msg.arg1 > 0, msg.arg2 > 0);
break;
}
}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
(5).截取全屏或者指定区域最后都是执行到了同一个逻辑。分析全屏截取。执行mScreenshot.takeScreenshot。

// GlobalScreenshot.java
void takeScreenshot(Runnable finisher, boolean statusBarVisible, boolean navBarVisible) {
mDisplay.getRealMetrics(mDisplayMetrics);
// 全屏就是 (0,0) -> (width,height)
takeScreenshot(finisher, statusBarVisible, navBarVisible, 0, 0, mDisplayMetrics.widthPixels,
mDisplayMetrics.heightPixels);
}
1
2
3
4
5
6
7
(6).GlobalScreenshot.takeScreenshot，截取选择区域也是这个方法。

// GlobalScreenshot.java
void takeScreenshot(Runnable finisher, boolean statusBarVisible, boolean navBarVisible,
int x, int y, int width, int height) {

// 省略代码
// 截取代码获取了Bitmap。
mScreenBitmap = SurfaceControl.screenshot((int) dims[0], (int) dims[1]);
// 截屏失败
if (mScreenBitmap == null) {
notifyScreenshotError(mContext, mNotificationManager,
R.string.screenshot_failed_to_capture_text);
finisher.run();
return;
}

// 省略代码
// Start the post-screenshot animation
startAnimation(finisher, mDisplayMetrics.widthPixels, mDisplayMetrics.heightPixels,
statusBarVisible, navBarVisible);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
(7).SurfaceControl.screenshot，SurfaceControl是hide的。

// SurfaceControl.java
public static Bitmap screenshot(int width, int height) {
IBinder displayToken = SurfaceControl.getBuiltInDisplay(
SurfaceControl.BUILT_IN_DISPLAY_ID_MAIN);
// 调用native代码截图
return nativeScreenshot(displayToken, new Rect(), width, height, 0, 0, true,
false, Surface.ROTATION_0);
}
1
2
3
4
5
6
7
8
扩展
截屏功能native层通过framebuffer来实现的（这里可能不是很准确）。帧缓冲（framebuffer）是Linux为显示设备提供的一个接口，把显存抽象后的一种设备，他允许上层应用程序在图形模式下直接对显示缓冲区进行读写操作。Android系统是基于Linux内核的，所以也存在framebuffer这个设备，我们要实现截屏的话只要能获取到framebuffer中的数据，然后把数据转换成图片就可以了，Android中的framebuffer数据是存放在 /dev/graphics/fb0文件中的，所以我们只需要来获取这个文件的数据就可以得到当前屏幕的内容。

总结
在自身应用中截取一个View比较简单。但是去截取任意界面任意大小，就需要比较大的权限，可能需要root手机。直接使用android.view.SurfaceControl反射处理。需要使用到系统的uid``android:sharedUserId="android.uid.systemui"。api21以后系统开放了截图的接口，可以直接使用(自己的使用的时候碰到过问题)。

参考
为什么 Android 截屏需要 root 权限
截屏方法总结
ddmlib使用入门
---------------------
作者：CoolEgos
来源：CSDN
原文：https://blog.csdn.net/A38017032/article/details/70482514
版权声明：本文为博主原创文章，转载请附上博文链接！

更多相关文章

随机推荐