使用intent以mp4格式捕獲視頻 - Android

Question

因此，我一直在尋找過去幾天的解決方案，但似乎找不到任何解決方案。起初它似乎很簡單。

我有一個應用程序，使用默認的Android相機應用程序使用意圖捕捉視頻。視頻錄製工作完美，但文件格式爲3gp。我想以mp4格式錄製視頻，但我不想實現自己的mediarecorder等來構建我自己的視頻錄製模塊。

我也搜索了可用的額外參數，我可以傳入意圖的文件格式，但我不能。

是否有任何額外的參數可用於選擇文件格式？

感謝您的幫助！

Answer 1

// Use this code to capture Mp4 video. 

import android.app.Activity; 
import android.content.Context; 
import android.content.Intent; 
import android.hardware.Camera; 
import android.media.CamcorderProfile; 
import android.media.MediaRecorder; 
import android.net.Uri; 
import android.os.Bundle; 
import android.os.Environment; 
import android.os.Handler; 
import android.util.Log; 
import android.view.SurfaceHolder; 
import android.view.SurfaceView; 
import android.view.View; 
import android.widget.Button; 
import android.widget.FrameLayout; 
import android.widget.Toast; 

import java.io.File; 
import java.io.IOException; 
import java.text.SimpleDateFormat; 
import java.util.Date; 
import java.util.Locale; 
import java.util.Timer; 
import java.util.TimerTask; 

public class MainActivity extends Activity{ 
    private static final String TAG = MainActivity.class.getSimpleName(); 


    private Camera myCamera; 
    private CameraSurfaceView cameraSurfaceView; 
    private MediaRecorder mediaRecorder; 

    Button myButton; 
    boolean recording; 
    public Context context; 
    private Uri fileUri; 
    public static final int MEDIA_TYPE_VIDEO = 2; 
    final Handler handler = new Handler(); 


    /** Called when the activity is first created. */ 
    @Override 
    public void onCreate(Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 

     recording = false; 

     setContentView(R.layout.activity_main); 

     //Get Camera for preview 
     myCamera = getCameraInstance(); 
     if(myCamera == null){ 
      Log.w(TAG, "camera not found"); 
      Toast.makeText(context, 
        "Fail to get Camera", 
        Toast.LENGTH_LONG).show(); 
     } 

     cameraSurfaceView = new CameraSurfaceView(this, myCamera); 
     FrameLayout cameraPreview = (FrameLayout)findViewById(R.id.videoview); 
     cameraPreview.addView(cameraSurfaceView); 

     myButton = (Button)findViewById(R.id.mybutton); 
     myButton.setOnClickListener(myButtonOnClickListener); 

    } 

    Button.OnClickListener myButtonOnClickListener 
      = new Button.OnClickListener(){ 

     @Override 
     public void onClick(View v) { 
      // TODO Auto-generated method stub 

      try{ 
       if(recording){ 
        // stop recording and release camera 
        mediaRecorder.stop(); // stop the recording 
        releaseMediaRecorder(); // release the MediaRecorder object 

        //Exit after saved 
        //finish(); 
        myButton.setText("REC"); 
        recording = false; 
        Log.e("file path",fileUri.getPath()); 


       }else{ 

        //Release Camera before MediaRecorder start 
        releaseCamera(); 

        if(!prepareMediaRecorder()){ 
         Toast.makeText(context, 
           "Fail in prepareMediaRecorder()!\n - Ended -", 
           Toast.LENGTH_LONG).show(); 
         finish(); 
        } 

        mediaRecorder.start(); 
        recording = true; 
        myButton.setText("STOP"); 
        Runnable r = new Runnable() { 
         public void run() { 
          Timer timer = new Timer(); 
          timer.schedule(doAsynchronousTask, 0, 10000); 
         } 
        }; 
        handler.postDelayed(r, 10000); 

       } 
      }catch (Exception ex){ 
       ex.printStackTrace(); 
      } 
     } 

    }; 

    private Camera getCameraInstance(){ 

     Camera c = null; 
     try { 
      c = Camera.open(Camera.CameraInfo.CAMERA_FACING_FRONT); // attempt to get a Camera instance 
      c.setDisplayOrientation(90); 

     } 
     catch (Exception e){ 
      // Camera is not available (in use or does not exist) 
     } 
     return c; // returns null if camera is unavailable 
    } 

    TimerTask doAsynchronousTask = new TimerTask() { 
     @Override 
     public void run() { 
      handler.post(new Runnable() { 
       @SuppressWarnings("unchecked") 
       public void run() { 
        try { 
         if(recording ==true) { 
          recording = false; 
          Log.e("file path",fileUri.getPath()); 

          doAsynchronousTask.cancel(); 
         } else{ 
          doAsynchronousTask.cancel(); 
         } 

        } 
        catch (Exception e) { 
         // TODO Auto-generated catch block 
        } 
       } 
      }); 
     } 
    }; 


