Develop Reference

Check custom front camera availibility

I have been working on Custom SurfaceView Camera. I need to work with front camera as my application takes user's selfie.
For that I have checked a for whether front camera is available using below code.
public boolean checkFrontCamera() {
int numCameras = Camera.getNumberOfCameras();
for (int i = 0; i < numCameras; i++) {
Camera.CameraInfo info = new Camera.CameraInfo();
Camera.getCameraInfo(i, info);
if (CameraSource.CAMERA_FACING_FRONT == info.facing) {
return true;
}
}
return false;
}
Its working fine if device has both the camera, and it returns true. But if device has only one camera, this method always returns false as info.facing is 0 in this case and for the same in this code CameraSource.CAMERA_FACING_FRONT is 1.
for Camera, I have used gms vision library. Below code is for camera source.
CameraSource mCameraSource = new CameraSource.Builder(context, detector)
.setRequestedPreviewSize(640, 480)
.setFacing(CameraSource.CAMERA_FACING_FRONT)
.setRequestedFps(30.0f)
.build();
Here I need to pass camera facing params.
Please provide if any other alternative. All solutions are welcomed.

Well you can use this method, which returns the camera object
private Camera getCameraInstance() {
Camera c = null;
try {
if (Camera.getNumberOfCameras() >= 2) {
//Front facing camera
c = Camera.open(Camera.CameraInfo.CAMERA_FACING_FRONT);
} else {
// only has one camera (Rear)
c = Camera.open();
}
} catch (Exception e) {
// Camera is not available (in use or does not exist)
}
return c; // returns null if camera is unavailable
}

Detect whether using front or back camera

When I open the Camera using
Camera cam = Camera.open();
or
Camera cam = Camera.open(number);
How can I get information that this is the front or back camera? Some devices may have both, and some just one.

