सैमसंग एस 5

Question

के साथ कैमरा 2 एपीआई ऑटोफोकस मैं सैमसंग एस 5 पर नए कैमरा 2 एपीआई के साथ काम कर रहा हूं। समर्थित डिवाइस स्तर यह डिवाइस रिपोर्टिंग कर रहा है LEGACY है, जो ठीक है।

हालांकि, मैं इस डिवाइस पर ऑटो-फ़ोकस करने में सक्षम नहीं प्रतीत होता। ऑटो फोकस गति प्रदान करने के अनुरोध इस तरह दिखता है: अनुरोध भेज दिया जाता है

previewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_AUTO); 
previewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, CaptureRequest.CONTROL_AF_TRIGGER_START); 
state = STATE_PREVIEW; 
try { 
    captureSession.setRepeatingRequest(previewRequestBuilder.build(), captureCallback, backgroundHandler); 
} catch (CameraAccessException e) { 
    e.printStackTrace(); 
} 

के बाद, अनुरोध के परिणाम हमेशा CONTROL_AF_STATE_ACTIVE_SCAN और कभी-कभी CONTROL_AF_STATE_NOT_FOCUSED_LOCKED है।

अजीब बात यह है कि, जब राज्य CONTROL_AF_STATE_NOT_FOCUSED_LOCKED है, ऑटो फोकस थोड़ी देर के लिए CONTROL_AF_STATE_ACTIVE_SCAN स्थिति में वापस और फिर वापस CONTROL_AF_STATE_NOT_FOCUSED_LOCKED को जाता है, एक अनंत फोकस लूप में परिवर्तित हो जाती है। डॉक्स, जब राज्य CONTROL_AF_STATE_NOT_FOCUSED_LOCKED है ...

लेंस स्थिर जब तक वायुसेना मोड (android.control.afMode) बदल गया है या एक नया वायुसेना ट्रिगर कैमरा डिवाइस (Android के लिए भेजा जाता रहेगा के अनुसार। control.afTrigger)।

मैं इस विसंगति क्योंकि यह सच है कि अगर हार्डवेयर स्तर LEGACY है और मैं वापस पदावनत कैमरा एपीआई का उपयोग करने के लिए जाना चाहिए, लेकिन है कि इस तरह ऑटो फोकस के रूप में इस तरह के एक प्रचलित सुविधा के लिए पागल हो रहा है सोच रहा हूँ ।

क्या कोई संशोधन है कि LEGACY पर रिपोर्ट करने वाले उपकरणों का इलाज कैसे करें?

Answer 1

ऑटोफोकस के साथ सैमसंग एस 5 INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY लौटा, जिसका अर्थ है कि यह Camera2 एपीआई का समर्थन नहीं करता है।

मेरे पास मेरे एप्लिकेशन में कैमरा का उपयोग करने के लिए नीचे दिया गया फ़िल्टर है।

if (Build.VERSION.SDK_INT >= 21 && isDeviceCompatibleOfCamera2()) { 
// Use camera2 
} else { 
// Use old camera 
} 

@TargetApi(Build.VERSION_CODES.LOLLIPOP) 
public boolean isDeviceCompatibleOfCamera2() { 
try { 
    CameraManager manager = (CameraManager) getActivity().getSystemService(Context.CAMERA_SERVICE); 
    String backCameraId = manager.getCameraIdList()[0]; 
    CameraCharacteristics backCameraInfo = manager.getCameraCharacteristics(backCameraId); 

    int level = backCameraInfo.get(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL); 
    return level == CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_FULL; 

    } catch (CameraAccessException e) { 
    ETLog.d(TAG, "Device not compatible of camera2 api" + e); 
    } 
    return false; 
} 

Answer 2

मुझे लगता है कि यह समस्या आपके सेटरेटिंगरक्वैस्ट के साथ है। जहां तक ​​मुझे पता है, CaptureRequest.CONTROL_AF_MODE_AUTO केवल एक ऑटोफोकस होने के कारण होना चाहिए, लेकिन setRepeatingRequest निरंतर अनुरोध भेजेगा। बजाय कब्जा उपयोग करके देखें:

previewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_AUTO); 
previewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, CaptureRequest.CONTROL_AF_TRIGGER_START); 

state = STATE_PREVIEW; 

try { 
mCaptureSession.capture(mPreviewRequestBuilder.build(), mPreCaptureCallback, mBackgroundHandler); 
} catch (Exception e) {e.printStackTrace();} 

Answer 3

मैं के साथ एक गैलेक्सी नोट 4 एंड्रॉयड 5.1.1 चल ही समस्या का सामना - जबकि एक ही कोड अन्य Android उपकरणों की एक किस्म पर ठीक काम करता है। गैलेक्सी-एस 4/एस 5/एस 6 के साथ इसी तरह के मुद्दों की रिपोर्टें हुई हैं। - जो, unfourtunately बहुत कम गुणवत्ता की प्रतीत हो रहा है यह सबसे अधिक संभावना कैमरा -2 कार्यान्वयन की सैमसंग की कार्यान्वयन में एक बग है:

http://developer.samsung.com/forum/board/thread/view.do?boardName=SDK&messageId=289824&startId=zzzzz~ https://www.youtube.com/watch?v=lnMoYZwVaFM

तो तुम सवाल anwer करने के लिए।

Answer 4

मैं प्रपत्र google's Camera2Basic example शाखाओं और CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE

के बजाय CaptureRequest.CONTROL_AF_MODE_AUTO उपयोग करने के लिए उस Git से परियोजना ले जा सकते हैं और परीक्षण यह बदल गया है - https://github.com/pinhassi/android-Camera2Basic

या बस Camera2BasicFragment से जोड़ें:

private static final long LOCK_FOCUS_DELAY_ON_FOCUSED = 5000; 
private static final long LOCK_FOCUS_DELAY_ON_UNFOCUSED = 1000; 

private Integer mLastAfState = null; 
private Handler mUiHandler = new Handler(); // UI handler 
private Runnable mLockAutoFocusRunnable = new Runnable() { 

    @Override 
    public void run() { 
     lockAutoFocus(); 
    } 
}; 


public void lockAutoFocus() { 
    try { 
     // This is how to tell the camera to lock focus. 
     mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, CameraMetadata.CONTROL_AF_TRIGGER_START); 
     CaptureRequest captureRequest = mPreviewRequestBuilder.build(); 
     mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, null); // prevent CONTROL_AF_TRIGGER_START from calling over and over again 
     mCaptureSession.capture(captureRequest, mCaptureCallback, mBackgroundHandler); 
    } catch (CameraAccessException e) { 
     e.printStackTrace(); 
    } 
} 


/** 
* 
* @return 
*/ 
private float getMinimumFocusDistance() { 
    if (mCameraId == null) 
     return 0; 

    Float minimumLens = null; 
    try { 
     CameraManager manager = (CameraManager) getActivity().getSystemService(Context.CAMERA_SERVICE); 
     CameraCharacteristics c = manager.getCameraCharacteristics(mCameraId); 
     minimumLens = c.get(CameraCharacteristics.LENS_INFO_MINIMUM_FOCUS_DISTANCE); 
    } catch (Exception e) { 
     Log.e(TAG, "isHardwareLevelSupported Error", e); 
    } 
    if (minimumLens != null) 
     return minimumLens; 
    return 0; 
} 

/** 
* 
* @return 
*/ 
private boolean isAutoFocusSupported() { 
    return isHardwareLevelSupported(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY) || getMinimumFocusDistance() > 0; 
} 