    private boolean prepareMediaRecorder(){ 
     myCamera = getCameraInstance(); 

     mediaRecorder = new MediaRecorder(); 

     myCamera.unlock(); 
     mediaRecorder.setCamera(myCamera); 

     mediaRecorder.setAudioSource(MediaRecorder.AudioSource.CAMCORDER); 
     mediaRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA); 

     mediaRecorder.setProfile(CamcorderProfile.get(CamcorderProfile.QUALITY_HIGH)); 

     fileUri = getOutputMediaFileUri(MEDIA_TYPE_VIDEO); 
     mediaRecorder.setOutputFile(fileUri.getPath()); 


     //mediaRecorder.setOutputFile("/sdcard/myvideo1.mp4"); 
     mediaRecorder.setMaxDuration(10000); // Set max duration 60 sec. 
     mediaRecorder.setMaxFileSize(50000000); // Set max file size 50M 

     mediaRecorder.setPreviewDisplay(cameraSurfaceView.getHolder().getSurface()); 


     try { 
      mediaRecorder.prepare(); 


     } catch (IllegalStateException e) { 
      releaseMediaRecorder(); 
      return false; 
     } catch (IOException e) { 
      releaseMediaRecorder(); 
      return false; 
     } 
     return true; 

    } 


    @Override 
    protected void onPause() { 
     super.onPause(); 
     releaseMediaRecorder();  // if you are using MediaRecorder, release it first 
     releaseCamera();    // release the camera immediately on pause event 
    } 

    private void releaseMediaRecorder(){ 
     if (mediaRecorder != null) { 
      mediaRecorder.reset(); // clear recorder configuration 
      mediaRecorder.release(); // release the recorder object 
      mediaRecorder = new MediaRecorder(); 
      myCamera.lock();   // lock camera for later use 
     } 
    } 

    private void releaseCamera(){ 
     if (myCamera != null){ 
      myCamera.release();  // release the camera for other applications 
      myCamera = null; 
     } 
    } 

    public class CameraSurfaceView extends SurfaceView implements SurfaceHolder.Callback{ 

     private SurfaceHolder mHolder; 
     private Camera mCamera; 

     public CameraSurfaceView(Context context, Camera camera) { 
      super(context); 
      mCamera = camera; 

      // Install a SurfaceHolder.Callback so we get notified when the 
      // underlying surface is created and destroyed. 
      mHolder = getHolder(); 
      mHolder.addCallback(this); 
      // deprecated setting, but required on Android versions prior to 3.0 
      mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS); 
     } 

     @Override 
     public void surfaceChanged(SurfaceHolder holder, int format, int weight, 
            int height) { 
      // If your preview can change or rotate, take care of those events here. 
      // Make sure to stop the preview before resizing or reformatting it. 

      if (mHolder.getSurface() == null){ 
       // preview surface does not exist 
       return; 
      } 

      // stop preview before making changes 
      try { 
       mCamera.stopPreview(); 
      } catch (Exception e){ 
       // ignore: tried to stop a non-existent preview 
      } 

      // make any resize, rotate or reformatting changes here 

      // start preview with new settings 
      try { 
       mCamera.setPreviewDisplay(mHolder); 
       mCamera.startPreview(); 

      } catch (Exception e){ 
      } 
     } 

     @Override 
     public void surfaceCreated(SurfaceHolder holder) { 
      // TODO Auto-generated method stub 
      // The Surface has been created, now tell the camera where to draw the preview. 
      try { 
       mCamera.setPreviewDisplay(holder); 
       mCamera.startPreview(); 
      } catch (IOException e) { 
      } 
     } 

     @Override 
     public void surfaceDestroyed(SurfaceHolder holder) { 
      // TODO Auto-generated method stub 

     } 
    } 
    public Uri getOutputMediaFileUri(int type) { 
     return Uri.fromFile(getOutputMediaFile(type)); 
    } 

    /** 
    * returning image/video 
    */ 
    private static File getOutputMediaFile(int type) { 

     // External sdcard location 
     File mediaStorageDir = new File(
       Environment 
         .getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES), 
       Config.IMAGE_DIRECTORY_NAME); 

     // Create the storage directory if it does not exist 
     if (!mediaStorageDir.exists()) { 
      if (!mediaStorageDir.mkdirs()) { 
       Log.d(TAG, "Oops! Failed create " 
         + Config.IMAGE_DIRECTORY_NAME + " directory"); 
       return null; 
      } 
     } 

     // Create a media file name 
     String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss", 
       Locale.getDefault()).format(new Date()); 
     File mediaFile; 
     if (type == MEDIA_TYPE_VIDEO) { 
      mediaFile = new File(mediaStorageDir.getPath() + File.separator 
        + "VID_" + timeStamp + ".mp4"); 
     } else { 
      return null; 
     } 

     return mediaFile; 
    } 



}