<ol>
<li><a href="#TaskManifest">Request Camera Permission</a></li>
<li><a href="#TaskCaptureIntent">Take a Photo with the Camera App</a></li>
- <li><a href="#TaskPhotoView">View the Photo</a></li>
- <li><a href="#TaskPath">Save the Photo</a></li>
+ <li><a href="#TaskPhotoView">Get the Thumbnail</a></li>
+ <li><a href="#TaskPath">Save the Full-size Photo</a></li>
<li><a href="#TaskGallery">Add the Photo to a Gallery</a></li>
<li><a href="#TaskScalePhoto">Decode a Scaled Image</a></li>
</ol>
<h2>You should also read</h2>
<ul>
<li><a href="{@docRoot}guide/topics/media/camera.html">Camera</a></li>
- <li><a href="{@docRoot}guide/components/intents-filters.html">Intents and Intent
+ <li><a href="{@docRoot}guide/components/intents-filters.html">Intents and Intent
Filters</a></li>
</ul>
href="{@docRoot}guide/topics/manifest/uses-feature-element.html"> {@code
<uses-feature>}</a> tag in your manifest file:</p>
-<pre>
+<pre style="clear:right">
<manifest ... >
- <uses-feature android:name="android.hardware.camera" />
+ <uses-feature android:name="android.hardware.camera"
+ android:required="true" />
...
-</manifest ... >
+</manifest>
</pre>
-<p>If your application uses, but does not require a camera in order to function, add {@code
-android:required="false"} to the tag. In doing so, Google Play will allow devices without a
+<p>If your application uses, but does not require a camera in order to function, instead set {@code
+android:required} to {@code false}. In doing so, Google Play will allow devices without a
camera to download your application. It's then your responsibility to check for the availability
of the camera at runtime by calling {@link
android.content.pm.PackageManager#hasSystemFeature hasSystemFeature(PackageManager.FEATURE_CAMERA)}.
If a camera is not available, you should then disable your camera features.</p>
-<h2 id="TaskCaptureIntent">Take a Photo with the Camera App</h2>
+<h2 id="TaskCaptureIntent">Take a Photo with the Camera App</h2>
<p>The Android way of delegating actions to other applications is to invoke an {@link
android.content.Intent} that describes what you want done. This process involves three pieces: The
<p>Here's a function that invokes an intent to capture a photo.</p>
<pre>
-private void dispatchTakePictureIntent(int actionCode) {
+static final int REQUEST_IMAGE_CAPTURE = 1;
+
+private void dispatchTakePictureIntent() {
Intent takePictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
- startActivityForResult(takePictureIntent, actionCode);
+ if (takePictureIntent.resolveActivity(getPackageManager()) != null) {
+ startActivityForResult(takePictureIntent, REQUEST_IMAGE_CAPTURE);
+ }
}
</pre>
+<p>Notice that the {@link android.app.Activity#startActivityForResult
+startActivityForResult()} method is protected by a condition that calls
+{@link android.content.Intent#resolveActivity resolveActivity()}, which returns the
+first activity component that can handle the intent. Performing this check
+is important because if you call {@link android.app.Activity#startActivityForResult
+startActivityForResult()} using an intent that no app can handle,
+your app will crash. So as long as the result is not null, it's safe to use the intent. </p>
-<p>Congratulations: with this code, your application has gained the ability to
-make another camera application do its bidding! Of course, if no compatible
-application is ready to catch the intent, then your app will fall down like a
-botched stage dive. Here is a function to check whether an app can handle your intent:</p>
-
-<pre>
-public static boolean isIntentAvailable(Context context, String action) {
- final PackageManager packageManager = context.getPackageManager();
- final Intent intent = new Intent(action);
- List<ResolveInfo> list =
- packageManager.queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY);
- return list.size() > 0;
-}
-</pre>
-<h2 id="TaskPhotoView">View the Photo</h2>
+<h2 id="TaskPhotoView">Get the Thumbnail</h2>
<p>If the simple feat of taking a photo is not the culmination of your app's
ambition, then you probably want to get the image back from the camera
this image and displays it in an {@link android.widget.ImageView}.</p>
<pre>
-private void handleSmallCameraPhoto(Intent intent) {
- Bundle extras = intent.getExtras();
- mImageBitmap = (Bitmap) extras.get("data");
- mImageView.setImageBitmap(mImageBitmap);
+@Override
+protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+ if (requestCode == REQUEST_IMAGE_CAPTURE && resultCode == RESULT_OK) {
+ Bundle extras = data.getExtras();
+ Bitmap imageBitmap = (Bitmap) extras.get("data");
+ mImageView.setImageBitmap(imageBitmap);
+ }
}
</pre>
work.</p>
-<h2 id="TaskPath">Save the Photo</h2>
+<h2 id="TaskPath">Save the Full-size Photo</h2>
<p>The Android Camera application saves a full-size photo if you give it a file to
-save into. You must provide a path that includes the storage volume,
-folder, and file name.</p>
-
-<p>There is an easy way to get the path for photos, but it works only on Android 2.2 (API level 8)
-and later:</p>
+save into. You must provide a fully qualified file name where the camera app should
+save the photo.</p>
+
+<p>Generally, any photos that the user captures with the device camera should be saved on
+the device in the public external storage so they are accessible by all apps.
+The proper directory for shared photos is provided by {@link
+android.os.Environment#getExternalStoragePublicDirectory getExternalStoragePublicDirectory()},
+with the {@link android.os.Environment#DIRECTORY_PICTURES} argument. Because the directory
+provided by this method is shared among all apps, reading and writing to it requires the
+{@link android.Manifest.permission#READ_EXTERNAL_STORAGE} and
+{@link android.Manifest.permission#WRITE_EXTERNAL_STORAGE} permissions, respectively.
+The write permission implicitly allows reading, so if you need to write to the external
+storage then you need to request only one permission:</p>
-<pre>
-storageDir = new File(
- Environment.getExternalStoragePublicDirectory(
- Environment.DIRECTORY_PICTURES
- ),
- getAlbumName()
-);
-</pre>
-
-<p>For earlier API levels, you have to provide the name of the photo
-directory yourself.</p>
-
-<pre>
-storageDir = new File (
- Environment.getExternalStorageDirectory()
- + PICTURES_DIR
- + getAlbumName()
-);
-</pre>
+<pre>
+<manifest ...>
+ <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+ ...
+</manifest>
+</pre>
-<p class="note"><strong>Note:</strong> The path component {@code PICTURES_DIR} is
-just {@code Pictures/}, the standard location for shared photos on the external/shared
-storage.</p>
+<p>However, if you'd like the photos to remain private to your app only, you can instead use the
+directory provided by {@link android.content.Context#getExternalFilesDir getExternalFilesDir()}.
+On Android 4.3 and lower, writing to this directory also requires the
+{@link android.Manifest.permission#WRITE_EXTERNAL_STORAGE} permission. Beginning with
+Android 4.4, the permission is no longer required because the directory is not accessible
+by other apps, so you can declare the permission should be requested only on the lower versions
+of Android by adding the <a
+href="{@docRoot}guide/topics/manifest/uses-permission-element.html#maxSdk">{@code maxSdkVersion}</a>
+attribute:</p>
+<pre>
+<manifest ...>
+ <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"
+ android:maxSdkVersion="18" />
+ ...
+</manifest>
+</pre>
+<p class="note"><strong>Note:</strong> Files you save in the directories provided by
+{@link android.content.Context#getExternalFilesDir getExternalFilesDir()} are deleted
+when the user uninstalls your app.</p>
-<h3 id="TaskFileName">Set the file name</h3>
+<p>Once you decide the directory for the file, you need to create a
+collision-resistant file name. You may wish also to save the path in a
+member variable for later use. Here's an example solution in a method that returns
+a unique file name for a new photo using a date-time stamp:</p>
-<p>As shown in the previous section, the file location for an image should be
-driven by the device environment. What you need to do yourself is choose a
-collision-resistant file-naming scheme. You may wish also to save the path in a
-member variable for later use. Here's an example solution:</p>
+<pre>
+String mCurrentPhotoPath;
-<pre>
private File createImageFile() throws IOException {
// Create an image file name
- String timeStamp =
- new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
- String imageFileName = JPEG_FILE_PREFIX + timeStamp + "_";
+ String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
+ String imageFileName = "JPEG_" + timeStamp + "_";
+ File storageDir = Environment.getExternalStoragePublicDirectory(
+ Environment.DIRECTORY_PICTURES);
File image = File.createTempFile(
- imageFileName,
- JPEG_FILE_SUFFIX,
- getAlbumDir()
+ imageFileName, /* prefix */
+ ".jpg", /* suffix */
+ storageDir /* directory */
);
- mCurrentPhotoPath = image.getAbsolutePath();
+
+ // Save a file: path for use with ACTION_VIEW intents
+ mCurrentPhotoPath = "file:" + image.getAbsolutePath();
return image;
}
-</pre>
-
+</pre>
-<h3 id="TaskIntentFileName">Append the file name onto the Intent</h3>
-<p>Once you have a place to save your image, pass that location to the camera
-application via the {@link android.content.Intent}.</p>
+<p>With this method available to create a file for the photo, you can now
+create and invoke the {@link android.content.Intent} like this:</p>
<pre>
-File f = createImageFile();
-takePictureIntent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(f));
+static final in REQUEST_TAKE_PHOTO = 1;
+
+private void dispatchTakePictureIntent() {
+ Intent takePictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
+ // Ensure that there's a camera activity to handle the intent
+ if (takePictureIntent.resolveActivity(getPackageManager()) != null) {
+ // Create the File where the photo should go
+ File photoFile = null;
+ try {
+ photoFile = createImageFile();
+ } catch (IOException ex) {
+ // Error occurred while creating the File
+ ...
+ }
+ // Continue only if the File was successfully created
+ if (photoFile != null) {
+ takePictureIntent.putExtra(MediaStore.EXTRA_OUTPUT,
+ Uri.fromFile(photoFile));
+ startActivityForResult(takePictureIntent, REQUEST_TAKE_PHOTO);
+ }
+ }
+}
</pre>
you said where to save it in the first place. For everyone else, perhaps the easiest way to make
your photo accessible is to make it accessible from the system's Media Provider.</p>
+<p class="note"><strong>Note:</strong> If you saved your photo to the directory provided by
+{@link android.content.Context#getExternalFilesDir getExternalFilesDir()}, the media
+scanner cannot access the files because they are private to your app.</p>
+
<p>The following example method demonstrates how to invoke the system's media scanner to add your
photo to the Media Provider's database, making it available in the Android Gallery application
and to other apps.</p>
// Get the dimensions of the View
int targetW = mImageView.getWidth();
int targetH = mImageView.getHeight();
-
+
// Get the dimensions of the bitmap
BitmapFactory.Options bmOptions = new BitmapFactory.Options();
bmOptions.inJustDecodeBounds = true;
BitmapFactory.decodeFile(mCurrentPhotoPath, bmOptions);
int photoW = bmOptions.outWidth;
int photoH = bmOptions.outHeight;
-
+
// Determine how much to scale down the image
int scaleFactor = Math.min(photoW/targetW, photoH/targetH);
-
+
// Decode the image file into a Bitmap sized to fill the View
bmOptions.inJustDecodeBounds = false;
bmOptions.inSampleSize = scaleFactor;
bmOptions.inPurgeable = true;
-
+
Bitmap bitmap = BitmapFactory.decodeFile(mCurrentPhotoPath, bmOptions);
mImageView.setImageBitmap(bitmap);
}
<h2>You should also read</h2>
<ul>
<li><a href="{@docRoot}guide/topics/media/camera.html">Camera</a></li>
- <li><a href="{@docRoot}guide/components/intents-filters.html">Intents and Intent
+ <li><a href="{@docRoot}guide/components/intents-filters.html">Intents and Intent
Filters</a></li>
</ul>
<p>To advertise that your application depends on having a camera, put a
{@code <uses-feature>} tag in the manifest file:</p>
-<pre>
+<pre style="clear:right">
<manifest ... >
- <uses-feature android:name="android.hardware.camera" />
+ <uses-feature android:name="android.hardware.camera"
+ android:required="true" />
...
-</manifest ... >
+</manifest>
</pre>
-<p>If your application uses, but does not require a camera in order to function, add {@code
-android:required="false"} to the tag. In doing so, Google Play will allow devices without a
+<p>If your application uses, but does not require a camera in order to function, set {@code
+android:required} to {@code false}. In doing so, Google Play will allow devices without a
camera to download your application. It's then your responsibility to check for the availability
of the camera at runtime by calling {@link
android.content.pm.PackageManager#hasSystemFeature hasSystemFeature(PackageManager.FEATURE_CAMERA)}.
If a camera is not available, you should then disable your camera features.</p>
-<h2 id="TaskCaptureIntent">Record a Video with a Camera App</h2>
+<h2 id="TaskCaptureIntent">Record a Video with a Camera App</h2>
-<p>The Android way of delegating actions to other applications is to invoke
-an {@link android.content.Intent} that describes what you want done. This
-involves three pieces: the {@link android.content.Intent} itself, a call to start the external
-{@link android.app.Activity}, and some code to handle the video when focus returns
-to your activity.</p>
+<p>The Android way of delegating actions to other applications is to invoke an {@link
+android.content.Intent} that describes what you want done. This process involves three pieces: The
+{@link android.content.Intent} itself, a call to start the external {@link android.app.Activity},
+and some code to handle the video when focus returns to your activity.</p>
<p>Here's a function that invokes an intent to capture video.</p>
<pre>
+static final int REQUEST_VIDEO_CAPTURE = 1;
+
private void dispatchTakeVideoIntent() {
Intent takeVideoIntent = new Intent(MediaStore.ACTION_VIDEO_CAPTURE);
- startActivityForResult(takeVideoIntent, ACTION_TAKE_VIDEO);
+ if (takeVideoIntent.resolveActivity(getPackageManager()) != null) {
+ startActivityForResult(takeVideoIntent, REQUEST_VIDEO_CAPTURE);
+ }
}
</pre>
-
-<p>It's a good idea to make sure an app exists to handle your intent
-before invoking it. Here's a function that checks for apps that can handle your intent:</p>
-
-<pre>
-public static boolean isIntentAvailable(Context context, String action) {
- final PackageManager packageManager = context.getPackageManager();
- final Intent intent = new Intent(action);
- List<ResolveInfo> list =
- packageManager.queryIntentActivities(intent,
- PackageManager.MATCH_DEFAULT_ONLY);
- return list.size() > 0;
-}
-</pre>
+<p>Notice that the {@link android.app.Activity#startActivityForResult
+startActivityForResult()} method is protected by a condition that calls
+{@link android.content.Intent#resolveActivity resolveActivity()}, which returns the
+first activity component that can handle the intent. Performing this check
+is important because if you call {@link android.app.Activity#startActivityForResult
+startActivityForResult()} using an intent that no app can handle,
+your app will crash. So as long as the result is not null, it's safe to use the intent. </p>
<h2 id="TaskVideoView">View the Video</h2>
retrieves this video and displays it in a {@link android.widget.VideoView}.</p>
<pre>
-private void handleCameraVideo(Intent intent) {
- mVideoUri = intent.getData();
- mVideoView.setVideoURI(mVideoUri);
+@Override
+protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+ if (requestCode == REQUEST_VIDEO_CAPTURE && resultCode == RESULT_OK) {
+ Uri videoUri = intent.getData();
+ mVideoView.setVideoURI(videoUri);
+ }
}
</pre>
OSDN Git Service
