Compruebe si el dispositivo tiene una cámara.

80

En mi aplicación, me gustaría usar la cámara, si el dispositivo tiene una. ¿Hay algún dispositivo con Android que no tenga cámara? Incluyendo lo siguiente en mi manifiesto:

<uses-feature android:name="android.hardware.camera" android:required="false"/>

entonces básicamente dice "Usaré una cámara si existe, pero no la necesito para ejecutar la aplicación".

¿Cómo puedo comprobar si existe una cámara en el dispositivo antes de intentar utilizar la clase Cámara?

marca
fuente
1
Creo (pero no estoy 100% seguro) que todas las versiones pasadas y presentes del Documento de definición de compatibilidad de Android especifican una cámara con una resolución mínima. El cumplimiento de la CDD es un requisito previo para el acceso con licencia a Android Market y las aplicaciones patentadas de Google. Sin embargo, hay dispositivos Android que no lo hacen (por ejemplo, el color Nook).
ephemient
2
A la fecha, la versión actual del documento (4.2) especifica "Las implementaciones del dispositivo DEBERÍAN incluir una cámara orientada hacia atrás y PUEDEN incluir una cámara frontal". Tenga en cuenta que no utiliza la palabra clave 'DEBE'.
Matthew Blackford
Solo para agregar que también hay dispositivos que solo tienen una cámara frontal.
El Berga
¿Tiene sentido agregar esto al manifiesto, si dice que la aplicación debería funcionar con y sin cámara? ¿Afecta a la aplicación en Play Store, quizás?
desarrollador de Android

Respuestas:

-44

No lo he probado, pero:

private android.hardware.Camera mCameraDevice;

try {
  mCameraDevice = android.hardware.Camera.open();
} catch (RuntimeException e) {
  Log.e(TAG, "fail to connect Camera", e);
  // Throw exception
}

Puede ser lo que necesitas.

user197385
fuente
¡Y no olvide soltar el objeto Cámara!
opedog
11
Consulte la respuesta de dpjanes a continuación para conocer la forma correcta de ver si un dispositivo tiene una cámara.
Zack Marrapese
22
Mal planteamiento. Llamada cara. Si otras aplicaciones abren la misma cámara, se generará una RuntimeException. No se adapta al propósito.
Puntero nulo
5
¡Esta respuesta se ha vuelto tan famosa! :) meta.stackoverflow.com/a/316273/651647
Farshid Zaker
Esta implementación en Android 6.0 (API nivel 23) + arrojaría una SecurityException a menos que hayas solicitado específicamente el permiso "android.permission.CAMERA" en tiempo de ejecución.
Matt G
224

Esto es lo que estoy usando

import android.content.pm.PackageManager;

PackageManager pm = context.getPackageManager();

if (pm.hasSystemFeature(PackageManager.FEATURE_CAMERA)) {
}

También hay disponibles todo tipo de cosas divertidas para probar: la brújula, la ubicación disponible, hay una cámara frontal: http://developer.android.com/reference/android/content/pm/PackageManager.html

dpjanes
fuente
4
pregunta tan rápida. esto puede ser tonto pero soy nuevo en android / java, ¿de dónde sacas el contexto? gracias
grobartn
3
@grobartn:public class YourActivity extends Activity { Context contextActivity; PackageManager pm; @Override public void onCreate(Bundle savedInstanceState) { ... contextActivity = this; pm = contextActivity.getPackageManager(); ...
Klofi
14
Desde el nivel de API 9, es posible que desee verificar FEATURE_CAMERA_FRONT además de FEATURE_CAMERA. Por ejemplo, Nexus 7 (que tiene solo una cámara frontal) devuelve falso a FEATURE_CAMERA.
Jorge Cevallos
6
Para Kindle Fire HD 7 "(Android 4.0.3), descubrí que informa FEATURE_CAMERA, ¡aunque solo tiene una cámara frontal! Horrible ... como solución alternativa, también pruebo (FEATURE_CAMERA_FRONT y Camera.getNumberOfCameras () == 1 ) entonces sé que no hay cámara trasera.
CSmith
6
Después del nivel de API 17, puede usar PackageManager.FEATURE_CAMERA_ANY
XY
42

Para saber cuántas cámaras hay disponibles en su dispositivo, puede llamar a:

import android.hardware.Camera;

int numCameras = Camera.getNumberOfCameras();
if (numCameras > 0) {
  hasCamera = true;
}

Camera.getNumberOfCameras () es estático, por lo que no requiere conectarse a una cámara. Esto funciona desde API 9.

Editar:

Con la API camera2 más reciente, también puede llamar a CameraManager.getCameraIdList () , que proporciona una lista de todas las ID de cámara válidas, en lugar de solo el recuento.

Eddy Talvala
fuente
2
esto funcionó para mí y FEATURE_CAMERA no en API 19
sobelito
Versión de una línea: boolean hasCam = android.hardware.Camera.getNumberOfCameras ()> 0;
J.Jacobs-VP
Esta respuesta es mejor. hasSystemFeature (PackageManager.FEATURE_CAMERA) devuelve falso en Kit-Kat (Nexus 7)
Kirill Karmazin
1
Devuelve falso para Nexus 7 (2013), porque FEATURE_CAMERA solo se trata de cámaras orientadas hacia atrás (debido a la compatibilidad con versiones anteriores); FEATURE_CAMERA_ANY es la característica que es verdadera si hay al menos una cámara de cualquier tipo en el dispositivo.
Eddy Talvala
¿Por qué está android.hardware.Cameraobsoleto? ¿Qué debería usarse en su lugar para esta función? Sé que ahora lo hemos hecho android.hardware.camera2, pero ¿dónde podemos encontrar la alternativa getNumberOfCameras?
desarrollador de Android
12

debe usar esto para encontrar la cámara en su dispositivo

public static boolean isCameraAvailable(Context context) {
    return context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA_ANY);
}
Vishwa
fuente
1
Creo que este es el más útil. FEATURE_CAMERA_ANY es una buena opción. Aquí hay una versión más corta del código para aquellos que lo prefieran. public static boolean isCameraAvailable(Context context) { return context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA_ANY)) }
miva2
6

