devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android 调用系统中的相机应用_android provider 非activity跳转系统相机

作者：IT小白 | 2024-03-01 16:28:10

赞

踩

android provider 非activity跳转系统相机

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

静默拍照 CameraActivity 

  1. package com.kelly.systemcameraandvedio;
  2.  
  3. /**
  4.  * 用来拍照的Activity
  5.  * 
  6.  */
  7. import java.io.File;
  8. import java.io.FileOutputStream;
  9. import java.io.IOException;
  10. import java.text.SimpleDateFormat;
  11. import java.util.Date;
  12.  
  13. import android.annotation.SuppressLint;
  14. import android.annotation.TargetApi;
  15. import android.app.Activity;
  16. import android.content.Context;
  17. import android.content.pm.PackageManager;
  18. import android.graphics.Bitmap;
  19. import android.graphics.BitmapFactory;
  20. import android.graphics.Matrix;
  21. import android.hardware.Camera;
  22. import android.hardware.Camera.AutoFocusCallback;
  23. import android.hardware.Camera.PictureCallback;
  24. import android.os.Build;
  25. import android.os.Bundle;
  26. import android.os.Environment;
  27. import android.util.Log;
  28. import android.view.SurfaceHolder;
  29. import android.view.SurfaceView;
  30. import android.view.Window;
  31. import android.view.WindowManager;
  32. import android.widget.Toast;
  33.  
  34. @TargetApi(Build.VERSION_CODES.GINGERBREAD)
  35. @SuppressLint("NewApi")
  36. public class CameraActivity extends Activity {
  37.  
  38. 	private SurfaceView mySurfaceView;
  39. 	private SurfaceHolder myHolder;
  40. 	private Camera myCamera;
  41. 	private static final String TAG = "CameraActivity";
  42.  
  43. 	@Override
  44. 	protected void onCreate(Bundle savedInstanceState) {
  45.  
  46. 		super.onCreate(savedInstanceState);
  47.  
  48. 		// 无title
  49. 		requestWindowFeature(Window.FEATURE_NO_TITLE);
  50. 		// 全屏
  51. 		getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
  52. 				WindowManager.LayoutParams.FLAG_FULLSCREEN);
  53.  
  54. 		// 设置布局
  55. 		setContentView(R.layout.activity_camera);
  56.  
  57. 		Log.i(TAG, "oncreate");
  58.  
  59. 		// 初始化surface
  60. 		initSurface();
  61.  
  62. 		// 这里得开线程进行拍照，因为Activity还未完全显示的时候，是无法进行拍照的，SurfaceView必须先显示
  63. 		new Thread(new Runnable() {
  64. 			@Override
  65. 			public void run() {
  66. 				// 初始化camera并对焦拍照
  67. 				initCamera();
  68. 			}
  69. 		}).start();
  70.  
  71. 	}
  72.  
  73. 	// 初始化surface
  74. 	@SuppressWarnings("deprecation")
  75. 	private void initSurface() {
  76. 		// 初始化surfaceview
  77. 		mySurfaceView = (SurfaceView) findViewById(R.id.camera_surfaceview);
  78.  
  79. 		// 初始化surfaceholder
  80. 		myHolder = mySurfaceView.getHolder();
  81.  
  82. 	}
  83.  
  84. 	// 初始化摄像头
  85. 	private void initCamera() {
  86.  
  87. 		// 如果存在摄像头
  88. 		if (checkCameraHardware(getApplicationContext())) {
  89. 			// 获取摄像头（首选前置，无前置选后置）
  90. 			if (openFacingFrontCamera()) {
  91. 				Log.i(TAG, "openCameraSuccess");
  92. 				// 进行对焦
  93. 				autoFocus();
  94. 			} else {
  95. 				Log.i(TAG, "openCameraFailed");
  96. 			}
  97.  
  98. 		}
  99. 	}
  100.  
  101. 	// 对焦并拍照
  102. 	private void autoFocus() {
  103.  
  104. 		try {
  105. 			// 因为开启摄像头需要时间，这里让线程睡两秒
  106. 			Thread.sleep(2000);
  107. 		} catch (InterruptedException e) {
  108. 			e.printStackTrace();
  109. 		}
  110.  
  111. 		// 自动对焦
  112. 		myCamera.autoFocus(myAutoFocus);
  113.  
  114. 		// 对焦后拍照
  115. 		myCamera.takePicture(null, null, myPicCallback);
  116. 	}
  117.  
  118. 	// 判断是否存在摄像头
  119. 	private boolean checkCameraHardware(Context context) {
  120.  
  121. 		if (context.getPackageManager().hasSystemFeature(
  122. 				PackageManager.FEATURE_CAMERA)) {
  123. 			// 设备存在摄像头
  124. 			return true;
  125. 		} else {
  126. 			// 设备不存在摄像头
  127. 			return false;
  128. 		}
  129.  
  130. 	}
  131.  
  132. 	// 得到后置摄像头
  133. 	private boolean openFacingFrontCamera() {
  134.  
  135. 		// 尝试开启前置摄像头
  136. 		Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
  137. 		for (int camIdx = 0, cameraCount = Camera.getNumberOfCameras(); camIdx < cameraCount; camIdx++) {
  138. 			Camera.getCameraInfo(camIdx, cameraInfo);
  139. 			if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
  140. 				try {
  141. 					Log.i(TAG, "tryToOpenCamera");
  142. 					myCamera = Camera.open(camIdx);
  143. 				} catch (RuntimeException e) {
  144. 					e.printStackTrace();
  145. 					return false;
  146. 				}
  147. 			}
  148. 		}
  149.  
  150. 		// 如果开启前置失败（无前置）则开启后置
  151. 		if (myCamera == null) {
  152. 			for (int camIdx = 0, cameraCount = Camera.getNumberOfCameras(); camIdx < cameraCount; camIdx++) {
  153. 				Camera.getCameraInfo(camIdx, cameraInfo);
  154. 				if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_BACK) {
  155. 					try {
  156. 						myCamera = Camera.open(camIdx);
  157. 					} catch (RuntimeException e) {
  158. 						return false;
  159. 					}
  160. 				}
  161. 			}
  162. 		}
  163.  
  164. 		try {
  165. 			// 这里的myCamera为已经初始化的Camera对象
  166. 			myCamera.setPreviewDisplay(myHolder);
  167. 		} catch (IOException e) {
  168. 			e.printStackTrace();
  169. 			myCamera.stopPreview();
  170. 			myCamera.release();
  171. 			myCamera = null;
  172. 		}
  173.  
  174. 		myCamera.startPreview();
  175.  
  176. 		return true;
  177. 	}
  178.  
  179. 	// 自动对焦回调函数(空实现)
  180. 	private AutoFocusCallback myAutoFocus = new AutoFocusCallback() {
  181. 		@Override
  182. 		public void onAutoFocus(boolean success, Camera camera) {
  183. 		}
  184. 	};
  185.  
  186. 	// 拍照成功回调函数
  187. 	private PictureCallback myPicCallback = new PictureCallback() {
  188.  
  189. 		@Override
  190. 		public void onPictureTaken(byte[] data, Camera camera) {
  191. 			// 完成拍照后关闭Activity
  192. 			CameraActivity.this.finish();
  193.  
  194. 			// 将得到的照片进行270°旋转，使其竖直
  195. 			Bitmap bitmap = BitmapFactory.decodeByteArray(data, 0, data.length);
  196. 			Matrix matrix = new Matrix();
  197. 			matrix.preRotate(270);
  198. 			bitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(),
  199. 					bitmap.getHeight(), matrix, true);
  200.  
  201. 			String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss")
  202. 					.format(new Date());
  203.  
  204. 			// 创建并保存图片文件
  205. 			File pictureFile = new File(getDir(), "IMG_" + timeStamp + ".jpg");
  206. 			try {
  207. 				FileOutputStream fos = new FileOutputStream(pictureFile);
  208. 				bitmap.compress(Bitmap.CompressFormat.PNG, 100, fos);
  209. 				fos.close();
  210. 			} catch (Exception error) {
  211. 				Toast.makeText(CameraActivity.this, "拍照失败", Toast.LENGTH_SHORT)
  212. 						.show();
  213. 				;
  214. 				Log.i(TAG, "保存照片失败" + error.toString());
  215. 				error.printStackTrace();
  216. 				myCamera.stopPreview();
  217. 				myCamera.release();
  218. 				myCamera = null;
  219. 			}
  220.  
  221. 			Log.i(TAG, "获取照片成功");
  222. 			Toast.makeText(CameraActivity.this, "获取照片成功", Toast.LENGTH_SHORT)
  223. 					.show();
  224. 			;
  225. 			myCamera.stopPreview();
  226. 			myCamera.release();
  227. 			myCamera = null;
  228. 		}
  229. 	};
  230.  
  231. 	// 获取文件夹
  232. 	private File getDir() {
  233. 		// 得到SD卡根目录
  234. 		File dir = Environment.getExternalStorageDirectory();
  235.  
  236. 		if (dir.exists()) {
  237. 			return dir;
  238. 		} else {
  239. 			dir.mkdirs();
  240. 			return dir;
  241. 		}
  242. 	}
  243. }


参考：1.http://www.cnblogs.com/mengdd/archive/2013/03/31/2991932.html

  2.http://download.csdn.net/detail/a740169405/6344845

代码下载：http://download.csdn.net/detail/leokelly001/8173715



声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/175304
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号