我录屏的方式是分别录制音频和视频，最后合并成mp4格式，比较麻烦，因为网上完整的教程比较少，所以我打算写一个完整版的，照着我的代码写完之后，至少是能够实现功能的，而不是简单的介绍下用法。

1既然是录制视频，我们应该有一个按钮控制开始和结束。

2在录制之前，需要先判断一下Android系统的版本是否大于5.0，并且动态申请一下权限（读写，录音，照相机），这一步可以在点开始按钮的时候执行

  1. 　　　　if (ContextCompat.checkSelfPermission(context, Manifest.permission.WRITE_EXTERNAL_STORAGE)
  2.                 != PackageManager.PERMISSION_GRANTED) {
  3.             ActivityCompat.requestPermissions();
  4.         }
  5.         if (ContextCompat.checkSelfPermission(context, Manifest.permission.RECORD_AUDIO)
  6.                 != PackageManager.PERMISSION_GRANTED) {
  7.             ActivityCompat.requestPermissions();
  8.         }
  9.         if (ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA)
  10.                 != PackageManager.PERMISSION_GRANTED) {
  11.             ActivityCompat.requestPermissions();
  12.         }
  13.  
  14.         Intent intent = null;
  15.         if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
  16.             intent = mediaProjectionManager.createScreenCaptureIntent();
  17.             startActivityForResult(intent, 101);//正常情况是要执行到这里的,作用是申请捕捉屏幕
  18.         } else {
  19.             ShowUtil.showToast(context, "Android版本太低，无法使用该功能");
  20.         }

3定义MediaProjection和MediaProjectionManager等一些其他必要的变量

  1. 　　boolean isrun = false;//用来标记录屏的状态private MediaProjectionManager mediaProjectionManager;
  2.     private MediaProjection mediaProjection;//录制视频的工具private int width, height, dpi;//屏幕宽高和dpi，后面会用到
  3.     private ScreenRecorder screenRecorder;//这个是自己写的录视频的工具类，下文会放完整的代码
  4.     Thread thread;//录视频要放在线程里去执行
  1. 在onCreat里写好实例化
  1. mediaProjectionManager = (MediaProjectionManager) context.getSystemService(MEDIA_PROJECTION_SERVICE);
  1. WindowManager manager = this.getWindowManager();DisplayMetrics outMetrics = new DisplayMetrics();manager.getDefaultDisplay().getMetrics(outMetrics);width = outMetrics.widthPixels;height = outMetrics.heightPixels;dpi = outMetrics.densityDpi;

4我们在onActivityResult回调方法中，来处理返回的事件

  1. @Override
  2.     protected void onActivityResult(int requestCode, int resultCode, Intent data) {
  3.         ) {
  4.             Toast.makeText(context, "缺少读写权限", Toast.LENGTH_SHORT).show();
  5.             return;
  6.         }
  7.         ) {
  8.             Toast.makeText(context, "缺少录音权限", Toast.LENGTH_SHORT).show();
  9.             return;
  10.         }
  11.         ) {
  12.             Toast.makeText(context, "缺少相机权限", Toast.LENGTH_SHORT).show();
  13.             return;
  14.         }
  15.         if (requestCode != 101) {
  16.             Log.e("HandDrawActivity", "error requestCode =" + requestCode);
  17.         }
  18.         if (resultCode != RESULT_OK) {
  19.             Toast.makeText(context, "捕捉屏幕被禁止", Toast.LENGTH_SHORT).show();
  20.             return;
  21.         }
  22.  
  23.         mediaProjection = mediaProjectionManager.getMediaProjection(resultCode, data);
  24.         if (mediaProjection != null) {
  25.             screenRecorder = new ScreenRecorder(width, height, mediaProjection, dpi);
  26.         }
  27.         thread = new Thread() {
  28.             @Override
  29.             public void run() {
  30.                 screenRecorder.startRecorder();//跟ScreenRecorder有关的下文再说，总之这句话的意思就是开始录屏的意思
  31.             }
  32.         };
  33.         thread.start();
  34.         binding.startPlayer.setText("停止");//开始和停止我用的同一个按钮，所以开始录屏之后把按钮文字改一下
  35.         isrun = true;//录屏状态改成真
  36.  
  37.     }