Update:
Camera.CameraInfo was deprecated in API level 21.
For newer versions see CameraCharacteristics.LENS_FACING. For more info, please see this answer.
First of all you may want to look at the reference of Camera class.
Methods getNumberOfCameras (does this device have only one camera or both?) and getCameraInfo (https://developer.android.com/reference/android/hardware/Camera.CameraInfo.html) will provide you with the exact information that you need.
There is an example of using both these methods:
private int findFrontFacingCamera() {
int cameraId = -1;
// Search for the front facing camera
int numberOfCameras = Camera.getNumberOfCameras();
for (int i = 0; i < numberOfCameras; i++) {
CameraInfo info = new CameraInfo();
Camera.getCameraInfo(i, info);
if (info.facing == CameraInfo.CAMERA_FACING_FRONT) {
Log.d(DEBUG_TAG, "Camera found");
cameraId = i;
break;
}
}
return cameraId;
}

first of all you should check if your device is supporting camera or not, and if the camera is supported then you get the number the number of available camera on your device.
<pre>CameraInfo cameraInfo = new CameraInfo();<br/>
for (int i = 0; i < numberOfCameras; i++) {
Camera.getCameraInfo(i, cameraInfo);
if (cameraInfo.facing == CameraInfo.CAMERA_FACING_FRONT) {
}
}
you can use something like this to know which camera is open.
hope this will help you..

Barcode scanning with ZX and front facing camera

I'm using the following code to fire an Intent to start the ZX barcode scanner. I've tweaked it to use the front-facing camera, but this appears to be failing to scan any barcodes because the front-facing image is reversed (I'm assuming this is the reason). ie a book barcode shows NBSI (with backwards letters) rather than ISBN. Using the rear facing camera a Nexus 5 and Nexus 7 can both scan barcodes. When switching to the front camera both fail to recognise barcodes.
How do I tweak my Intent so ZX shows a non-reversed front-facing camera image?
private void startBarcodeScanner() {
IntentIntegrator integrator = new IntentIntegrator(MainActivity.this);
integrator.addExtra("SCAN_CAMERA_ID", getFrontCameraId());
integrator.addExtra("SCAN_MODE", "PRODUCT_MODE");
integrator.initiateScan(IntentIntegrator.PRODUCT_CODE_TYPES);
}
private int getFrontCameraId() {
int cameraId = -1;
int numberOfCameras = Camera.getNumberOfCameras();
for (int i = 0; i < numberOfCameras; i++) {
Camera.CameraInfo info = new Camera.CameraInfo();
Camera.getCameraInfo(i, info);
if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
cameraId = i;
return cameraId;
}
}
return -1;
}

Works Perfectly with Tab S7 with slight modification:
public void barcodeButtonPressed(View v){
IntentIntegrator scanIntegrator = new IntentIntegrator(this);
scanIntegrator.addExtra("SCAN_CAMERA_ID", getFrontCameraId());
//scanIntegrator.addExtra("SCAN_MODE", "PRODUCT_MODE");
scanIntegrator.initiateScan(IntentIntegrator.ALL_CODE_TYPES);
}

We did more testing on other devices and it DOES scan barcodes using the front facing camera using the code above. For some reason on my N5 and N7 it fails, but I'll have to put it down to focus/lighting.
I'll leave the question up in case anyone else wants to confirm ZX does scan barcodes using the front facing camera out of the box.

Detecting lack of rear camera

My app has functionality that requires a rear camera. Whether there is a front camera or not is irrelevant to my needs. Putting together a robust routine to detect whether or not a rear camera exists, in all circumstances, is proving tricky. For example, a user with an HTC Evo 3D has complained that the app says there's no rear camera (there clearly is), and I've had a number of similar complaints from other users.
This is a tricky thing to test, as despite having a number of devices I don't have a device with only a front camera, such as the Nexus 7, or any of the models mentioned by the users.
Here's what I have, and this was taken from code on other answers on this site:
boolean rearCameraFound = false;
if(BUILD_VERSION > 8){
int cameraCount = 0;
Camera cam = null;
Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
cameraCount = Camera.getNumberOfCameras();
for ( int camIdx = 0; camIdx < cameraCount; camIdx++ ) {
Camera.getCameraInfo( camIdx, cameraInfo );
if ( cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_BACK ) {
try {
cam = Camera.open( camIdx );
Log.d("TAG", "Rear camera detected");
rearCameraFound = true;
} catch (RuntimeException e) {
Log.e("TAG", "Camera failed to open: " + e.getLocalizedMessage());
}
}
if ( cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_FRONT ) {
Log.d("TAG", "Front camera detected");
}
}
return rearCameraFound;
}else{
if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA)){
// this device has a camera
return true;
} else {
// no camera on this device
return false;
}
}
I've now replaced this code with this much simpler version:
PackageManager pm = context.getPackageManager();
return pm.hasSystemFeature(PackageManager.FEATURE_CAMERA);
However, I don't know what would happen on the Nexus 7 for example, with only a front camera. Would this return true?
I'm looking for code that will tell me for sure if there's a rear camera or not!

Nexus 7 (which has only one frontal camera) returns false to FEATURE_CAMERA, Instead of it, you can use FEATURE_CAMERA_FRONT. Check out this discussion.
Now, by using the above, you could make sure that there is atleast one camera. So now, you can check the number of camera's present in the phone, if it is greater than one, then there will be surely a rear camera.
import android.hardware.Camera;
int numCameras = Camera.getNumberOfCameras();
if (numCameras > 1) {
rearCamera = true;
}
This is quite tricky. But that's all, I can now think of. Just give it a try.

