devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android 实现屏幕录制和截屏_android 录屏开发

作者：2023面试高手 | 2024-05-15 03:38:26

赞

踩

android 录屏开发

在移动开发中，实现屏幕录制和截屏是常见的需求。对于 Android 应用而言，实现屏幕录制和截屏可以帮助开发者更好地测试和调试自己的应用，同时还能够提供一些特定场景下的用户体验。

屏幕录制

Android 应用程序可以通过使用 MediaProjection API 来实现屏幕录制功能。使用此 API 可以获取指定屏幕的图像帧，并进行相关处理或保存为视频文件。

下面是一些简要的实现步骤：

  1. 获取 MediaProjection 对象：调用 MediaProjectionManager.createScreenCaptureIntent() 方法，启动屏幕捕获 Intent，并在 onActivityResult() 方法中获取 MediaProjection 对象。

  2. 创建虚拟显示器：使用 DisplayManager.createVirtualDisplay() 方法创建虚拟显示器，并将其与 MediaProjection 对象进行绑定。虚拟显示器将模拟真实屏幕并捕获图像帧。

  3. 获取屏幕截图：使用 MediaProjection.createVirtualDisplay() 的返回值创建 Surface 实例，并将其传递到 ImageReader.newInstance() 方法中，用于捕获指定屏幕的图像帧。

  4. 处理和编码每一帧图像：使用 ImageReader.acquireNextImage() 方法获取每一帧图像，并将其转换为 Bitmap 或 byte[] 形式。之后，可对图像进行自定义处理、压缩和编码操作，例如使用 MediaCodec 进行 H.264 编码等。

  5. 保存为视频文件：将每一帧图像数据按照音视频格式进行封装，写入 MP4 文件中。

需要注意的是，在 Android 5.0 以上版本中，启动屏幕捕获 Intent 需要授权，而且用户会受到屏幕被录制的通知。因此，要想隐藏通知，需要使用 SystemUI 系统应用程序或自己编写（需要 root 权限）。

在 Android 应用程序中实现屏幕录制，可以使用 MediaProjection API。具体实现步骤如下：

  1. 获取 MediaProjection 对象

在 Activity 中启动屏幕捕获 Intent，并在 onActivityResult() 方法中获取 MediaProjection 对象。

private static final int REQUEST_CODE = 1;
private MediaProjectionManager mMediaProjectionManager;
private MediaProjection mMediaProjection;

