调用android系统相机拍照并保存

叁歲伎倆 2022-08-08 05:15 156阅读 0赞

很好的一篇文章，仅供学习，转载地址：http://www.cnblogs.com/mengdd/archive/2013/03/31/2991932.html

通过Intent直接调用系统相机

　　直接调用系统的相机应用，只需要在Intent对象中传入相应的参数即可，总体来说需要以下三步：

　　1. Compose a Camera Intent

　　MediaStore.ACTION_IMAGE_CAPTURE 拍照；

　　MediaStore.ACTION_VIDEO_CAPTURE录像。

　　2. Start the Camera Intent

　　使用startActivityForResult()方法，并传入上面的intent对象。

　　之后，系统自带的相机应用就会启动，用户就可以用它来拍照或者录像。

　　3. Receive the Intent Result

　　用onActivityResult()接收传回的图像，当用户拍完照片或者录像，或者取消后，系统都会调用这个函数。

关于接收图像

　　如果不设置接收图像的部分，拍照完毕后将会返回到原来的activity，相片会自动存储在拍照应用的默认存储位置。

　　为了接收图像，需要做以下几个工作：

　　1.指定图像的存储位置，一般图像都是存储在外部存储设备，即SD卡上。

　　你可以考虑的标准的位置有以下两个：

　　Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES)

　　这个方法返回图像和视频的标准共享位置，别的应用也可以访问，如果你的应用被卸载了，这个路径下的文件是会保留的。

　　为了区分，你可以在这个路径下为你的应用创建一个子文件夹。

　　Context.getExternalFilesDir(Environment.DIRECTORY_PICTURES)

　　这个方法返回的路径是和你的应用相关的一个存储图像和视频的方法。

　　如果应用被卸载，这个路径下的东西全都会被删除。

　　这个路径没有什么安全性限制，别的应用也可以自由访问里面的文件。

　　2.为了接收intent的结果，需要覆写activity中的 onActivityResult() 方法。

　　前面说过，可以不设置相机返回的图像结果的操作，此时在startActivityForResult()中不需要给intent传入额外的数据，这样在onActivityResult()回调时，返回的Intent data不为null，照片存在系统默认的图片存储路径下。

　　但是如果想得到这个图像，你必须制定要存储的目标File，并且把它作为URI传给启动的intent，使用MediaStore.EXTRA_OUTPUT作为关键字。

　　这样的话，拍摄出来的照片将会存在这个特殊指定的地方，此时没有thumbnail会被返回给activity的回调函数，所以接收到的Intent data为null。

程序实例

