Kamera2 API-Autofokus mit Samsung S5

Arbeite ich mit der neuen Kamera 2 API auf ein Samsung S5. Die unterstützten hardware-Ebene dieses Gerät ist für die Berichterstattung ist LEGACY, was in Ordnung ist.

Aber ich kann nicht scheinen zu werden in der Lage, auto-Fokus auf dieses Gerät. Die Anforderung auszulösen, auto-Fokus, sieht wie folgt aus:

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

Nachdem die Anfrage gesendet wird, wird das Ergebnis der Anfrage ist immer CONTROL_AF_STATE_ACTIVE_SCAN und gelegentlich CONTROL_AF_STATE_NOT_FOCUSED_LOCKED.

Das merkwürdige ist, dass, wenn der Staat CONTROL_AF_STATE_NOT_FOCUSED_LOCKED die auto-Fokus geht wieder in den CONTROL_AF_STATE_ACTIVE_SCAN Zustand für eine Weile und dann zurück zu CONTROL_AF_STATE_NOT_FOCUSED_LOCKED, was in einer unendlich-Schleife. Laut der docs, wenn der Zustand ist CONTROL_AF_STATE_NOT_FOCUSED_LOCKED...

Das Objektiv wird stationär bleiben, bis die AF-Modus (android.Kontrolle.afMode) geändert wird oder ein neuer AF-trigger gesendet wird, um die Kamera-Gerät (android.Kontrolle.afTrigger).

Frage ich mich, ob diese Diskrepanz ist aufgrund der Tatsache, dass der hardware-Ebene ist LEGACY und dass ich zurückgehen sollte, um mit der veralteten Kamera-API, aber das scheint verrückt für eine so weit verbreitete Features wie Autofokus.

Gibt es jede reccomendations, wie zu behandeln, wie Geräte, die Berichterstattung LEGACY?

Hast du dieses Problem lösen?

InformationsquelleAutor Alex Fu | 2015-11-25

  1. 10

    Ich verzweigte form google Camera2Basic Beispiel und verändert es zu verwenden CaptureRequest.CONTROL_AF_MODE_AUTO statt CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE

    Können Sie das Projekt aus git und test - https://github.com/pinhassi/android-Camera2Basic

    Oder fügen Sie einfach diese zu 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;
}

    Dann, zu ergänzen, zu STATE_PREVIEW block:

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

    Und ersetzen Sie alle vorkommen von:

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

    Mit:

    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);
    Gut gemacht, hat mir sehr geholfen.
    Geholfen als start-Punkt, musste testen und ändern Sie eine Menge
    für mich es hat funktioniert, Prima. welche weiteren Anpassungen hast du aber?
    im nächsten Schritt wurde, wie dies if(supportsContinuousAutoFocus(activity, mCameraId)){ builder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE); } else { builder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_AUTO); builder.set(CaptureRequest.CONTROL_AF_TRIGGER, CaptureRequest.CONTROL_AF_TRIGGER_START); }

    InformationsquelleAutor Asaf Pinhassi

  2. 1

    Ich denke, das Problem mit Ihrer setRepeatingRequest. Soweit ich weiß, CaptureRequest.CONTROL_AF_MODE_AUTO sollte nur dazu führen, dass eine Autofokus-auf einmal auftreten, aber setRepeatingRequest senden kontinuierliche Anfragen. Versuchen Sie es mit capture statt: 

    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();}
    Dies ist, was ich nicht so gut fand ich allerdings, dass seit dem 2. Versuch Bild nehmen, afState ist immer 0 (INAKTIV) anstatt 4 oder 5 (GESPERRT)

    InformationsquelleAutor Nick

  3. 0

    Erlebe ich das gleiche Problem mit einem Galaxy Note 4 mit Android 5.1.1 - während der gleiche code funktioniert auf einer Vielzahl von anderen Android-Geräten. Es gibt Berichte von ähnlichen Problemen mit Galaxie-S4/S5/S6.

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

    So beantworten Sie die Frage: Das ist höchstwahrscheinlich ein bug in Samsungs Implementierung der Kamera-2-Einführung - das scheint zu sein, sehr niedrige Qualität, unfourtunately.

    InformationsquelleAutor user2923748

  4. -2

    Das Samsung S5 mit Autofokus zurückgegeben INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY, was bedeutet, dass es nicht unterstützt Camera2 api.

    Habe ich die unter dem filter für die Kamera verwenden in meiner Anwendung.

    if (Build.VERSION.SDK_INT >= 21 &amp;&amp; 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, &quot;Device not compatible of camera2 api&quot; + e);
    }
    return false;
 }
    Diese Antwort ist falsch. LEGACY-hardware-Unterstützung hat nichts zu tun mit auto-Fokus, Belichtung oder Weißabgleich zu tun hat, im Grunde mit manueller sensor-Steuerung. Ältere Geräte können (und tun) Sie haben noch auto steuert, wenn man Sie richtig zu verwenden. Siehe developer.android.com/reference/android/hardware/camera2/...
    Wie können Sie sagen, wenn CONTROL_AF_MODE_AUTO unterstützt wird? durch die immer LENS_INFO_MINIMUM_FOCUS_DISTANCE Wert, die availvable nur mit hardware-Unterstützung > LEGACY

    InformationsquelleAutor Mayuresh Raut

Schreibe einen Kommentar