android 屏幕录制方案,Android录屏的三种方案

本文总结三种用于安卓录屏的解决方案：

adb shell命令screenrecord

MediaRecorder， MediaProjection

MediaProjection , MediaCodec和MediaMuxer

screenrecord命令

screenrecord是一个shell命令，支持Android4.4(API level 19)以上，录制的视频格式为mp4 ,存放到手机sd卡里，默认录制时间为180s

adb shell screenrecord --size 1280*720 --bit-rate 6000000 --time-limit 30 /sdcard/demo.mp4

--size 指定视频分辨率；

--bit-rate 指定视频比特率，默认为4M，该值越小，保存的视频文件越小；

--time-limit 指定录制时长，若设定大于180，命令不会被执行；

MediaRecorder

MediaProjection是Android5.0后才开放的屏幕采集接口，通过系统级服务MediaProjectionManager进行管理。

录屏过程可以分成两个部分，即通过MediaProjectionManage申请录屏权限，用户允许后开始录制屏幕；然后通过MediaRecorder对音视频数据进行处理。

获取MediaProjectionManager实例

MediaProjectionManager mProjectionManager = (MediaProjectionManager) getSystemService("media_projection");

申请权限

Intent captureIntent = mProjectionManager.createScreenCaptureIntent();

startActivityForResult(captureIntent, LOCAL_REQUEST_CODE);

createScreenCaptureIntent()这个方法会返回一个intent，你可以通过startActivityForResult方法来传递这个intent，为了能开始屏幕捕捉，activity会提示用户是否允许屏幕捕捉(为了防止开发者做一个木马，来捕获用户私人信息)，你可以通过getMediaProjection来获取屏幕捕捉的结果。

在onActivityResult中获取结果

@Override

public void onActivityResult(int requestCode, int resultCode, Intent data) {

MediaProjection mediaProjection = mProjectionManager.getMediaProjection(resultCode, data);

if (mediaProjection == null) {

Log.e(TAG, "media projection is null");

return;

}

File file = new File("xx.mp4"); //录屏生成文件

mediaRecord = new MediaRecordService(displayWidth, displayHeight, 6000000, 1,

mediaProjection, file.getAbsolutePath());

mediaRecord.start();

}

创建MediaRecorder进程

package com.unionpay.service;

import android.hardware.display.DisplayManager;

import android.hardware.display.VirtualDisplay;

import android.media.MediaRecorder;

import android.media.projection.MediaProjection;

import android.util.Log;

public class MediaRecordService extends Thread {

private static final String TAG = "MediaRecordService";

private int mWidth;

private int mHeight;

private int mBitRate;

private int mDpi;

private String mDstPath;

private MediaRecorder mMediaRecorder;

private MediaProjection mMediaProjection;

private static final int FRAME_RATE = 60; // 60 fps

private VirtualDisplay mVirtualDisplay;

public MediaRecordService(int width, int height, int bitrate, int dpi, MediaProjection mp, String dstPath) {

mWidth = width;

mHeight = height;

mBitRate = bitrate;

mDpi = dpi;

mMediaProjection = mp;

mDstPath = dstPath;

}

@Override

public void run() {

try {

initMediaRecorder();

//在mediarecorder.prepare()方法后调用

mVirtualDisplay = mMediaProjection.createVirtualDisplay(TAG + "-display", mWidth, mHeight, mDpi,

DisplayManager.VIRTUAL_DISPLAY_FLAG_PUBLIC, mMediaRecorder.getSurface(), null, null);

Log.i(TAG, "created virtual display: " + mVirtualDisplay);

mMediaRecorder.start();

Log.i(TAG, "mediarecorder start");

} catch (Exception e) {

e.printStackTrace();

}

}

/**

* 初始化MediaRecorder

*

* @return

*/

public void initMediaRecorder() {

mMediaRecorder = new MediaRecorder();

mMediaRecorder.setVideoSource(MediaRecorder.VideoSource.SURFACE);

mMediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);

mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4);

mMediaRecorder.setOutputFile(mDstPath);

mMediaRecorder.setVideoSize(mWidth, mHeight);

mMediaRecorder.setVideoFrameRate(FRAME_RATE);

mMediaRecorder.setVideoEncodingBitRate(mBitRate);

mMediaRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H264);

mMediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AAC);

try {

mMediaRecorder.prepare();

} catch (Exception e) {

e.printStackTrace();

}

Log.i(TAG, "media recorder" + mBitRate + "kps");

}

public void release() {

if (mVirtualDisplay != null) {

mVirtualDisplay.release();

mVirtualDisplay = null;

}

if (mMediaRecorder != null) {

mMediaRecorder.setOnErrorListener(null);

mMediaProjection.stop();

mMediaRecorder.reset();

mMediaRecorder.release();

}

if (mMediaProjection != null) {

mMediaProjection.stop();

mMediaProjection = null;

}

Log.i(TAG, "release");

}

}

MediaCodec与MediaMuxer

MediaCodec提供对音视频压缩编码和解码功能，MediaMuxer可以将音视频混合生成多媒体文件，生成MP4文件。

与MediaRecorder类似，都需要先通过MediaProjectionManager获取录屏权限，在回调中进行屏幕数据处理。

这里创建另一个进程：

package com.unionpay.service;

import java.io.IOException;

import java.nio.ByteBuffer;

import java.util.concurrent.atomic.AtomicBoolean;

import android.hardware.display.DisplayManager;

import android.hardware.display.VirtualDisplay;

import android.media.MediaCodec;

import android.media.MediaCodecInfo;

import android.media.MediaFormat;

