拍照时，如果指定的camera不存在，等待2s后重试

电源打开之后，系统需要时间检测到相机

app/src/main/cpp/camera2/ndkcamera.cpp

@@ -25,11 +25,13 @@
 
 static void onAvailabilityCallback(void* context, const char* cameraId)
 {
+    ((NdkCamera*)context)->onAvailabilityCallback(cameraId);
     ALOGI("CameraStatus::onAvailability CameraId: %s", cameraId);
 }
 
 static void onUnavailabilityCallback(void* context, const char* cameraId)
 {
+    ((NdkCamera*)context)->onUnavailabilityCallback(cameraId);
     ALOGI("CameraStatus::onUnavailability CameraId: %s", cameraId);
 }
 
@@ -123,11 +125,9 @@ NdkCamera::NdkCamera(int32_t width, int32_t height, const NdkCamera::CAMERA_PARA
     nightModeSupported = false;
     nightPortraitModeSupported = false;
 
-#ifdef _DEBUG
     camera_manager_cb.context = this;
-    camera_manager_cb.onCameraAvailable = onAvailabilityCallback;
+    camera_manager_cb.onCameraAvailable = ::onAvailabilityCallback;
-    camera_manager_cb.onCameraUnavailable = onUnavailabilityCallback;
+    camera_manager_cb.onCameraUnavailable = ::onUnavailabilityCallback;
-#endif
 
     camera_manager = 0;
     camera_device = 0;
@@ -144,8 +144,6 @@ NdkCamera::NdkCamera(int32_t width, int32_t height, const NdkCamera::CAMERA_PARA
 NdkCamera::~NdkCamera()
 {
     close();
-
-
 }
 
 int NdkCamera::open(const std::string& cameraId) {
@@ -154,52 +152,57 @@ int NdkCamera::open(const std::string& cameraId) {
     // camera_facing = _camera_facing;
 
     camera_manager = ACameraManager_create();
-#ifdef _DEBUG
     ACameraManager_registerAvailabilityCallback(camera_manager, &camera_manager_cb);
-#endif
 
-    // find front camera
+    // find camera
-    std::string camera_id;
     bool foundIt = false;
     DisplayDimension disp(mWidth, mHeight);
     DisplayDimension foundRes = disp;
 
+
     {
         ACameraIdList *camera_id_list = 0;
+        for (int retry = 0; retry < 2; retry++)
+        {
             ACameraManager_getCameraIdList(camera_manager, &camera_id_list);
+            // ACameraManager_getCameraIdList will fire AvailabilityCallback
 
-        for (int i = 0; i < camera_id_list->numCameras; ++i)
+            for (int i = 0; i < camera_id_list->numCameras; ++i) {
-        {
                 const char *id = camera_id_list->cameraIds[i];
-            if (cameraId.compare(id) != 0) {
+                if (cameraId.compare(id) == 0) {
-                continue;
+                    foundIt = true;
+                    break;
+                }
             }
-            ACameraMetadata * camera_metadata = 0;
-            ACameraManager_getCameraCharacteristics(camera_manager, id, &camera_metadata);
 
-            // query faceing
+            ACameraManager_deleteCameraIdList(camera_id_list);
-            acamera_metadata_enum_android_lens_facing_t facing = ACAMERA_LENS_FACING_FRONT;
+            if (foundIt)
             {
-                ACameraMetadata_const_entry e = {0};
+                break;
-                ACameraMetadata_getConstEntry(camera_metadata, ACAMERA_LENS_FACING, &e);
-                facing = (acamera_metadata_enum_android_lens_facing_t) e.data.u8[0];
             }
 
-            camera_facing = facing;
+            if (retry == 0)
-
-            camera_id = cameraId;
-            camera_id.assign(id, strlen(id));
-
-            // query orientation
-            int orientation = 0;
             {
-                ACameraMetadata_const_entry e = {0};
+                for (int idx = 0; idx < 128; idx++)
-                ACameraMetadata_getConstEntry(camera_metadata, ACAMERA_SENSOR_ORIENTATION, &e);
+                {
+                    if (IsCameraAvailable(cameraId))
+                    {
+                        break;
+                    }
+                    std::this_thread::sleep_for(std::chrono::milliseconds(16));
+                }
+            }
+        }
 
-                orientation = (int) e.data.i32[0];
+        if (!foundIt)
+        {
+            return 1;
         }
 
-            camera_orientation = orientation;
+        mCameraId = cameraId;
+
+        ACameraMetadata * camera_metadata = 0;
+        ACameraManager_getCameraCharacteristics(camera_manager, cameraId.c_str(), &camera_metadata);
 
         {
             ACameraMetadata_const_entry e = {0};
@@ -209,6 +212,7 @@ int NdkCamera::open(const std::string& cameraId) {
             // DisplayDimension foundRes(4000, 4000);
             // DisplayDimension maxJPG(0, 0);
 
+            foundIt = false;
             unsigned long long minRatio = -1;
             DisplayDimension temp;
             unsigned long long pixels = (unsigned long long)mWidth * mHeight;
@@ -251,11 +255,36 @@ int NdkCamera::open(const std::string& cameraId) {
             }
         }
 
+        if (!foundIt)
+        {
+            ACameraMetadata_free(camera_metadata);
+            ALOGE("Camera RES(%d, %d) Not Found on ID: %s", mWidth, mHeight, cameraId.c_str());
+            return 1;
+        }
+
+        // query faceing
+        acamera_metadata_enum_android_lens_facing_t facing = ACAMERA_LENS_FACING_FRONT;
         {
             ACameraMetadata_const_entry e = {0};
-                camera_status_t status = ACameraMetadata_getConstEntry(camera_metadata,ACAMERA_LENS_INFO_MINIMUM_FOCUS_DISTANCE, &e);
+            ACameraMetadata_getConstEntry(camera_metadata, ACAMERA_LENS_FACING, &e);
+            facing = (acamera_metadata_enum_android_lens_facing_t) e.data.u8[0];
+        }
+        camera_facing = facing;
+
+        // query orientation
+        int orientation = 0;
+        {
+            ACameraMetadata_const_entry e = {0};
+            ACameraMetadata_getConstEntry(camera_metadata, ACAMERA_SENSOR_ORIENTATION, &e);
+            orientation = (int) e.data.i32[0];
+        }
+        camera_orientation = orientation;
 
+        {
+            ACameraMetadata_const_entry e = {0};
+            camera_status_t status = ACameraMetadata_getConstEntry(camera_metadata,ACAMERA_LENS_INFO_MINIMUM_FOCUS_DISTANCE, &e);
         }
+
         {
             ACameraMetadata_const_entry e = {0};
             camera_status_t status = ACameraMetadata_getConstEntry(camera_metadata,ACAMERA_CONTROL_AF_AVAILABLE_MODES, &e);
@@ -339,36 +368,8 @@ int NdkCamera::open(const std::string& cameraId) {
         }
 
         ACameraMetadata_free(camera_metadata);
-
-            break;
-        }
-
-        ACameraManager_deleteCameraIdList(camera_id_list);
     }
 
-    if (camera_id.empty() || !foundIt) {
-        ALOGE("CameraId %s With RES(%d, %d) Not Found", cameraId.c_str(), mWidth, mHeight);
-        return 1;
-    }
-
-    // TODO: PATCH!!!!
-    if (camera_id == "0")
-    {
-        // afSupported = true;
-    }
-    if (camera_id == "1")
-    {
-#if 0
-        camera_facing = 1;
-#endif
-    }
-    if (camera_id == "2")
-    {
-        // camera_orientation += 180;
-    }
-
-    mCameraId = camera_id;
-
     camera_status_t res = ACAMERA_OK;
     // setup imagereader and its surface
     {
@@ -394,7 +395,7 @@ int NdkCamera::open(const std::string& cameraId) {
         camera_device_state_callbacks.onDisconnected = onDisconnected;
         camera_device_state_callbacks.onError = onError;
 
-        res = ACameraManager_openCamera(camera_manager, camera_id.c_str(), &camera_device_state_callbacks, &camera_device);
+        res = ACameraManager_openCamera(camera_manager, cameraId.c_str(), &camera_device_state_callbacks, &camera_device);
         if (res != ACAMERA_OK)
         {
             ALOGE("Failed to open camera res=%d", res);
@@ -402,7 +403,7 @@ int NdkCamera::open(const std::string& cameraId) {
         }
     }
 
-    ALOGI("CameraStatus::Open %s %d", camera_id.c_str(), camera_orientation);
+    ALOGI("CameraStatus::Open %s %d", cameraId.c_str(), camera_orientation);
 
     // std::this_thread::sleep_for(std::chrono::milliseconds(128));
     // capture request
@@ -573,9 +574,7 @@ void NdkCamera::close()
 
     if (camera_manager)
     {
-#ifdef _DEBUG
         ACameraManager_unregisterAvailabilityCallback(camera_manager, &camera_manager_cb);
-#endif
         ACameraManager_delete(camera_manager);
         camera_manager = 0;
     }
@@ -846,3 +845,29 @@ void NdkCamera::onCaptureCompleted(ACameraCaptureSession* session, ACaptureReque
 
     // __android_log_print(ANDROID_LOG_WARN, "NdkCamera", "onCaptureCompleted %p %p %p", session, request, result);
 }
+
+void NdkCamera::onAvailabilityCallback(const char* cameraId)
+{
+    std::string s(cameraId);
+    m_locker.lock();
+    m_availableCameras.insert(s);
+    m_locker.unlock();
+
+}
+void NdkCamera::onUnavailabilityCallback(const char* cameraId)
+{
+    std::string s(cameraId);
+    m_locker.lock();
+    m_availableCameras.erase(s);
+    m_locker.unlock();
+}
+
+bool NdkCamera::IsCameraAvailable(const std::string& cameraId)
+{
+    bool existed = false;
+    m_locker.lock();
+    existed = (m_availableCameras.find(cameraId) != m_availableCameras.cend());
+    m_locker.unlock();
+
+    return existed;
+}

app/src/main/cpp/camera2/ndkcamera.h

@@ -22,6 +22,8 @@
 
 #include <opencv2/core/core.hpp>
 #include "Camera2Helper.h"
+#include <mutex>
+#include <set>
 
 /**
  * Range of Camera Exposure Time:
@@ -67,6 +69,8 @@ public:
     int open(const std::string& cameraId);
     void close();
 
+    void onAvailabilityCallback(const char* cameraId);
+    void onUnavailabilityCallback(const char* cameraId);
     void onImageAvailable(AImageReader* reader);
     virtual bool on_image(cv::Mat& rgb);
     virtual void on_error(const std::string& msg);
@@ -79,8 +83,13 @@ public:
         return mResult;
     }
 
+    bool IsCameraAvailable(const std::string& cameraId);
 
-public:
+protected:
+    std::mutex m_locker;
+    std::set<std::string> m_availableCameras;
+
+protected:
     CAMERA_PARAMS m_params;
     int camera_facing;
     int camera_orientation;
@@ -104,10 +113,9 @@ public:
 
     CAPTURE_RESULT mResult;
 
-private:
+protected:
-#ifdef _DEBUG
+
     ACameraManager_AvailabilityCallbacks camera_manager_cb;
-#endif
     ACameraManager* camera_manager;
     ACameraDevice* camera_device;
     AImageReader* image_reader;