The first thing to understand when setting out to use camera features on Android devices is that not all camera features are supported on all devices. In addition, devices that support a particular feature may support them to different levels or with different options. Therefore, part of your decision process as you develop a camera application is to decide what camera features you want to support and to what level. After making that decision, you should plan on including code in your camera application that checks to see if device hardware supports those features and fails gracefully if a feature is not available.
Cameracapturesession is actually a pipeline instance with the target surface configured. We must create a cameracapturesession instance before using the camera function. A cameradevice can only open one cameracapturesession at a time.
Most camera operations are realized by submitting a capture request to cameracapturesession, such as taking photos, continuous shooting, setting flash mode, touching focus, displaying preview screen, etc. In some photographic scenarios, automatic focusing and light metering may not produce the desired results. This technique works for nearly all camera features, and most parameters can be changed at any time after you have obtained an instance of the Camera object.
Changes to parameters are typically visible to the user immediately in the application's camera preview. On the software side, parameter changes may take several frames to actually take effect as the camera hardware processes the new instructions and then sends updated image data. Now we're ready to capture the still image in CaptureStillPicture().
Here we'll create a new capture request using the StillCapture template and add our ImageReader surface as a target. Then we'll set flash and auto-focus to the same settings we used in the preview. Since this is a new request, we also need to deal with orientation again. It's a little different this time but we can use the GetOrientation method we created earlier to help us. Finally we stop and abort the preview captures and start a new one with our stillCaptureBuilder. To gain access for your app to the mobile camera and its features, you are required to present to your users the list of specific permissions and features needed.
Since Android 6.0 API level 23, users can have more control of granting or denying permissions dynamically instead of just during the installation. That will keep your app from being stopped during the operation. In the AndroidManifest.xml file, here are some permissions and features you will likely use to control and camera and save the resulting media files onto the external storage devices, such as a SD card. Video subtitles - This option is analogous to the "Stamp photos" option, but rather than embedding text into the video itself, it stores the text in a separate subtitles (".SRT") file. Most decent video players should support SRT files, and use them to display the information as subtitles. If "Store location data" is enabled (see "Location settings" below), then the current location latitude and longitude coordinates will also be recorded .
Note that you can control the formatting style for date, time and location using the options under the "Photo settings" menu . When the program calls the setRepeatingRequest() method to preview, or calls the capture() method to take a picture, it needs to pass in the CameraRequest parameter. CameraRequest represents a capture request, which is used to describe the various parameter settings of the captured image, such as focus mode, exposure mode... In short, the various controls that the program needs to do on the photo are set through the CameraRequest parameter.
CameraRequest.Builder is responsible for generating CameraRequest objects. 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. Camera API - If set to "Camera2 API", this enables support for the Camera2 API that was introduced in Android 5. Changing this setting will cause Open Camera to restart. Camera2 API enables more advanced features (including manual ISO/exposure, manual focus, HDR, exposure bracketing).
Also note that even if devices support Camera2 API, some devices have poor support. Please see here for more details on device compatibility. Maximum file size of video - This allows to set a maximum file size for videos. Note that many Android devices set a maximum file size , and there is no way Open Camera can work around such a limitation (and using exFAT doesn't get round it). Note that the value is approximate - typically the resultant videos may be slightly smaller.
If "Restart on maximum file size" is disabled, then hitting the maximum file size will always cause the video to end without restarting, even if you've set "Restart video after max duration". Preview size - By default, Open Camera matches the aspect ratio of the preview (the image that is displayed on the phone/tablet's display) with that of the photo resolution ("Match photo size " mode). If instead you select "Maximise preview size", then the camera preview will be as large as possible, trying to fill the available space. However if the resolution of the photo is a different aspect ratio to that of your device, this will result in the preview being cropped. Also note that the feature reduces the available space in the image - because rotating an image makes it no longer fit into a rectangular image, so we have to crop it.
So it's still advisable to try to hold the camera reasonably level when using this feature. A dot shows to the top-right of the GPS icon to indicate the accuracy . If the location isn't available, a dash will be shown through the gps icon. (Only available on some devices, and if Camera2 API is used.) This mode takes a series of photos each with a different focus distance. Two sliders appear, allowing you to change the "source" and "target" focus distance. In this mode, you can change the number of photos to take from the popup menu.
Also on the popup menu, the option "Add infinite distance" if enabled will mean an extra photo is taken, at infinite focus distance. Focus bracketing is typically used with Focus stacking software to merge the images into a single photo. Note that whilst taking a set of focus bracketed photos, you can cancel the set by pressing the "take photo" button again. Also see the options "Focus assist" and "Focus peaking" under Settings/Camera preview/ which may be useful when adjusting the focus distances. The manual focus SeekBar is very similar to the zoom SeekBar with the only difference that the range of values is always 0-1.
We set the range of the SeekBar from to widen the range. Then again we set a anonymous Listener to react on the user input. Since we widened the value range, we need to divide the current Seekbar value by 100 before we pass it back to the CameraManager by calling setManualFocusDistance. Using the manual focus only works if no auto focus is enabled.
This means that to use manual focus the camera focus mode has to be CameraSettings.CameraFocusMode.OFF. The manual focus SeekBar is only shown in the sample if the focus mode is set to CameraSettings.CameraFocusMode.OFF because of this behaviour. Manual Support works only when using the camera2 api which can be enabled in the ArchitectStartupConfiguration by the calling config.setCamera2Enabled.
Please note that the camera2 api has issues on several devices which is why it is disabled by default. 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.
On most devices, the default orientation of the camera preview is landscape. This example layout specifies a horizontal 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.
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 overlayed on the live camera preview images.
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. MediaStore.EXTRA_OUTPUT - This setting requires a Uri object specifying a path and file name where you'd like to save the picture. If you do not specify this value, the camera application saves the requested picture in the default location with a default name, specified in the returned intent's Intent.getData()field. Simply point, and press the blue camera icon to take a photo. If your device supports focus areas, you can touch the part of the screen you want to focus.
Touching an area will also control the exposure level (e.g., so clicking on a bright area will adjust the exposure so that it becomes less bright). To zoom, use the slider next to the take photo button, or do a multi-touch "pinch" gesture. You can also control via the volume keys on your phone or tablet - by default, pressing them will take a photo, but you can change this to zoom in/out from the Settings. OnOpened is called as the 'success' callback of manager.OpenCamera() and gives us access to the CameraDevice. We take this opportunity to set our TextureView's SurfaceTexture buffer size to match our preview size. Then we start a capture session that will be used for both preview and image capture.
The capture session needs access to any surface that will be used, so we pass in our TextureView and ImageReader's respective surfaces. 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. A camera intent makes a request to capture a picture or video clip through an existing camera app and then returns control back to your application. This section shows you how to capture an image or video using this technique. Why doesn't Open Camera support the maximum video resolution on my device?
- If you are using Camera2 API, make sure that you're not in slow motion mode (see "Speed" under the popup menu), and you don't have a non-default frame rate set (under Settings/Video settings). If a high speed frame rate is in use, then this usually limits the maximum video resolution. Restart on maximum file size - Whether to automatically restart if the maximum file size is met.
As noted above, almost all Android devices have a maximum file size for videos, even if you don't explicitly set one. So it's advisable to keep this option to true, so that Open Camera will restart as soon as possible if you're recording video, and hit this limit. Note that on devices that are not running Android 8 or later, there will still be a loss of a few seconds while the video stops and restarts.
On Android 8 or later, the resume should be seamless . Focus assist - If enabled, this will show a zoomed in view on the camera preview when in manual focus mode, and you are changing the manual focus distance. Similarly in focus bracketing mode, the preview will zoom in when changing the focus distances to bracket between. It's called as the 'success' callback of CreateCaptureSession(). Here we handle the last setup actions needed like activating auto-focus , activating flash and starting a repeating capture request.
The repeating request tells Android to continuously read from the camera and display the results on our preview surface. The first thing we do is initialize our ImageReader to the correct size. This is what we will use to actually capture the photo. It's not realy a part of the preview process, but I found this to be a good place to make sure it's properly initialized. We create it by finding the largest available JPEG size on the device and create a new instance using those dimensions.
This controls how many images the reader can keep active in memory at one time. Since we're planning to save each image to disk immediately we can save memory by only holding one in memory at a time. ImageReader will throw an exception if we try to take a second picture, so we'll need to clear out our image after saving to disk. In addition to the mode configuration, capturerequest can also configure many other information, such as image format, image resolution, sensor control, flash control, 3A control, etc. It can be set in the callback of createcapturesession, and finally throughbuild()Method to generate a capturerequest object. For example, you can use the surface of surfaceview to receive preview data of each frame for displaying preview screen, or you can use the surface of imagereader to receive JPEG or YUV data.
You can get a list of sizes supported by a data format from cameracharacteristics. A camera is perhaps one of the most desirable hardware features among the regular mobile phone functionalities. It goes beyond the traditional purpose of just taking pictures.
Modern mobile cameras, as shown in Figure 1, also do on-the-fly image processing, object recognition, 3-D photo capture, security authentication, virtual reality, and so on. With the gigantic selection of versatile camera apps, many things become excitingly possible. Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES) - This method returns the standard, shared and recommended location for saving pictures and videos. This directory is shared , so other applications can easily discover, read, change and delete files saved in this location.
If your application is uninstalled by the user, media files saved to this location will not be removed. To avoid interfering with users existing pictures and videos, you should create a sub-directory for your application's media files within this directory, as shown in the code sample below. This method is available in Android 2.2 , for equivalent calls in earlier API versions, see Saving Shared Files. Why doesn't the preview display match the resultant photo/video? - Firstly, make sure that Settings/Camera preview/Preview size is set to "Match photo size ".
A workaround may be to try a different resolution for photos and/or videos. Stamp photos - Option to add a date and timestamp to the resultant photos. If "Store location data" is enabled (see "Location settings" below), then the current location latitude and longitude coordinates, and altitude, will also be stamped on the resultant photos . Note that if this option is enabled, then it will take longer to save the photo. Save all images for HDR mode - When using HDR mode, if this option is enabled, then the three base exposure images will be saved as well as the final HDR photo. This is useful if you want to use external HDR applications to create the final HDR image (although if you don't want Open Camera's HDR mode at all, you can instead use the Exposure Bracketing Photo Mode).
Note this will make saving slower, especially if options like "Stamp photos" orAuto-level are also used. Bluetooth LE remote control - Open Camera supports connecting to some specific "smart housing" cases via the options in these settings. At the time of writing, only one make/model is supported. Once connected via Bluetooth, it should be possible to control Open Camera from the device.
