Android MediaCodec录屏功能实现

Android的MediaCodec类可以用于录屏，下面是一个简单的实现步骤：

1.创建一个MediaCodec对象，用于编码视频数据。

2.创建一个MediaProjection对象，用于获取屏幕上的图像数据。

3.创建一个Surface对象，将MediaCodec和MediaProjection连接起来，以便将屏幕上的图像传递给MediaCodec。

4.创建一个MediaMuxer对象，用于将编码后的视频数据写入到一个MP4文件中。

5.在循环中，使用MediaProjection获取屏幕上的图像数据，通过Surface将图像传递给MediaCodec进行编码，然后将编码后的数据写入到MediaMuxer中。

6.完成录制后，释放所有资源。

下面是一个简单的示例代码，可以将屏幕录制为MP4文件：

public class ScreenRecorder {
    private static final String TAG = "ScreenRecorder";

    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 = 5000000;

    private MediaProjection mMediaProjection;
    private MediaCodec mMediaCodec;
    private MediaMuxer mMediaMuxer;
    private Surface mInputSurface;
    private boolean mIsRecording;

    private int mScreenWidth;
    private int mScreenHeight;
    private int mScreenDensity;

    private int mTrackIndex;
    private long mStartTime;

    public ScreenRecorder(int width, int height, int density) {
        mScreenWidth = width;
        mScreenHeight = height;
        mScreenDensity = density;
    }

    public void startRecording(Context context, Intent data, String outputPath) {
        if (mIsRecording) {
            return;
        }

        mMediaProjection = createMediaProjection(context, data);
        if (mMediaProjection == null) {
            return;
        }

        MediaFormat format = createMediaFormat();
        mMediaCodec = createMediaCodec(format);
        if (mMediaCodec == null) {
            return;
        }

        mMediaMuxer = createMediaMuxer(outputPath);
        if (mMediaMuxer == null) {
            return;
        }

        mMediaCodec.start();
        mIsRecording = true;

        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                record();
            }
        });
        thread.start();
    }

    public void stopRecording() {
        if (!mIsRecording) {
            return;
        }

        mIsRecording = false;

        try {
            mMediaProjection.stop();
        } catch (Exception e) {
            Log.e(TAG, "Failed to stop MediaProjection", e);
        }

        releaseMediaCodec();
        releaseMediaMuxer();
    }

    private MediaProjection createMediaProjection(Context context, Intent data) {
        return ((MediaProjectionManager) context.getSystemService(Context.MEDIA_PROJECTION_SERVICE))
                .getMediaProjection(Activity.RESULT_OK, data);
    }

    private MediaFormat createMediaFormat() {
        int bitrate = BIT_RATE;
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            bitrate = (int) (mScreenWidth * mScreenHeight * FRAME_RATE * 0.1);
        }

        MediaFormat format = MediaFormat.createVideoFormat(MIME_TYPE, mScreenWidth, mScreenHeight);
        format.setInteger(MediaFormat.KEY_BIT_RATE, bitrate);
        format.setInteger(MediaFormat.KEY_FRAME_RATE, FRAME_RATE);
        format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, I_FRAME_INTERVAL);
        format.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
        return format;
    }

    private MediaCodec createMediaCodec(MediaFormat format) {
        try {
            MediaCodec codec = MediaCodec.createEncoderByType(MIME_TYPE);
            codec.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
            mInputSurface = codec.createInputSurface();
            return codec;
        } catch (IOException e) {
            Log.e(TAG, "Failed to create MediaCodec", e);
            return null;
        }
    }

    private MediaMuxer createMediaMuxer(String outputPath) {
        try {
            return new MediaMuxer(outputPath, MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4);
        } catch (IOException e) {
            Log.e(TAG, "Failed to create MediaMuxer", e);
            return null;
        }
    }

    private void record() {
        mStartTime = System.currentTimeMillis();
        MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
        while (mIsRecording) {
            int index = mMediaCodec.dequeueOutputBuffer(bufferInfo, 10000);
            if (index == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
                mTrackIndex = mMediaMuxer.addTrack(mMediaCodec.getOutputFormat());
                mMediaMuxer.start();
            } else if (index >= 0) {
                ByteBuffer outputBuffer = mMediaCodec.getOutputBuffer(index);
                if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0) {
                    bufferInfo.size = 0;
                }
                if (bufferInfo.size != 0) {
                    bufferInfo.presentationTimeUs = System.currentTimeMillis() - mStartTime;
                    outputBuffer.position(bufferInfo.offset);
                    outputBuffer.limit(bufferInfo.offset + bufferInfo.size);
                    mMediaMuxer.writeSampleData(mTrackIndex, outputBuffer, bufferInfo);
                }
                mMediaCodec.releaseOutputBuffer(index, false);
            }
        }
    }

    private void releaseMediaCodec() {
        try {
            if (mMediaCodec != null) {
                mMediaCodec.signalEndOfInputStream();
                mMediaCodec.stop();
                mMediaCodec.release();
            }
        } catch (Exception e) {
            Log.e(TAG, "Failed to release MediaCodec", e);
        }
        if (mInputSurface != null) {
            mInputSurface.release();
        }
    }

    private void releaseMediaMuxer() {
        try {
            if (mMediaMuxer != null) {
                mMediaMuxer.stop();
                mMediaMuxer.release();
            }
        } catch (Exception e) {
            Log.e(TAG, "Failed to release MediaMuxer", e);
        }
    }
}

在Activity中调用startRecording()方法开始录制，stopRecording()方法停止录制。在AndroidManifest.xml中添加下面的权限：

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.RECORD_AUDIO" />

同时需要在代码中动态申请录音和存储权限。