The Android framework includes support for various cameras and camera features available on devices, allowing you to capture pictures and videos in your applications. This document discusses a quick, simple approach to image and video capture and outlines an advanced approach for creating custom camera experiences for your users. Note: This page describes the Camera class, which has been deprecated. We recommend using the newer class camera2 , which works on Android 5. Read more about camera2 on our blog and watch this video.
Considerations Before enabling your application to use cameras on Android devices, you should consider a few questions about how your app intends to use this hardware feature.
The Android framework supports capturing images and video through the android. Here are the relevant classes:. Before starting development on your application with the Camera API, you should make sure your manifest has the appropriate declarations to allow use of camera hardware and other related features. Note: If you are using the camera by invoking an existing camera app , your application does not need to request this permission.
For a list of camera features, see the manifest Features Reference. Adding camera features to your manifest causes Google Play to prevent your application from being installed to devices that do not include a camera or do not support the camera features you specify.
If your application can use a camera or camera feature for proper operation, but does not require it, you should specify this in the manifest by including the android:required attribute, and setting it to false :. Note that, if your app targets Android 5.
For more information about getting user location, see Location Strategies. A quick way to enable taking pictures or videos in your application without a lot of extra code is to use an Intent to invoke an existing Android camera application. Some developers may require a camera user interface that is customized to the look of their application or provides special features.
Writing your own picture-taking code can provide a more compelling experience for your users. For new or advanced camera applications, the newer android. Camera hardware is a shared resource that must be carefully managed so your application does not collide with other applications that may also want to use it. The following sections discusses how to detect camera hardware, how to request access to a camera, how to capture pictures or video and how to release the camera when your application is done using it.
Caution: Remember to release the Camera object by calling the Camera. If your application does not properly release the camera, all subsequent attempts to access the camera, including those by your own application, will fail and may cause your or other applications to be shut down.
If your application does not specifically require a camera using a manifest declaration, you should check to see if a camera is available at runtime. To perform this check, use the PackageManager. Android devices can have multiple cameras, for example a back-facing camera for photography and a front-facing camera for video calls.
Android 2. If you have determined that the device on which your application is running has a camera, you must request to access it by getting an instance of Camera unless you are using an intent to access the camera. To access the primary camera, use the Camera. Caution: Always check for exceptions when using Camera. Failing to check for exceptions if the camera is in use or does not exist will cause your application to be shut down by the system.
On devices running Android 2. The example code above will access the first, back-facing camera on a device with more than one camera. Once you obtain access to a camera, you can get further information about its capabilities using the Camera.
Parameters object for supported capabilities. For users to effectively take pictures or video, they must be able to see what the device camera sees. A camera preview class is a SurfaceView that can display the live image data coming from a camera, so users can frame and capture a picture or video. The following example code demonstrates how to create a basic camera preview class that can be included in a View layout.
This class implements SurfaceHolder. Callback in order to capture the callback events for creating and destroying the view, which are needed for assigning the camera preview input. If you want to set a specific size for your camera preview, set this in the surfaceChanged method as noted in the comments above. When setting preview size, you must use values from getSupportedPreviewSizes. Do not set arbitrary values in the setPreviewSize method. Note: With the introduction of the Multi-Window feature in Android 7.
Depending on the window size and aspect ratio, you may may have to fit a wide camera preview into a portrait-orientated layout, or vice versa, using a letterbox layout. Placing preview in a layout A camera preview class, such as the example shown in the previous section, must be placed in the layout of an activity along with other user interface controls for taking a picture or video.
This section shows you how to build a basic layout and activity for the preview. The following layout code provides a very basic view that can be used to display a camera preview.
In this example, the FrameLayout element is meant to be the container for the camera preview class. This layout type is used so that additional picture information or controls can be overlaid on the live camera preview images. On most devices, the default orientation of the camera preview is landscape.
This example layout specifies a horizontal landscape layout and the code below fixes the orientation of the application to landscape. For simplicity in rendering a camera preview, you should change your application's preview activity orientation to landscape by adding the following to your manifest.
Note: A camera preview does not have to be in landscape mode. Starting in Android 2. In order to change preview orientation as the user re-orients the phone, within the surfaceChanged method of your preview class, first stop the preview with Camera.
In the activity for your camera view, add your preview class to the FrameLayout element shown in the example above. Your camera activity must also ensure that it releases the camera when it is paused or shut down. The following example shows how to modify a camera activity to attach the preview class shown in Creating a preview class. Note: The getCameraInstance method in the example above refers to the example method shown in Accessing cameras.
Once you have built a preview class and a view layout in which to display it, you are ready to start capturing images with your application.
In your application code, you must set up listeners for your user interface controls to respond to a user action by taking a picture. In order to retrieve a picture, use the Camera. This method takes three parameters which receive data from the camera. PictureCallback interface to receive the image data and write it to a file. The following code shows a basic implementation of the Camera.
PictureCallback interface to save an image received from the camera. Trigger capturing an image by calling the Camera. The following example code shows how to call this method from a button View. Note: The mPicture member in the following example refers to the example code above.
For information about how to release the camera, see Releasing the camera. Video capture using the Android framework requires careful management of the Camera object and coordination with the MediaRecorder class. When recording video with Camera , you must manage the Camera. Note: Starting with Android 4. Unlike taking pictures with a device camera, capturing video requires a very particular call order. You must follow a specific order of execution to successfully prepare for and capture video with your application, as detailed below.
Caution: You must call these MediaRecorder configuration methods in this order , otherwise your application will encounter errors and the recording will fail. Note: It is possible to use MediaRecorder without creating a camera preview first and skip the first few steps of this process. However, since users typically prefer to see a preview before starting a recording, that process is not discussed here.
Tip: If your application is typically used for recording video, set setRecordingHint boolean to true prior to starting your preview.
This setting can help reduce the time it takes to start recording. When using the MediaRecorder class to record video, you must perform configuration steps in a specific order and then call the MediaRecorder. The following example code demonstrates how to properly configure and prepare the MediaRecorder class for video recording.
Prior to Android 2. This approach is demonstrated in the following code:. The following video recording parameters for MediaRecorder are given default settings, however, you may want to adjust these settings for your application:. When starting and stopping video recording using the MediaRecorder class, you must follow a specific order, as listed below.
The following example code demonstrates how to wire up a button to properly start and stop video recording using the camera and the MediaRecorder class. Note: When completing a video recording, do not release the camera or else your preview will be stopped. Note: In the above example, the prepareVideoRecorder method refers to the example code shown in Configuring MediaRecorder.
This method takes care of locking the camera, configuring and preparing the MediaRecorder instance. Cameras are a resource that is shared by applications on a device. Your application can make use of the camera after getting an instance of Camera , and you must be particularly careful to release the camera object when your application stops using it, and as soon as your application is paused Activity. To release an instance of the Camera object, use the Camera.
Caution: If your application does not properly release the camera, all subsequent attempts to access the camera, including those by your own application, will fail and may cause your or other applications to be shut down. Media files created by users such as pictures and videos should be saved to a device's external storage directory SD Card to conserve system space and to allow users to access these files without their device.
There are many possible directory locations to save media files on a device, however there are only two standard locations you should consider as a developer:. The following example code demonstrates how to create a File or Uri location for a media file that can be used when invoking a device's camera with an Intent or as part of a Building a Camera App.
accept. camera download games frontal share your
not camera frontal download games amusing phrase