Use this snippet. Note this only works for API 9 or higher.
private static boolean checkCameraFacing(final int facing) {
if (getSdkVersion() < Build.VERSION_CODES.GINGERBREAD) {
return false;
}
final int cameraCount = Camera.getNumberOfCameras();
CameraInfo info = new CameraInfo();
for (int i = 0; i < cameraCount; i++) {
Camera.getCameraInfo(i, info);
if (facing == info.facing) {
return true;
}
}
return false;
}
public static boolean hasBackFacingCamera() {
final int CAMERA_FACING_BACK = 0;
return checkCameraFacing(CAMERA_FACING_BACK);
}
public static boolean hasFrontFacingCamera() {
final int CAMERA_FACING_BACK = 1;
return checkCameraFacing(CAMERA_FACING_BACK);
}
public static int getSdkVersion() {
return android.os.Build.VERSION.SDK_INT;
}
And this is no need to open the camera.

For front camera
Context context = this; //If its Activity
// Context context=getActivity(); If its a Fragment
PackageManager packageManager = context.getPackageManager();
if (packageManager.hasSystemFeature(PackageManager.FEATURE_CAMERA_FRONT)) {
Log.i("CameraLog", "Front Camera Available");
} else {
Log.i("CameraLog", "No Front Camera Available");
}
for back camera
Context context = this; //If its an Activity
// Context context=getActivity(); If its a fragments
PackageManager packageManager = context.getPackageManager();
if (packageManager.hasSystemFeature(PackageManager.FEATURE_CAMERA)) {
Log.i("CameraLog", "Back Camera is Available");
} else {
Log.i("CameraLog", "No Back Camera Available");
}

If device has one camera only, it can have back camera only, or the front camera only, first check if back camera exists:
Check if front camera exists, but devices with two cameras has front camera obviously
Check if device has one camera only, but it can have back or front camera
Final result: If device has the front camera and it has one camera only, back camera no exists
private boolean backCameraExists() {
boolean isFrontExists = getApplicationContext().getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA_FRONT);
if (isFrontExists && (Camera.getNumberOfCameras()<2)) {
return false;
}
return true;
}

How to detect no of camera's available in android device? and also if the device has front camera how to use it?

How to detect no of camera's available in android device? and also if the device has front camera how to use it?

What I would suggest is similar to doc_180's answer, but should be able to detect both front and back facing cameras even for Froyo, though if I'm not mistaken, Froyo never supported front-facing cameras, so you'll always get a false response for frontCam on Froyo.
PackageManager pm = getPackageManager();
boolean frontCam, rearCam;
//Must have a targetSdk >= 9 defined in the AndroidManifest
frontCam = pm.hasSystemFeature(PackageManager.FEATURE_CAMERA_FRONT);
rearCam = pm.hasSystemFeature(PackageManager.FEATURE_CAMERA);
EDIT: Just realized this is a really, really old question. Oh well, hopefully it helps someone in the future.

Use packagemanager to check if the device supports the Intent. In this case Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
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;
}

CameraInfo cameraInfo = new CameraInfo();
for (int i = 0; i < numberOfCameras; i++) {
Camera.getCameraInfo(i, cameraInfo);
if (cameraInfo.facing == CameraInfo.CAMERA_FACING_FRONT) {
}
}

The quickest way I've found to check if a (backfacing) camera exists is to check if Camera.open() returns null.
Camera cam = Camera.open();
if(null == cam){
//no camera exists
}
This should be available for earlier versions of android as well.

you can use this static method if you just want to know how many cameras there are:
Camera.getNumberOfCameras(); (api 9)

/** Check if this device has a camera */
private boolean checkCameraHardware(Context context) {
if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA)){
// this device has a camera
return true;
} else {
// no camera on this device
return false;
}
}

I am using this method to get the count of the available camera
public int getCameraCount(){
CameraManager manager = (CameraManager) context.getSystemService(Context.CAMERA_SERVICE);
try {
String[] strings = manager.getCameraIdList();
return strings.length;
} catch (CameraAccessException e) {
e.printStackTrace();
return 0;
}
}

Try this, this worked for me in a Moto RAZR HD:
public static Camera open (int cameraId)
Example usage:
mCamera = Camera.open(1);