5先放上ScreenRecorder代码，只想要结果的朋友呢，直接把类粘贴走，把报错的地方改一改（在我自己的项目里可是不报错的）,就实现了录制屏幕的功能了，还想看看的，可以往下看看

  1. import android.hardware.display.DisplayManager;
  2. import android.media.MediaCodec;
  3. import android.media.MediaCodecInfo;
  4. import android.media.MediaFormat;
  5. import android.media.MediaMuxer;
  6. import android.media.MediaRecorder;
  7. import android.media.projection.MediaProjection;
  8. import android.os.Build;
  9. import android.os.Environment;
  10. import android.text.TextUtils;
  11. import android.util.Log;
  12. import android.view.Surface;
  13. import com.coremedia.iso.boxes.Container;
  14. import com.googlecode.mp4parser.authoring.Movie;
  15. import com.googlecode.mp4parser.authoring.Track;
  16. import com.googlecode.mp4parser.authoring.builder.DefaultMp4Builder;
  17. import com.googlecode.mp4parser.authoring.container.mp4.MovieCreator;
  18. import com.googlecode.mp4parser.authoring.tracks.AppendTrack;
  19.  
  20. import java.io.File;
  21. import java.io.FileNotFoundException;
  22. import java.io.IOException;
  23. import java.io.RandomAccessFile;
  24. import java.nio.ByteBuffer;
  25. import java.nio.channels.FileChannel;
  26. import java.util.ArrayList;
  27. import java.util.LinkedList;
  28. import java.util.List;
  29.  
  30. public class ScreenRecorder {
  31.  
  32.     private int mWidth, mHeight, mDensty;
  33.     private MediaProjection mediaProjection;
  34.     private MediaCodec.BufferInfo mBufferInfo;
  35.     private MediaCodec mEncorder;
  36.     private Surface mInputSurface;
  37.     private MediaMuxer mMuxer;
  38.     private boolean isQuit = false;
  39.     private boolean mMuxerStarted = false;
  40.     private int mTrackIndex;
  41.     private String path = Environment.getExternalStorageDirectory().getAbsolutePath() + "/cache";
  42.  
  43.     private MediaRecorder mediaRecorder;
  44.  
  45.     public ScreenRecorder(int mWidth, int mHeight, MediaProjection mediaProjection, int mDensty) {
  46.         this.mWidth = mWidth;
  47.         this.mHeight = mHeight;
  48.         this.mediaProjection = mediaProjection;
  49.         this.mDensty = mDensty;
  50.  
  51.         File file = new File(path);
  52.         if (!file.exists()) {
  53.             file.mkdirs();
  54.         }
  55.     }
  56.  
  57.     public void startRecorder() {
  58.         prepareRecorder();
  59.         startLuYin();
  60.         startRecording();
  61.     }
  62.  
  63.     public void stop() {
  64.         isQuit = true;
  65.         releaseEncorders(1);
  66.         List<String> filePath = new ArrayList<>();
  67.         filePath.add(path + "/APlanyinpin.amr");
  68.         filePath.add(path + "/APlanshipin.mp4");
  69.         joinVideo(filePath, path);
  70.     }
  71.  
  72.     public void destory() {
  73.         releaseEncorders(0);
  74.     }
  75.  
  76.     private void startLuYin() {
  77.         File file = new File(path, "APlanyinpin.amr");
  78.         mediaRecorder = new MediaRecorder();
  79.         mediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
  80.         mediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.DEFAULT);
  81.         mediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.DEFAULT);
  82.         mediaRecorder.setOutputFile(file.getAbsolutePath());
  83.  
  84.         try {
  85.             mediaRecorder.prepare();
  86.             mediaRecorder.start();
  87.             Log.e("HandDrawActivity", "已经开始录音");
  88.         } catch (IOException e) {
  89.             e.printStackTrace();
  90.         }
  91.     }
  92.  
  93.     private void prepareRecorder() {
  94.         mBufferInfo = new MediaCodec.BufferInfo();  //元数据，描述bytebuffer的数据，尺寸，偏移
  95.         //创建格式化对象 MIMI_TYPE 传入的 video/avc 是H264编码格式
  96.         MediaFormat format = MediaFormat.createVideoFormat("video/avc", mWidth, mHeight);
  97.         int frameRate = 45;
  98.         format.setInteger(MediaFormat.KEY_BIT_RATE, 3000000);
  99.         format.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
  100.         format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 10);
  101.         format.setInteger(MediaFormat.KEY_FRAME_RATE, frameRate);
  102.         format.setInteger(MediaFormat.KEY_CHANNEL_COUNT, 1);
  103.         format.setInteger(MediaFormat.KEY_CAPTURE_RATE, frameRate);
  104.         format.setInteger(MediaFormat.KEY_REPEAT_PREVIOUS_FRAME_AFTER, 1000000 / frameRate);
  105.  
  106.         try {
  107.             mEncorder = MediaCodec.createEncoderByType("video/avc");
  108.             mEncorder.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
  109.             mInputSurface = mEncorder.createInputSurface();
  110.             mEncorder.start();
  111.         } catch (IOException e) {
  112.             e.printStackTrace();
  113.             releaseEncorders(0);
  114.         }
  115.     }
  116.  
  117.     private void startRecording() {
  118.         File saveFile = new File(path, "APlanshipin.mp4");
  119.         try {
  120.             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
  121.                 mMuxer = new MediaMuxer(saveFile.getAbsolutePath(), MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4);
  122.                 mediaProjection.createVirtualDisplay("SCREENRECORDER", mWidth, mHeight, mDensty, DisplayManager.VIRTUAL_DISPLAY_FLAG_PUBLIC,
  123.                         mInputSurface, null, null);
  124.                 drainEncoder();
  125.             }
  126.         } catch (Exception e) {
  127.             e.printStackTrace();
  128.         }
  129.  
  130.     }
  131.  
  132.     private void drainEncoder() {
  133.         while (!isQuit) {
  134.             Log.e("TAG", "drain.....");
  135.             int bufferIndex = mEncorder.dequeueOutputBuffer(mBufferInfo, 0);
  136.             if (bufferIndex == MediaCodec.INFO_TRY_AGAIN_LATER) {
  137.                 try {
  138.                     Thread.sleep(10);
  139.                 } catch (InterruptedException e) {
  140.                     e.printStackTrace();
  141.                 }
  142.             }
  143.             if (bufferIndex == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
  144.                 mTrackIndex = mMuxer.addTrack(mEncorder.getOutputFormat());
  145.                 if (!mMuxerStarted && mTrackIndex >= 0) {
  146.                     mMuxer.start();
  147.                     mMuxerStarted = true;
  148.  
  149.                     Log.e("HandDrawActivity", "已经开始录屏");
  150.                 }
  151.             }
  152.             if (bufferIndex >= 0) {
  153.                 Log.e("TAG", "drain...write..");
  154.                 ByteBuffer bufferData = mEncorder.getOutputBuffer(bufferIndex);
  155.                 if ((mBufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0) {
  156.                     mBufferInfo.size = 0;
  157.                 }
  158.                 if (mBufferInfo.size != 0) {
  159.                     if (mMuxerStarted) {
  160.                         bufferData.position(mBufferInfo.offset);
  161.                         bufferData.limit(mBufferInfo.offset + mBufferInfo.size);
  162.                         mMuxer.writeSampleData(mTrackIndex, bufferData, mBufferInfo);
  163.                     }
  164.                 }
  165.                 mEncorder.releaseOutputBuffer(bufferIndex, false);
  166.                 if ((mBufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
  167.                     break;
  168.                 }
  169.             }
  170.         }
  171.         Log.e("HandDrawActivity", "已经结束录屏");
  172.  
  173.     }
  174.  
  175.     private void releaseEncorders(int i) {
  176.         if (mediaProjection != null) {
  177.             mediaProjection.stop();
  178.         }
  179.         mBufferInfo = null;
  180.         if (mEncorder != null) {
  181.             mEncorder.stop();
  182.         }
  183.         mInputSurface = null;
  184.         if (mMuxer != null && i == 1) {
  185.             mMuxer.stop();
  186.         }
  187.         if (mediaRecorder != null) {
  188.             mediaRecorder.stop();
  189.             mediaRecorder.reset();
  190.             mediaRecorder.release();
  191.         }
  192.  
  193.     }
  194.  
  195.     private boolean joinVideo(List<String> filePaths, String resultPath) {
  196.         Log.e("HandDrawActivity", "准备合成中");
  197.         boolean result = false;
  198.  
  199.         if (filePaths == null || filePaths.size() <= 0 || TextUtils.isEmpty(resultPath)) {
  200.             throw new IllegalArgumentException();
  201.         }
  202.  
  203.         if (filePaths.size() == 1) { // 只有一个视频片段，不需要合并
  204.             return true;
  205.         }
  206.  
  207.         try {
  208.             Movie[] inMovies = new Movie[filePaths.size()];
  209.             for (int i = 0; i < filePaths.size(); i++) {
  210.                 Log.e("HandDrawActivity", "filePaths=" + filePaths.get(i));
  211.                 File f = new File(filePaths.get(i));
  212.                 if (f.exists()) {
  213.                     inMovies[i] = MovieCreator.build(filePaths.get(i));
  214.                 }
  215.             }
  216.  
  217.             // 分别取出音轨和视频
  218.             List<Track> videoTracks = new LinkedList<>();
  219.             List<Track> audioTracks = new LinkedList<>();
  220.             for (Movie m : inMovies) {
  221.                 for (Track t : m.getTracks()) {
  222.                     if (t.getHandler().equals("soun")) {
  223.                         audioTracks.add(t);
  224.                     }
  225.                     if (t.getHandler().equals("vide")) {
  226.                         videoTracks.add(t);
  227.                     }
  228.                 }
  229.             }
  230.  
  231.             // 合并到最终的视频文件
  232.             Movie outMovie = new Movie();
  233.  
  234.             if (audioTracks.size() > 0) {
  235.                 outMovie.addTrack(new AppendTrack(audioTracks.toArray(new Track[audioTracks.size()])));
  236.             }
  237.             if (videoTracks.size() > 0) {
  238.                 outMovie.addTrack(new AppendTrack(videoTracks.toArray(new Track[videoTracks.size()])));
  239.             }
  240.  
  241.             Container mp4file = new DefaultMp4Builder().build(outMovie);
  242.  
  243.             // 将文件输出
  244.             File resultFile = new File(resultPath, "APlanTeacherAnswer.mp4");
  245.             if (resultFile.exists() && resultFile.isFile()) {
  246.                 resultFile.delete();
  247.             }
  248.             FileChannel fc = new RandomAccessFile(resultFile, "rw").getChannel();
  249.             mp4file.writeContainer(fc);
  250.             fc.close();
  251.             Log.e("HandDrawActivity", "合成完毕");
  252.             // 合成完成后把原片段文件删除
  253.             for (String filePath : filePaths) {
  254.                 File file = new File(filePath);
  255.                 file.delete();
  256.             }
  257.             result = true;
  258.  
  259.             HandDrawActivity.sendVideo();
  260.  
  261.         } catch (FileNotFoundException e) {
  262.             e.printStackTrace();
  263.         } catch (Exception e) {
  264.             e.printStackTrace();
  265.         }
  266.         return result;
  267.  
  268.     }
  269. }

6从startRecorder方法说起

  1. public void startRecorder() {
  2.         prepareRecorder();//录视频前的准备
  3.         startLuYin();//直接录音频(不用准备)
  4.         startRecording();//录视频
  5.     }
  1. 录音的方法private void startLuYin() {
  2.         File file = new File(path, "APlanyinpin.amr");
  3.         mediaRecorder = new MediaRecorder();
  4.         mediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);//声音来源，麦克
  5.         mediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.DEFAULT);//音频格式，默认，其实就是上面定义好的amr了，除此之外还有mp4
  6.         mediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.DEFAULT);//编码格式，问题是我不知道编码格式对什么有影响，是音质高低还是文件大小还是解析快慢，等我有时间去专门研究一下
  7.         mediaRecorder.setOutputFile(file.getAbsolutePath());
  8.  
  9.         try {
  10.             mediaRecorder.prepare();
  11.             mediaRecorder.start();
  12.             Log.e("HandDrawActivity", "已经开始录音");
  13.         } catch (IOException e) {
  14.             e.printStackTrace();
  15.         }
  16.     }
  1. //录视频前的准备工作private void prepareRecorder() {
  2.         mBufferInfo = new MediaCodec.BufferInfo();  //元数据，描述bytebuffer的数据，尺寸，偏移
  3.         //创建格式化对象 MIMI_TYPE 传入的 video/avc 是H264编码格式
  4.         MediaFormat format = MediaFormat.createVideoFormat("video/avc", mWidth, mHeight);
  5.         int frameRate = 45;
  6.         format.setInteger(MediaFormat.KEY_BIT_RATE, 3000000);
  7.         format.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
  8.         format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 10);
  9.         format.setInteger(MediaFormat.KEY_FRAME_RATE, frameRate);
  10.         format.setInteger(MediaFormat.KEY_CHANNEL_COUNT, 1);
  11.         format.setInteger(MediaFormat.KEY_CAPTURE_RATE, frameRate);
  12.         format.setInteger(MediaFormat.KEY_REPEAT_PREVIOUS_FRAME_AFTER, 1000000 / frameRate);//编码器的设置，具体是设置的啥我也不太清楚，但是网上查一查都是这么写的！！！
  13.  
  14.         try {
  15.             mEncorder = MediaCodec.createEncoderByType("video/avc");
  16.             mEncorder.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
  17.             mInputSurface = mEncorder.createInputSurface();
  18.             mEncorder.start();//让编码器先跑起来
  19.         } catch (IOException e) {
  20.             e.printStackTrace();
  21.             releaseEncorders(0);
  22.         }
  23.     }
  1. 这里也是准备工作private void startRecording() {
  2.         File saveFile = new File(path, "APlanshipin.mp4");
  3.         try {
  4.             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
  5.                 mMuxer = new MediaMuxer(saveFile.getAbsolutePath(), MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4);//百度一下MediaMuxer,讲的很详细的
  6.                 mediaProjection.createVirtualDisplay("SCREENRECORDER", mWidth, mHeight, mDensty, DisplayManager.VIRTUAL_DISPLAY_FLAG_PUBLIC,
  7.                         mInputSurface, null, null);
  8.                 drainEncoder();
  9.             }
  10.         } catch (Exception e) {
  11.             e.printStackTrace();
  12.         }
  13.  
  14.     }
  1. 这个就是开始写视频文件了private void drainEncoder() {
  2.         while (!isQuit) {
  3.             Log.e("TAG", "drain.....");
  4.             int bufferIndex = mEncorder.dequeueOutputBuffer(mBufferInfo, 0);
  5.             if (bufferIndex == MediaCodec.INFO_TRY_AGAIN_LATER) {
  6.                 try {
  7.                     Thread.sleep(10);
  8.                 } catch (InterruptedException e) {
  9.                     e.printStackTrace();
  10.                 }
  11.             }
  12.             if (bufferIndex == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
  13.                 mTrackIndex = mMuxer.addTrack(mEncorder.getOutputFormat());
  14.                 if (!mMuxerStarted && mTrackIndex >= 0) {
  15.                     mMuxer.start();
  16.                     mMuxerStarted = true;
  17.  
  18.                     Log.e("HandDrawActivity", "已经开始录屏");
  19.                 }
  20.             }
  21.             if (bufferIndex >= 0) {
  22.                 Log.e("TAG", "drain...write..");
  23.                 ByteBuffer bufferData = mEncorder.getOutputBuffer(bufferIndex);
  24.                 if ((mBufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0) {
  25.                     mBufferInfo.size = 0;
  26.                 }
  27.                 if (mBufferInfo.size != 0) {
  28.                     if (mMuxerStarted) {
  29.                         bufferData.position(mBufferInfo.offset);
  30.                         bufferData.limit(mBufferInfo.offset + mBufferInfo.size);
  31.                         mMuxer.writeSampleData(mTrackIndex, bufferData, mBufferInfo);
  32.                     }
  33.                 }
  34.                 mEncorder.releaseOutputBuffer(bufferIndex, false);
  35.                 if ((mBufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
  36.                     break;
  37.                 }
  38.             }
  39.         }
  40.         Log.e("HandDrawActivity", "已经结束录屏");
  41.  
  42.     }
  1. 这个就是把录好的音频和视频合并成mp4的方法了，也是点击停止录屏的时候用到的private boolean joinVideo(List<String> filePaths, String resultPath) {
  2.         Log.e("HandDrawActivity", "准备合成中");
  3.         boolean result = false;
  4.  
  5.         if (filePaths == null || filePaths.size() <= 0 || TextUtils.isEmpty(resultPath)) {
  6.             throw new IllegalArgumentException();
  7.         }
  8.  
  9.         if (filePaths.size() == 1) { // 只有一个视频片段，不需要合并
  10.             return true;
  11.         }
  12.  
  13.         try {
  14.             Movie[] inMovies = new Movie[filePaths.size()];
  15.             for (int i = 0; i < filePaths.size(); i++) {
  16.                 Log.e("HandDrawActivity", "filePaths=" + filePaths.get(i));
  17.                 File f = new File(filePaths.get(i));
  18.                 if (f.exists()) {
  19.                     inMovies[i] = MovieCreator.build(filePaths.get(i));
  20.                 }
  21.             }
  22.  
  23.             // 分别取出音轨和视频
  24.             List<Track> videoTracks = new LinkedList<>();
  25.             List<Track> audioTracks = new LinkedList<>();
  26.             for (Movie m : inMovies) {
  27.                 for (Track t : m.getTracks()) {
  28.                     if (t.getHandler().equals("soun")) {
  29.                         audioTracks.add(t);
  30.                     }
  31.                     if (t.getHandler().equals("vide")) {
  32.                         videoTracks.add(t);
  33.                     }
  34.                 }
  35.             }
  36.  
  37.             // 合并到最终的视频文件
  38.             Movie outMovie = new Movie();
  39.  
  40.             if (audioTracks.size() > 0) {
  41.                 outMovie.addTrack(new AppendTrack(audioTracks.toArray(new Track[audioTracks.size()])));
  42.             }
  43.             if (videoTracks.size() > 0) {
  44.                 outMovie.addTrack(new AppendTrack(videoTracks.toArray(new Track[videoTracks.size()])));
  45.             }
  46.  
  47.             Container mp4file = new DefaultMp4Builder().build(outMovie);
  48.  
  49.             // 将文件输出
  50.             File resultFile = new File(resultPath, "APlanTeacherAnswer.mp4");
  51.             if (resultFile.exists() && resultFile.isFile()) {
  52.                 resultFile.delete();
  53.             }
  54.             FileChannel fc = new RandomAccessFile(resultFile, "rw").getChannel();
  55.             mp4file.writeContainer(fc);
  56.             fc.close();
  57.             Log.e("HandDrawActivity", "合成完毕");
  58.             // 合成完成后把原片段文件删除
  59.             for (String filePath : filePaths) {
  60.                 File file = new File(filePath);
  61.                 file.delete();
  62.             }
  63.             result = true;
  64.  
  65.             HandDrawActivity.sendVideo();
  66.  
  67.         } catch (FileNotFoundException e) {
  68.             e.printStackTrace();
  69.         } catch (Exception e) {
  70.             e.printStackTrace();
  71.         }
  72.         return result;
  73.  
  74.     }
  1. 这个就是结束的时候了，该清空的清空，该注销的注销， i是用来判断录没录的，有可能刚进入这个页面都没录过，直接就返回到别的页面了，那就有可能空指针异常，因为有些变量都没初始化，所以用i判断一下，也可以自己写别的方法判端private void releaseEncorders(int i) {
  2.         if (mediaProjection != null) {
  3.             mediaProjection.stop();
  4.         }
  5.         mBufferInfo = null;
  6.         if (mEncorder != null) {
  7.             mEncorder.stop();
  8.         }
  9.         mInputSurface = null;
  10.         if (mMuxer != null && i == 1) {
  11.             mMuxer.stop();
  12.         }
  13.         if (mediaRecorder != null) {
  14.             mediaRecorder.stop();
  15.             mediaRecorder.reset();
  16.             mediaRecorder.release();
  17.         }
  18.  
  19.     }

7部分代码也是我从网上扒的，但是网上的代码就没怎么见过比较完整的版本的，我上面写的都是经过我自己测试绝对没问题的而且代码也没什么遗漏的，要是发现有遗漏的代码我后续再补上。

Android5.0以上版本录屏实现的更多相关文章

  1. Android5.0免Root截屏,录屏

    http://blog.csdn.net/wds1181977/article/details/52174840 MediaProjection介绍 MediaProjection可以用来捕捉屏幕,具 ...

  2. Android5.0以后版本把应用移动到SD或者TF卡的方法

    由于手机内存较小,才8G,用的时间一久,内部存储就满了,天天删垃圾,WIFI还老断线,终于忍无可忍了,决定把应用移动到SD卡,实践下来,只有少部分App默认支持移动到SD卡,大部分程序不支持只能装在内 ...

  3. 友情提醒:欲开发android5.0以上应用，请全部更新开发工具至最新

    周末帮人完成一个项目,android5.0以上版本,谁知道被开发工具折腾的死去活来.我的开发环境是adt-bundle-windows-x86-20140702.zip版本,也是目前能找到的adt-b ...

  4. Fundebug录屏插件更新至0.6.0

    摘要: 录屏插件的性能进一步优化,传输的数据体积大幅度减少. 录屏功能介绍 Fundebug提供专业的异常监控服务,当线上应用出现 BUG 的时候,我们可以第一时间报警,帮助开发者及时发现 BUG,提 ...

  5. Fundebug录屏插件更新至0.5.0，新增domain参数

    摘要: 通过配置domain来保证"视频"的正确录制 录屏功能介绍 Fundebug提供专业的异常监控服务,当线上应用出现 BUG 的时候,我们可以第一时间报警,帮助开发者及时发现 ...

  6. Fundebug录屏插件更新至0.4.0，修复BUG，优化性能

    摘要: 录屏功能更加强大,欢迎免费试用! 关于Fundebug录屏功能 Fundebug是专业的程序BUG监控服务,当线上应用出现BUG的时候,我们可以第一时间报警,帮助开发者及时发现BUG,提高De ...

  7. Android Material Design Ripple Effect在Android5.0（SDK=21）以下Android版本崩溃问题解决

    Android Material Design Ripple Effect在Android5.0(SDK=21)以下Android版本崩溃问题解决 附录1的Android Ripple Effect水 ...

  8. 华为联运游戏审核驳回：在未安装或需更新HMS Core的手机上，提示安装，点击取消后，游戏卡屏（集成的6.1.0.301版本游戏SDK）

    问题描述 更新游戏SDK到6.1.0.301版本之后,游戏包被审核驳回:在未安装或需更新华为移动服务版本(HMS Core)的手机上,提示安装华为移动服务(HMS Core),点击取消,游戏卡屏.修改 ...

  9. 手游录屏直播技术详解 | 直播 SDK 性能优化实践

    在上期<直播推流端弱网优化策略 >中,我们介绍了直播推流端是如何优化的.本期,将介绍手游直播中录屏的实现方式. 直播经过一年左右的快速发展,衍生出越来越丰富的业务形式,也覆盖越来越广的应用 ...

随机推荐

  1. JSON标准格式

    标准JSON的合法符号:{(左大括号)  }(右大括号)  "(双引号)  :(冒号)  ,(逗号)  [(左中括号)  ](右中括号) JSON字符串:特殊字符可在字符前面加 \ 或使用 ...

  2. POJ2217(最长公共子串)

    Secretary Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 992   Accepted: 408 Descripti ...

  3. 注册页面Page的内置属性以及函数 路由 模块化

    Page.prototype.route  route字段可以获取到当前页面的路径 Page.prototype.setData() setData函数用于将数据从逻辑层发送到视图层,同时改变对应的t ...

  4. docker容器firewalld端口转发规则

    docker容器firewalld端口转发规则 1.配置firewalld端口转发,要先打开端口转发,则需要先 #firewall-cmd --zone=public --add-maspuerade ...

  5. [poj2778]DNA Sequence(AC自动机+矩阵快速幂)

    题意:有m种DNA序列是有疾病的,问有多少种长度为n的DNA序列不包含任何一种有疾病的DNA序列.(仅含A,T,C,G四个字符) 解题关键:AC自动机,实际上就是一个状态转移图,注意能少取模就少取模, ...

  6. Git（一）

    Git概念 Git其实是一种分布式版本控制系统,与CVS,Subversion等集中化的版本控制系统相对.它主要有几个特点: • 速度快 • 简单的设计 • 对非线性开发模式的强力支持(允许上千个并行 ...

  7. MFC CMap整理

    映射表类(CMap)是MFC集合类中的一个模板类,也称作为“字典”.CMap是把唯一关键码映射到值的字典收集类,使用CMap可以构造一个关键字和元素值映射的集合类.一旦在映射中插入了一个关键码值对(元 ...

  8. 51nod1770(xjb)

    题目链接:http://www.51nod.com/onlineJudge/questionCode.html#!problemId=1770 题意:中文题诶- 思路:随便写几个例子不难发现乘机中间部 ...

  9. scrapy.Request使用meta传递数据，以及deepcopy的使用

    scrapy.Request(url[,callback,method="GET",headers,body,cookies,meta,dont_filter=False])   ...

  10. 远程kafka通信实例，各种bug解决----虚拟机+本地电脑

    为了实现远程kafka通信,我可谓是呕心沥血.期间各种bug各种调,太煎熬了 (T.T) 介绍: 我用一台虚拟机作为远程消息的发送方,用本地电脑主机作为消息的接收方 虚拟机:安装java,kafka, ...