Camera.getNumberOfCameras () está obsoleto. Puedes usar:

@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public int getNumberOfCameras() {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        try {
            return ((CameraManager) getSystemService(Context.CAMERA_SERVICE)).getCameraIdList().length;
        } catch (CameraAccessException e) {
            Log.e("", "", e);
        }
    }
    return Camera.getNumberOfCameras();
}
Franco
fuente
6

Utilice el método PackageManager.hasSystemFeature () para comprobar la cámara:

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;
    }
}

Fuente: https://developer.android.com/guide/topics/media/camera.html#custom-camera

Nurul Akter Towhid
fuente
3

Prueba esto :

/** 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;
    }
}

de: http://developer.android.com/guide/topics/media/camera.html

samaniego
fuente
3

De la siguiente manera podemos verificar si el dispositivo tiene cámara o no.

/** Check if this device has a camera */
    public static boolean checkCameraHardware(Context context) {
        if (context.getPackageManager().hasSystemFeature(
                PackageManager.FEATURE_CAMERA)) 
        {
            return true;
        }
        else if(context.getPackageManager().hasSystemFeature(
                PackageManager.FEATURE_CAMERA_FRONT))
        {
            return true;
        }
        else {
            return false;
        }
    }
DjP
fuente
1

Si está utilizando Android 2.3, hay algunas API que puede verificar el estado de su cámara, como la cantidad de cámaras (frontal y posterior)

mabeiyi
fuente
1

prueba esto

Para cámara frontal

    Context context = this;
    PackageManager packageManager = context.getPackageManager();
    if (packageManager.hasSystemFeature(PackageManager.FEATURE_CAMERA_FRONT)) {

        Utils.makeAlertDialog(context, "Has Front Camera ?", "YES");

    } else {

        Utils.makeAlertDialog(context, "Has Front Camera ?", "NO");
          }

para cámara trasera

    Context context = this;
    PackageManager packageManager = context.getPackageManager();
    if (packageManager.hasSystemFeature(PackageManager.FEATURE_CAMERA)) {

        Utils.makeAlertDialog(context, "Has back Camera ?", "YES");

    } else {

        Utils.makeAlertDialog(context, "Has back Camera ?", "NO");
          }
Sr. T
fuente
1

Según la documentación de Android:

/** 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;
    }
}

Consulte más información sobre la API de la cámara:
https://developer.android.com/guide/topics/media/camera.html#detect-camera

Googlian
fuente
0

Según la documentación , debe usar el Administrador de paquetes para verificar si la cámara está disponible en el dispositivo o no

En Java:

final boolean isCameraAvailable = getPackageManager().hasSystemFeature(FEATURE_CAMERA);

En Kotlin:

val isCameraAvailable = packageManager.hasSystemFeature(FEATURE_CAMERA)
Srikar Reddy
fuente
0

Encontré en cajas de TV Android donde puedes conectar y reproducir la cámara USB varias veces. En algún momento, el servicio de cámaras comienza a decir que detectó una cámara en el sistema mientras no hay ninguna cámara conectada al sistema. Esto sucede cuando conecta o desconecta la cámara varias veces. Para solucionarlo, encontré que esta solución funciona:

//under oncreate:
//cameraManager = ((CameraManager) getSystemService(Context.CAMERA_SERVICE)); 

public int getNumberOfCameras() {
        int count_ = 0;
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            try {
                count_ = cameraManager.getCameraIdList().length;

                if(count_==1)
                {
                    try {
                        cameraManager.getCameraCharacteristics(cameraManager.getCameraIdList()[0]);
                    }catch (Exception e)
                    {
                        count_ = 0;
                    }
                }

            } catch (Exception e) {
               //e.printStackTrace();
            }
        }
        else {
            count_ = Camera.getNumberOfCameras();
        }

        return count_;
    }
Sourja Banerjee
fuente
0

Solución de una línea:

public static boolean hasCamera(Context context) {
    return context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA);
}

Pon este método en tu clase de proyecto Utils.java.

Henrique Monte
fuente