private void startScreenCapture() {
    mMediaProjectionManager = (MediaProjectionManager) getSystemService(Context.MEDIA_PROJECTION_SERVICE);
    startActivityForResult(mMediaProjectionManager.createScreenCaptureIntent(), REQUEST_CODE);
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == REQUEST_CODE && resultCode == RESULT_OK) {
        mMediaProjection = mMediaProjectionManager.getMediaProjection(resultCode, data);
        startRecord();
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  1. 创建虚拟显示器

调用 MediaProjection.createVirtualDisplay() 方法创建一个虚拟显示器，该方法接受的参数包括显示器名称、显示器宽度、显示器高度、显示器 dpi、显示标识符等，并返回一个 VirtualDisplay 对象。

private static final int DISPLAY_FLAGS =
        DisplayManager.VIRTUAL_DISPLAY_FLAG_PUBLIC |
        DisplayManager.VIRTUAL_DISPLAY_FLAG_OWN_CONTENT_ONLY |
        DisplayManager.VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR;
private static final int RECORD_WIDTH = 1280;
private static final int RECORD_HEIGHT = 720;
private static final int RECORD_DPI = 320;
private VirtualDisplay mVirtualDisplay;

private void startRecord() {
    // 创建 ImageReader 对象，用于从虚拟显示器中获取图像帧
    ImageReader imageReader = ImageReader.newInstance(RECORD_WIDTH, RECORD_HEIGHT, PixelFormat.RGBA_8888, 2);

    // 创建虚拟显示器，指定虚拟显示器的名称、宽度、高度、dpi 等参数
    mVirtualDisplay = mMediaProjection.createVirtualDisplay(
            "ScreenCapture",
            RECORD_WIDTH, RECORD_HEIGHT, RECORD_DPI,
            DISPLAY_FLAGS,
            imageReader.getSurface(), null, mHandler);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  1. 从 ImageReader 中获取图像帧并编码

调用 ImageReader.acquireLatestImage() 方法从 ImageReader 对象中获取最新一帧的图像数据，并将其转换为 Bitmap 对象。然后使用 MediaCodec API 将 Bitmap 编码为 H.264 格式的视频流。

private static final String MIME_TYPE = "video/avc";
private static final int FRAME_RATE = 30;
private static final int I_FRAME_INTERVAL = 1;
private static final int BIT_RATE = RECORD_WIDTH * RECORD_HEIGHT * 4 * 5; // 视频编码码率(比特率)，计算方式参考 H.264 的标准
private static final int TIMEOUT_US = 10000;

private MediaCodec mEncoder;
private Surface mSurface;

private void startEncode() {
    try {
        // 创建 MediaCodec 对象，指定编码器类型、编码格式、采样率、比特率等参数
        mEncoder = MediaCodec.createEncoderByType(MIME_TYPE);
        MediaFormat mediaFormat = MediaFormat.createVideoFormat(MIME_TYPE, RECORD_WIDTH, RECORD_HEIGHT);
        mediaFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
        mediaFormat.setInteger(MediaFormat.KEY_BIT_RATE, BIT_RATE); // 比特率
        mediaFormat.setInteger(MediaFormat.KEY_FRAME_RATE, FRAME_RATE); // 帧率
        mediaFormat.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, I_FRAME_INTERVAL); // I帧间隔

        // 配置 MediaCodec 对象并启动
        mEncoder.configure(mediaFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
        mSurface = mEncoder.createInputSurface();
        mEncoder.start();

        // 获取 ImageReader 中的图像数据并编码
        while (true) {
            Image image = mImageReader.acquireLatestImage();
            if (image == null) {
                continue;
            }

            // 将 Image 转化为 Bitmap 对象
            Image.Plane[] planes = image.getPlanes();
            int width = image.getWidth();
            int height = image.getHeight();
            ByteBuffer buffer = planes[0].getBuffer();
            int pixelStride = planes[0].getPixelStride();
            int rowStride = planes[0].getRowStride();
            int padding = rowStride - pixelStride * width;
            Bitmap bitmap = Bitmap.createBitmap(width + padding / pixelStride, height, Bitmap.Config.ARGB_8888);
            bitmap.copyPixelsFromBuffer(buffer);
            bitmap = Bitmap.createBitmap(bitmap, 0, 0, width, height);

            // 编码 Bitmap 数据
            long pts = System.nanoTime() / 1000;
            int inputIndex = mEncoder.dequeueInputBuffer(TIMEOUT_US);
            if (inputIndex >= 0) {
                Surface surface = mEncoder.createInputSurface();
                Canvas canvas = surface.lockCanvas(null);
                canvas.drawBitmap(bitmap, new Matrix(), null);
                surface.unlockCanvasAndPost(canvas);
                mEncoder.queueInputBuffer(inputIndex, 0, 0, pts, 0);
            }

            image.close();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

  • 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

需要注意的是，在使用 MediaProjection API 进行屏幕录制时，需要获取用户的授权。同时在录制过程中，还需要处理好多个线程之间的同步关系，避免出现数据异常等情况。

截屏

在 Android 应用程序中实现屏幕截屏，通常可以使用以下两种方式：

  1. 使用 MediaProjection API：MediaProjection API 是 Android Framework 提供的一种机制，允许应用获取指定屏幕的图像帧，并进行相关处理或保存为视频文件。在屏幕截屏方面，开发者可以使用 MediaProjection.createVirtualDisplay() 方法创建虚拟显示器，并使用 ImageReader.acquireLatestImage() 方法获取最新的一帧图像，进而将其保存为图片文件。

具体实现过程如下：

// 在 Activity 中启动屏幕捕获 Intent，并在 onActivityResult() 方法中获取 MediaProjection 对象
private void startScreenCapture() {
    mMediaProjectionManager = (MediaProjectionManager) getSystemService(Context.MEDIA_PROJECTION_SERVICE);
    startActivityForResult(mMediaProjectionManager.createScreenCaptureIntent(), REQUEST_MEDIA_PROJECTION);
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == REQUEST_MEDIA_PROJECTION && resultCode == RESULT_OK) {
        mMediaProjection = mMediaProjectionManager.getMediaProjection(resultCode, data);

        // 创建虚拟显示器
        mVirtualDisplay = mMediaProjection.createVirtualDisplay(
                "ScreenCapture",
                mScreenWidth, mScreenHeight, mScreenDensity,
                DisplayManager.VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR,
                mImageReader.getSurface(), null, mHandler);
    }
}

// 在需要截屏的时候调用
private void takeScreenShot() {
    Image image = mImageReader.acquireLatestImage();
    ByteBuffer buffer = image.getPlanes()[0].getBuffer();
    byte[] bytes = new byte[buffer.capacity()];
    buffer.get(bytes);
    Bitmap bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);

    // 将 Bitmap 保存为本地文件
    File file = new File(Environment.getExternalStorageDirectory(), "screenshot.png");
    FileOutputStream outputStream = null;
    try {
        outputStream = new FileOutputStream(file);
        bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream);
        Log.d(TAG, "ScreenShot Saved");
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } finally {
        image.close();
        if (outputStream != null) {
            try {
                outputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

  • 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

需要注意的是，在 Android 5.0 及以上版本中，启动屏幕捕获 Intent 需要授权，而且用户会受到屏幕被录制的通知。如果要想避免这种情况，需要使用 SystemUI 系统应用程序或自己编写（需要 root 权限）。

  1. 使用 View 的 draw() 方法：在 View 的绘制过程中，可以通过调用 View 的 draw(Canvas canvas) 方法来获取其绘制区域的内容，并将其保存为图片文件。具体实现方式如下：
// 创建一个 View
View view = getWindow().getDecorView();

// 创建 Bitmap 并将 View 绘制到画布上
Bitmap bm = Bitmap.createBitmap(view.getWidth(), view.getHeight(), Bitmap.Config.ARGB_8888);
Canvas canvas = new Canvas(bm);
view.draw(canvas);

// 将 Bitmap 保存到本地文件中
File saveDir = Environment.getExternalStorageDirectory();
File file = new File(saveDir, "screenshot.png");
OutputStream outputStream = new FileOutputStream(file);
bm.compress(Bitmap.CompressFormat.PNG, 100, outputStream);
outputStream.close();

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

需要注意的是，该方法只适用于当前应用程序内部界面的截图。如果想要截取其他应用程序、系统界面或整个屏幕的截图，则需要使用 MediaProjection API 实现。

长截屏

实现长截屏的方法一般是通过将多个屏幕截图拼接在一起。下面是一些实现长截屏的步骤以及相关代码示例：

  1. 获取屏幕宽度和高度
DisplayMetrics metrics = getResources().getDisplayMetrics();
int width = metrics.widthPixels;
int height = metrics.heightPixels;

  • 1
  • 2
  • 3
  1. 创建一个空的 Bitmap 对象用于保存所截取的屏幕内容
Bitmap longScreenshot = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);

  • 1
  1. 获取当前屏幕的 View 对象并将其绘制到 Bitmap 中
View screenshotView = getWindow().getDecorView().getRootView();
Canvas canvas = new Canvas(longScreenshot);
screenshotView.draw(canvas);

  • 1
  • 2
  • 3
  1. 循环获取当前 View 的滚动位置并将其截取下来，然后将其拼接到 longScreenshot 中
while (scrollY < totalHeight) {
    scrollView.scrollTo(0, scrollY);
    Bitmap bitmap = Bitmap.createBitmap(scrollView.getWidth(), scrollView.getHeight(), Bitmap.Config.ARGB_8888);
    Canvas canvas = new Canvas(bitmap);
    scrollView.draw(canvas);
    canvas.drawBitmap(bitmap, 0, scrollY, null);
    scrollY += scrollView.getHeight();
}

longScreenshot.compress(Bitmap.CompressFormat.PNG, 100, outputStream);

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

完整代码示例请参考：

private void takeLongScreenshot() {
    // 获取屏幕宽度和高度
    DisplayMetrics metrics = getResources().getDisplayMetrics();
    int width = metrics.widthPixels;
    int height = metrics.heightPixels;
    
    // 创建一个空的 Bitmap 对象用于保存所截取的屏幕内容
    Bitmap longScreenshot = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
    
    // 获取当前屏幕的 View 对象并将其绘制到 Bitmap 中
    View screenshotView = getWindow().getDecorView().getRootView();
    Canvas canvas = new Canvas(longScreenshot);
    screenshotView.draw(canvas);
    
    // 循环获取当前 View 的滚动位置并将其截取下来，然后将其拼接到 longScreenshot 中
    int scrollY = screenshotView.getHeight();
    ScrollView scrollView = findViewById(R.id.scroll_view);
    int totalHeight = scrollView.getChildAt(0).getHeight();
    while (scrollY < totalHeight) {
        scrollView.scrollTo(0, scrollY);
        Bitmap bitmap = Bitmap.createBitmap(scrollView.getWidth(), scrollView.getHeight(), Bitmap.Config.ARGB_8888);
        Canvas canvas1 = new Canvas(bitmap);
        scrollView.draw(canvas1);
        canvas.drawBitmap(bitmap, 0, scrollY, null);
        scrollY += scrollView.getHeight();
    }
    
    // 将拼接后的长截屏保存到文件中
    try {
        FileOutputStream outputStream = new FileOutputStream(getExternalFilesDir(null) + "/long_screenshot.png");
        longScreenshot.compress(Bitmap.CompressFormat.PNG, 100, outputStream);
        outputStream.flush();
        outputStream.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

  • 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

需要注意的是，由于手机屏幕宽度和高度有限，因此一些页面可能无法完全截取。同时，由于 Android 系统版本和不同厂商的定制系统可能存在差异，因此上述代码并不能保证在所有情况下都能正常工作。

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号