import android.media.MediaMuxer;

import android.media.projection.MediaProjection;

import android.util.Log;

import android.view.Surface;

public class ScreenRecordService extends Thread{

private static final String TAG = "ScreenRecordService";

private int mWidth;

private int mHeight;

private int mBitRate;

private int mDpi;

private String mDstPath;

private MediaProjection mMediaProjection;

// parameters for the encoder

private static final String MIME_TYPE = "video/avc"; // H.264 Advanced

// Video Coding

private static final int FRAME_RATE = 30; // 30 fps

private static final int IFRAME_INTERVAL = 10; // 10 seconds between

// I-frames

private static final int TIMEOUT_US = 10000;

private MediaCodec mEncoder;

private Surface mSurface;

private MediaMuxer mMuxer;

private boolean mMuxerStarted = false;

private int mVideoTrackIndex = -1;

private AtomicBoolean mQuit = new AtomicBoolean(false);

private MediaCodec.BufferInfo mBufferInfo = new MediaCodec.BufferInfo();

private VirtualDisplay mVirtualDisplay;

public ScreenRecordService(int width, int height, int bitrate, int dpi, MediaProjection mp, String dstPath) {

super(TAG);

mWidth = width;

mHeight = height;

mBitRate = bitrate;

mDpi = dpi;

mMediaProjection = mp;

mDstPath = dstPath;

}

/**

* stop task

*/

public final void quit() {

mQuit.set(true);

}

@Override

public void run() {

try {

try {

prepareEncoder();

mMuxer = new MediaMuxer(mDstPath, MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4);

} catch (IOException e) {

throw new RuntimeException(e);

}

mVirtualDisplay = mMediaProjection.createVirtualDisplay(TAG + "-display", mWidth, mHeight, mDpi,

DisplayManager.VIRTUAL_DISPLAY_FLAG_PUBLIC, mSurface, null, null);

Log.d(TAG, "created virtual display: " + mVirtualDisplay);

recordVirtualDisplay();

} finally {

release();

}

}

private void recordVirtualDisplay() {

while (!mQuit.get()) {

int index = mEncoder.dequeueOutputBuffer(mBufferInfo, TIMEOUT_US);

// Log.i(TAG, "dequeue output buffer index=" + index);

if (index == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {

// 后续输出格式变化

resetOutputFormat();

} else if (index == MediaCodec.INFO_TRY_AGAIN_LATER) {

// 请求超时

// Log.d(TAG, "retrieving buffers time out!");

try {

// wait 10ms

Thread.sleep(10);

} catch (InterruptedException e) {

}

} else if (index >= 0) {

// 有效输出

if (!mMuxerStarted) {

throw new IllegalStateException("MediaMuxer dose not call addTrack(format) ");

}

encodeToVideoTrack(index);

mEncoder.releaseOutputBuffer(index, false);

}

}

}

/**

* 硬解码获取实时帧数据并写入mp4文件

*

* @param index

*/

private void encodeToVideoTrack(int index) {

// 获取到的实时帧视频数据

ByteBuffer encodedData = mEncoder.getOutputBuffer(index);

if ((mBufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0) {

// The codec config data was pulled out and fed to the muxer

// when we got

// the INFO_OUTPUT_FORMAT_CHANGED status.

// Ignore it.

Log.d(TAG, "ignoring BUFFER_FLAG_CODEC_CONFIG");

mBufferInfo.size = 0;

}

if (mBufferInfo.size == 0) {

Log.d(TAG, "info.size == 0, drop it.");

encodedData = null;

} else {

// Log.d(TAG, "got buffer, info: size=" + mBufferInfo.size + ", presentationTimeUs="

// + mBufferInfo.presentationTimeUs + ", offset=" + mBufferInfo.offset);

}

if (encodedData != null) {

mMuxer.writeSampleData(mVideoTrackIndex, encodedData, mBufferInfo);

}

}

private void resetOutputFormat() {

// should happen before receiving buffers, and should only happen

// once

if (mMuxerStarted) {

throw new IllegalStateException("output format already changed!");

}

MediaFormat newFormat = mEncoder.getOutputFormat();

mVideoTrackIndex = mMuxer.addTrack(newFormat);

mMuxer.start();

mMuxerStarted = true;

Log.i(TAG, "started media muxer, videoIndex=" + mVideoTrackIndex);

}

private void prepareEncoder() throws IOException {

MediaFormat format = MediaFormat.createVideoFormat(MIME_TYPE, mWidth, mHeight);

format.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);

format.setInteger(MediaFormat.KEY_BIT_RATE, mBitRate);

format.setInteger(MediaFormat.KEY_FRAME_RATE, FRAME_RATE);

format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, IFRAME_INTERVAL);

Log.d(TAG, "created video format: " + format);

mEncoder = MediaCodec.createEncoderByType(MIME_TYPE);

mEncoder.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);

mSurface = mEncoder.createInputSurface();

Log.d(TAG, "created input surface: " + mSurface);

mEncoder.start();

}

private void release() {

if (mEncoder != null) {

mEncoder.stop();

mEncoder.release();

mEncoder = null;

}

if (mVirtualDisplay != null) {

mVirtualDisplay.release();

}

if (mMediaProjection != null) {

mMediaProjection.stop();

}

if (mMuxer != null) {

mMuxer.stop();

mMuxer.release();

mMuxer = null;

}

}

}

该进程只实现了视频录制，调用该进程只需修改主进程中的onActivityResult方法。

总结

MediaProjection似乎只有在屏幕发生变化时才传输，因此录屏推流的画面显得不够流畅