　　附上程序代码，其中视频存储的返回结果部分没有写代码，视频拍摄后会存入系统应用的默认位置。

  1. 系统自带相机应用测试
  3. package com.example.hellocamera;
  5. import java.io.File;
  6. import java.text.SimpleDateFormat;
  7. import java.util.Date;
  9. import android.app.Activity;
  10. import android.content.Intent;
  11. import android.graphics.Bitmap;
  12. import android.graphics.BitmapFactory;
  13. import android.net.Uri;
  14. import android.os.Bundle;
  15. import android.os.Environment;
  16. import android.provider.MediaStore;
  17. import android.util.Log;
  18. import android.view.View;
  19. import android.view.View.OnClickListener;
  20. import android.widget.Button;
  21. import android.widget.ImageView;
  22. import android.widget.Toast;
  24. public class HelloCameraActivity extends Activity
  25. {
  26.     private static final String LOG_TAG = "HelloCamera";
  27.     private static final int CAPTURE_IMAGE_ACTIVITY_REQUEST_CODE = 100;
  28.     private static final int CAPTURE_VIDEO_ACTIVITY_REQUEST_CODE = 200;
  30.     private Button takePicBtn = null;
  31.     private Button takeVideoBtn = null;
  33.     private ImageView imageView = null;
  35.     private Uri fileUri;
  37.     @Override
  38.     public void onCreate(Bundle savedInstanceState)
  39.     {
  40.         Log.d(LOG_TAG, "onCreate");
  41.         super.onCreate(savedInstanceState);
  42.         setContentView(R.layout.activity_hello_camera);
  44.         takePicBtn = (Button) findViewById(R.id.buttonPicture);
  45.         takePicBtn.setOnClickListener(takePiClickListener);
  47.         takeVideoBtn = (Button) findViewById(R.id.buttonVideo);
  48.         takeVideoBtn.setOnClickListener(takeVideoClickListener);
  50.         imageView = (ImageView) findViewById(R.id.imageView1);
  52.     }
  54.     private final OnClickListener takePiClickListener = new View.OnClickListener()
  55.     {
  57.         @Override
  58.         public void onClick(View v)
  59.         {
  60.             Log.d(LOG_TAG, "Take Picture Button Click");
  61.             // 利用系统自带的相机应用:拍照
  62.             Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
  64.             // create a file to save the image
  65.             fileUri = getOutputMediaFileUri(MEDIA_TYPE_IMAGE);
  67.             // 此处这句intent的值设置关系到后面的onActivityResult中会进入那个分支，即关系到data是否为null，如果此处指定，则后来的data为null
  68.             // set the image file name
  69.             intent.putExtra(MediaStore.EXTRA_OUTPUT, fileUri);
  71.             startActivityForResult(intent, CAPTURE_IMAGE_ACTIVITY_REQUEST_CODE);
  72.         }
  74.     };
  76.     private final OnClickListener takeVideoClickListener = new View.OnClickListener()
  77.     {
  79.         @Override
  80.         public void onClick(View v)
  81.         {
  82.             Log.d(LOG_TAG, "Take Video Button Click");
  83.             // 摄像
  84.             Intent intent = new Intent(MediaStore.ACTION_VIDEO_CAPTURE);
  86.             // create a file to save the video
  87.             fileUri = getOutputMediaFileUri(MEDIA_TYPE_VIDEO);
  88.             // set the image file name
  89.             intent.putExtra(MediaStore.EXTRA_OUTPUT, fileUri);
  91.             // set the video image quality to high
  92.             intent.putExtra(MediaStore.EXTRA_VIDEO_QUALITY, 1);
  94.             startActivityForResult(intent, CAPTURE_VIDEO_ACTIVITY_REQUEST_CODE);
  95.         }
  96.     };
  98.     public static final int MEDIA_TYPE_IMAGE = 1;
  99.     public static final int MEDIA_TYPE_VIDEO = 2;
  101.     /** Create a file Uri for saving an image or video */
  102.     private static Uri getOutputMediaFileUri(int type)
  103.     {
  104.         return Uri.fromFile(getOutputMediaFile(type));
  105.     }
  107.     /** Create a File for saving an image or video */
  108.     private static File getOutputMediaFile(int type)
  109.     {
  110.         // To be safe, you should check that the SDCard is mounted
  111.         // using Environment.getExternalStorageState() before doing this.
  113.         File mediaStorageDir = null;
  114.         try
  115.         {
  116.             // This location works best if you want the created images to be
  117.             // shared
  118.             // between applications and persist after your app has been
  119.             // uninstalled.
  120.             mediaStorageDir = new File(
  121.                     Environment
  122.                             .getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES),
  123.                     "MyCameraApp");
  125.             Log.d(LOG_TAG, "Successfully created mediaStorageDir: "
  126.                     + mediaStorageDir);
  128.         }
  129.         catch (Exception e)
  130.         {
  131.             e.printStackTrace();
  132.             Log.d(LOG_TAG, "Error in Creating mediaStorageDir: "
  133.                     + mediaStorageDir);
  134.         }
  136.         // Create the storage directory if it does not exist
  137.         if (!mediaStorageDir.exists())
  138.         {
  139.             if (!mediaStorageDir.mkdirs())
  140.             {
  141.                 // 在SD卡上创建文件夹需要权限：
  142.                 // <uses-permission
  143.                 // android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
  144.                 Log.d(LOG_TAG,
  145.                         "failed to create directory, check if you have the WRITE_EXTERNAL_STORAGE permission");
  146.                 return null;
  147.             }
  148.         }
  150.         // Create a media file name
  151.         String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss")
  152.                 .format(new Date());
  153.         File mediaFile;
  154.         if (type == MEDIA_TYPE_IMAGE)
  155.         {
  156.             mediaFile = new File(mediaStorageDir.getPath() + File.separator
  157.                     + "IMG_" + timeStamp + ".jpg");
  158.         }
  159.         else if (type == MEDIA_TYPE_VIDEO)
  160.         {
  161.             mediaFile = new File(mediaStorageDir.getPath() + File.separator
  162.                     + "VID_" + timeStamp + ".mp4");
  163.         }
  164.         else
  165.         {
  166.             return null;
  167.         }
  169.         return mediaFile;
  170.     }
  172.     @Override
  173.     protected void onActivityResult(int requestCode, int resultCode, Intent data)
  174.     {
  175.         super.onActivityResult(requestCode, resultCode, data);
  176.         Log.d(LOG_TAG, "onActivityResult: requestCode: " + requestCode
  177.                 + ", resultCode: " + requestCode + ", data: " + data);
  178.         // 如果是拍照
  179.         if (CAPTURE_IMAGE_ACTIVITY_REQUEST_CODE == requestCode)
  180.         {
  181.             Log.d(LOG_TAG, "CAPTURE_IMAGE");
  183.             if (RESULT_OK == resultCode)
  184.             {
  185.                 Log.d(LOG_TAG, "RESULT_OK");
  187.                 // Check if the result includes a thumbnail Bitmap
  188.                 if (data != null)
  189.                 {
  190.                     // 没有指定特定存储路径的时候
  191.                     Log.d(LOG_TAG,
  192.                             "data is NOT null, file on default position.");
  194.                     // 指定了存储路径的时候（intent.putExtra(MediaStore.EXTRA_OUTPUT,fileUri);）
  195.                     // Image captured and saved to fileUri specified in the
  196.                     // Intent
  197.                     Toast.makeText(this, "Image saved to:\n" + data.getData(),
  198.                             Toast.LENGTH_LONG).show();
  200.                     if (data.hasExtra("data"))
  201.                     {
  202.                         Bitmap thumbnail = data.getParcelableExtra("data");
  203.                         imageView.setImageBitmap(thumbnail);
  204.                     }
  205.                 }
  206.                 else
  207.                 {
  209.                     Log.d(LOG_TAG,
  210.                             "data IS null, file saved on target position.");
  211.                     // If there is no thumbnail image data, the image
  212.                     // will have been stored in the target output URI.
  214.                     // Resize the full image to fit in out image view.
  215.                     int width = imageView.getWidth();
  216.                     int height = imageView.getHeight();
  218.                     BitmapFactory.Options factoryOptions = new BitmapFactory.Options();
  220.                     factoryOptions.inJustDecodeBounds = true;
  221.                     BitmapFactory.decodeFile(fileUri.getPath(), factoryOptions);
  223.                     int imageWidth = factoryOptions.outWidth;
  224.                     int imageHeight = factoryOptions.outHeight;
  226.                     // Determine how much to scale down the image
  227.                     int scaleFactor = Math.min(imageWidth / width, imageHeight
  228.                             / height);
  230.                     // Decode the image file into a Bitmap sized to fill the
  231.                     // View
  232.                     factoryOptions.inJustDecodeBounds = false;
  233.                     factoryOptions.inSampleSize = scaleFactor;
  234.                     factoryOptions.inPurgeable = true;
  236.                     Bitmap bitmap = BitmapFactory.decodeFile(fileUri.getPath(),
  237.                             factoryOptions);
  239.                     imageView.setImageBitmap(bitmap);
  240.                 }
  241.             }
  242.             else if (resultCode == RESULT_CANCELED)
  243.             {
  244.                 // User cancelled the image capture
  245.             }
  246.             else
  247.             {
  248.                 // Image capture failed, advise user
  249.             }
  250.         }
  252.         // 如果是录像
  253.         if (requestCode == CAPTURE_VIDEO_ACTIVITY_REQUEST_CODE)
  254.         {
  255.             Log.d(LOG_TAG, "CAPTURE_VIDEO");
  257.             if (resultCode == RESULT_OK)
  258.             {
  259.             }
  260.             else if (resultCode == RESULT_CANCELED)
  261.             {
  262.                 // User cancelled the video capture
  263.             }
  264.             else
  265.             {
  266.                 // Video capture failed, advise user
  267.             }
  268.         }
  269.     }
  271. }

发表评论

表情：
评论列表 （有 0 条评论，156人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Android拍照保存

    1、拍照是在安卓开发中常用到的一个功能，所以需要熟练掌握 2、实现的功能是：拍照、保存到指定文件夹、照片可以命名 3、先获得读取文件夹的权限： <uses-per

    旧城等待，旧城等待，/ 0 赞/ 370 阅读