// Returns true if the device supports the required hardware level, or better. 
@TargetApi(Build.VERSION_CODES.LOLLIPOP) 
private boolean isHardwareLevelSupported(int requiredLevel) { 
    boolean res = false; 
    if (mCameraId == null) 
     return res; 
    try { 
     CameraManager manager = (CameraManager) getActivity().getSystemService(Context.CAMERA_SERVICE); 
     CameraCharacteristics cameraCharacteristics = manager.getCameraCharacteristics(mCameraId); 

     int deviceLevel = cameraCharacteristics.get(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL); 
     switch (deviceLevel) { 
      case CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_3: 
       Log.d(TAG, "Camera support level: INFO_SUPPORTED_HARDWARE_LEVEL_3"); 
       break; 
      case CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_FULL: 
       Log.d(TAG, "Camera support level: INFO_SUPPORTED_HARDWARE_LEVEL_FULL"); 
       break; 
      case CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY: 
       Log.d(TAG, "Camera support level: INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY"); 
       break; 
      case CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED: 
       Log.d(TAG, "Camera support level: INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED"); 
       break; 
      default: 
       Log.d(TAG, "Unknown INFO_SUPPORTED_HARDWARE_LEVEL: " + deviceLevel); 
       break; 
     } 


     if (deviceLevel == CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY) { 
      res = requiredLevel == deviceLevel; 
     } else { 
      // deviceLevel is not LEGACY, can use numerical sort 
      res = requiredLevel <= deviceLevel; 
     } 

    } catch (Exception e) { 
     Log.e(TAG, "isHardwareLevelSupported Error", e); 
    } 
    return res; 
} 

फिर, STATE_PREVIEW ब्लॉक में जोड़ें:

 case STATE_PREVIEW: { 

      // We have nothing to do when the camera preview is working normally. 
      // TODO: handle auto focus 
      Integer afState = result.get(CaptureResult.CONTROL_AF_STATE); 
      if (afState != null && !afState.equals(mLastAfState)) { 
       switch (afState) { 
        case CaptureResult.CONTROL_AF_STATE_INACTIVE: 
         Log.d(TAG, "CaptureResult.CONTROL_AF_STATE_INACTIVE"); 
         lockAutoFocus(); 
         break; 
        case CaptureResult.CONTROL_AF_STATE_ACTIVE_SCAN: 
         Log.d(TAG, "CaptureResult.CONTROL_AF_STATE_ACTIVE_SCAN"); 
         break; 
        case CaptureResult.CONTROL_AF_STATE_FOCUSED_LOCKED: 
         Log.d(TAG, "CaptureResult.CONTROL_AF_STATE_FOCUSED_LOCKED"); 
         mUiHandler.removeCallbacks(mLockAutoFocusRunnable); 
         mUiHandler.postDelayed(mLockAutoFocusRunnable, LOCK_FOCUS_DELAY_ON_FOCUSED); 
         break; 
        case CaptureResult.CONTROL_AF_STATE_NOT_FOCUSED_LOCKED: 
         mUiHandler.removeCallbacks(mLockAutoFocusRunnable); 
         mUiHandler.postDelayed(mLockAutoFocusRunnable, LOCK_FOCUS_DELAY_ON_UNFOCUSED); 
         Log.d(TAG, "CaptureResult.CONTROL_AF_STATE_NOT_FOCUSED_LOCKED"); 
         break; 
        case CaptureResult.CONTROL_AF_STATE_PASSIVE_UNFOCUSED: 
         mUiHandler.removeCallbacks(mLockAutoFocusRunnable); 
         //mUiHandler.postDelayed(mLockAutoFocusRunnable, LOCK_FOCUS_DELAY_ON_UNFOCUSED); 
         Log.d(TAG, "CaptureResult.CONTROL_AF_STATE_PASSIVE_UNFOCUSED"); 
         break; 
        case CaptureResult.CONTROL_AF_STATE_PASSIVE_SCAN: 
         Log.d(TAG, "CaptureResult.CONTROL_AF_STATE_PASSIVE_SCAN"); 
         break; 
        case CaptureResult.CONTROL_AF_STATE_PASSIVE_FOCUSED: 
         mUiHandler.removeCallbacks(mLockAutoFocusRunnable); 
         //mUiHandler.postDelayed(mLockAutoFocusRunnable, LOCK_FOCUS_DELAY_ON_FOCUSED); 
         Log.d(TAG, "CaptureResult.CONTROL_AF_STATE_PASSIVE_FOCUSED"); 
         break; 
       } 
      } 
      mLastAfState = afState; 
      break; 
     } 

और की सभी घटनाओं की जगह:

mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, 
              CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE); 

के साथ:

if (isAutoFocusSupported()) 
           mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, 
             CaptureRequest.CONTROL_AF_MODE_AUTO); 
          else 
           mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, 
             CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);