Чтобы переводить контент на ваш предпочитаемый язык, Google использует технологии на основе искусственного интеллекта. Переводы от ИИ могут содержать ошибки.

Мигание экрана

Мигание экрана, также называемое передней вспышкой или вспышкой для селфи, использует яркость экрана телефона для освещения объекта при съемке изображений с помощью фронтальной камеры в условиях низкой освещенности. Она доступна во многих встроенных приложениях камеры и социальных сетей. Поскольку большинство людей держат телефон достаточно близко, когда делают селфи, этот подход эффективен.

Однако разработчикам сложно реализовать эту функцию должным образом и поддерживать хорошее качество записи на разных устройствах. В этом руководстве рассказывается, как правильно реализовать эту функцию с помощью Camera2 – низкоуровневого API фреймворка камеры Android.

Общий рабочий процесс

Чтобы правильно реализовать эту функцию, необходимо использовать последовательность замера перед съемкой (автоматическая экспозиция перед съемкой) и правильно рассчитать время операций. Общий рабочий процесс показан на рисунке 1.

Блок-схема, показывающая, как интерфейс мигания экрана используется в Camera2. — **Рисунок 1.** Общий рабочий процесс для реализации мигания экрана.

Ниже описано, как сделать снимок с помощью функции мигания экрана.

Примените изменения интерфейса, необходимые для вспышки экрана, которая может обеспечить достаточное количество света для съемки фотографий с помощью экрана устройства. Для общих случаев использования Google предлагает следующие изменения интерфейса, которые мы применяли в своих тестах:
- Экран приложения покрыт белым оверлеем.
- Яркость экрана установлена на максимум.
Установите режим автоматической экспозиции (AE) на CONTROL_AE_MODE_ON_EXTERNAL_FLASH, если он поддерживается.
Запустите предварительную съемку с помощью CONTROL_AE_PRECAPTURE_TRIGGER.
Дождитесь, пока автоматическая экспозиция и автоматический баланс белого не будут сведены.

Примечание. Прежде чем проверять, сошлись ли значения AE и AWB, убедитесь, что начался новый предварительный захват AE. В противном случае значения AE и AWB могут сойтись с другими состояниями, которые были до триггера предварительного захвата.
После этого используется обычный процесс съемки.
Отправка запроса на захват в фреймворк.
Дождитесь результатов.
Сбросить режим автоэкспозиции, если было задано значение CONTROL_AE_MODE_ON_EXTERNAL_FLASH.
Очистить изменения интерфейса для мигания экрана.

Образцы кода Camera2

Экран приложения закрыт белым оверлеем

Добавьте View в XML-файл макета приложения. У него достаточная высота, чтобы находиться поверх всех остальных элементов интерфейса во время съемки с миганием экрана. По умолчанию он скрыт и становится видимым, только когда применяются изменения интерфейса мигания экрана.

В примере кода ниже для представления используется белый цвет (#FFFFFF). Приложения могут выбирать цвет или предлагать пользователям несколько цветов в зависимости от их требований.

<View
    android:id="@+id/white_color_overlay"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="#FFFFFF"
    android:visibility="invisible"
    android:elevation="8dp" />

Увеличить яркость экрана до максимума

Изменить яркость экрана в приложении для Android можно несколькими способами. Один из них – изменить параметр screenBrightness WindowManager в ссылке Activity Window.

Kotlin

private var previousBrightness: Float = -1.0f

private fun maximizeScreenBrightness() {
    activity?.window?.let { window ->
        window.attributes?.apply {
            previousBrightness = screenBrightness
            screenBrightness = 1f
            window.attributes = this
        }
    }
}

private fun restoreScreenBrightness() {
    activity?.window?.let { window ->
        window.attributes?.apply {
            screenBrightness = previousBrightness
            window.attributes = this
        }
    }
}

Java

private float mPreviousBrightness = -1.0f;

private void maximizeScreenBrightness() {
    if (getActivity() == null || getActivity().getWindow() == null) {
        return;
    }

    Window window = getActivity().getWindow();
    WindowManager.LayoutParams attributes = window.getAttributes();

    mPreviousBrightness = attributes.screenBrightness;
    attributes.screenBrightness = 1f;
    window.setAttributes(attributes);
}

private void restoreScreenBrightness() {
    if (getActivity() == null || getActivity().getWindow() == null) {
        return;
    }

    Window window = getActivity().getWindow();
    WindowManager.LayoutParams attributes = window.getAttributes();

    attributes.screenBrightness = mPreviousBrightness;
    window.setAttributes(attributes);
}

Установить режим автоэкспозиции `CONTROL_AE_MODE_ON_EXTERNAL_FLASH`

CONTROL_AE_MODE_ON_EXTERNAL_FLASH доступен для уровня API 28 и выше. Однако этот режим доступен не на всех устройствах, поэтому проверьте, доступен ли он, и установите соответствующее значение. Чтобы проверить доступность, используйте CameraCharacteristics#CONTROL_AE_AVAILABLE_MODES.

Kotlin

private val characteristics: CameraCharacteristics by lazy {
    cameraManager.getCameraCharacteristics(cameraId)
}

@RequiresApi(Build.VERSION_CODES.P)
private fun isExternalFlashAeModeAvailable() =
    characteristics.get(CameraCharacteristics.CONTROL_AE_AVAILABLE_MODES)
        ?.contains(CaptureRequest.CONTROL_AE_MODE_ON_EXTERNAL_FLASH) ?: false

Java

try {
    mCharacteristics = mCameraManager.getCameraCharacteristics(mCameraId);
} catch (CameraAccessException e) {
    e.printStackTrace();
}

@RequiresApi(Build.VERSION_CODES.P)
private boolean isExternalFlashAeModeAvailable() {
    int[] availableAeModes = mCharacteristics.get(CameraCharacteristics.CONTROL_AE_AVAILABLE_MODES);

    for (int aeMode : availableAeModes) {
        if (aeMode == CaptureRequest.CONTROL_AE_MODE_ON_EXTERNAL_FLASH) {
            return true;
        }
    }
    return false;
}

Если в приложении задан повторяющийся запрос на съемку (он необходим для предварительного просмотра), режим автоэкспозиции нужно установить для повторяющегося запроса. В противном случае при следующей повторяющейся съемке он может быть переопределен режимом автоэкспозиции, заданным по умолчанию или пользователем. В этом случае у камеры может не хватить времени на выполнение всех операций, которые обычно выполняются в режиме автоматической экспозиции с внешней вспышкой.

Чтобы убедиться, что камера полностью обработала запрос на обновление режима AE, проверьте результат съемки в обратном вызове повторяющейся съемки и дождитесь обновления режима AE в результате.

Обратный вызов захвата, который может ожидать обновления режима автоэкспозиции.

В приведенном ниже фрагменте кода показано, как это сделать.

Kotlin

private val repeatingCaptureCallback = object : CameraCaptureSession.CaptureCallback() {
    private var targetAeMode: Int? = null
    private var aeModeUpdateDeferred: CompletableDeferred? = null

    suspend fun awaitAeModeUpdate(targetAeMode: Int) {
        this.targetAeMode = targetAeMode
        aeModeUpdateDeferred = CompletableDeferred()
        // Makes the current coroutine wait until aeModeUpdateDeferred is completed. It is
        // completed once targetAeMode is found in the following capture callbacks
        aeModeUpdateDeferred?.await()
    }

    private fun process(result: CaptureResult) {
        // Checks if AE mode is updated and completes any awaiting Deferred
        aeModeUpdateDeferred?.let {
            val aeMode = result[CaptureResult.CONTROL_AE_MODE]
            if (aeMode == targetAeMode) {
                it.complete(Unit)
            }
        }
    }

    override fun onCaptureCompleted(
        session: CameraCaptureSession,
        request: CaptureRequest,
        result: TotalCaptureResult
    ) {
        super.onCaptureCompleted(session, request, result)
        process(result)
    }
}

Java

static class AwaitingCaptureCallback extends CameraCaptureSession.CaptureCallback {
    private int mTargetAeMode;
    private CountDownLatch mAeModeUpdateLatch = null;

    public void awaitAeModeUpdate(int targetAeMode) {
        mTargetAeMode = targetAeMode;
        mAeModeUpdateLatch = new CountDownLatch(1);
        // Makes the current thread wait until mAeModeUpdateLatch is released, it will be
        // released once targetAeMode is found in the capture callbacks below
        try {
            mAeModeUpdateLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void process(CaptureResult result) {
        // Checks if AE mode is updated and decrements the count of any awaiting latch
        if (mAeModeUpdateLatch != null) {
            int aeMode = result.get(CaptureResult.CONTROL_AE_MODE);
            if (aeMode == mTargetAeMode) {
                mAeModeUpdateLatch.countDown();
            }
        }
    }

    @Override
    public void onCaptureCompleted(@NonNull CameraCaptureSession session,
            @NonNull CaptureRequest request,
            @NonNull TotalCaptureResult result) {
        super.onCaptureCompleted(session, request, result);
        process(result);
    }
}

private final AwaitingCaptureCallback mRepeatingCaptureCallback = new AwaitingCaptureCallback();

Настройте повторяющийся запрос, чтобы включить или отключить режим AE.

В приведенных ниже примерах кода показано, как настроить повторяющийся запрос с помощью обратного вызова.

Kotlin

/** [HandlerThread] where all camera operations run */
private val cameraThread = HandlerThread("CameraThread").apply { start() }

/** [Handler] corresponding to [cameraThread] */
private val cameraHandler = Handler(cameraThread.looper)

private suspend fun enableExternalFlashAeMode() {
    if (Build.VERSION.SDK_INT >= 28 && isExternalFlashAeModeAvailable()) {
        session.setRepeatingRequest(
            camera.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW).apply {
                addTarget(previewSurface)
                set(
                    CaptureRequest.CONTROL_AE_MODE,
                    CaptureRequest.CONTROL_AE_MODE_ON_EXTERNAL_FLASH
                )
            }.build(), repeatingCaptureCallback, cameraHandler
        )

        // Wait for the request to be processed by camera
        repeatingCaptureCallback.awaitAeModeUpdate(CaptureRequest.CONTROL_AE_MODE_ON_EXTERNAL_FLASH)
    }
}

private fun disableExternalFlashAeMode() {
    if (Build.VERSION.SDK_INT >= 28 && isExternalFlashAeModeAvailable()) {
        session.setRepeatingRequest(
            camera.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW).apply {
                addTarget(previewSurface)
            }.build(), repeatingCaptureCallback, cameraHandler
        )
    }
}

Java

private void setupCameraThread() {
    // HandlerThread where all camera operations run
    HandlerThread cameraThread = new HandlerThread("CameraThread");
    cameraThread.start();

    // Handler corresponding to cameraThread
    mCameraHandler = new Handler(cameraThread.getLooper());
}

private void enableExternalFlashAeMode() {
    if (Build.VERSION.SDK_INT >= 28 && isExternalFlashAeModeAvailable()) {
        try {
            CaptureRequest.Builder requestBuilder = mCamera.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
            requestBuilder.addTarget(mPreviewSurface);
            requestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON_EXTERNAL_FLASH);
            mSession.setRepeatingRequest(requestBuilder.build(), mRepeatingCaptureCallback, mCameraHandler);
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }

        // Wait for the request to be processed by camera
        mRepeatingCaptureCallback.awaitAeModeUpdate(CaptureRequest.CONTROL_AE_MODE_ON_EXTERNAL_FLASH);
    }
}

private void disableExternalFlashAeMode() {
    if (Build.VERSION.SDK_INT >= 28 && isExternalFlashAeModeAvailable()) {
        try {
            CaptureRequest.Builder requestBuilder = mCamera.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
            requestBuilder.addTarget(mPreviewSurface);
            mSession.setRepeatingRequest(requestBuilder.build(), mRepeatingCaptureCallback, mCameraHandler);
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }
}

Как запустить предварительную съемку

Чтобы запустить последовательность замера перед съемкой, отправьте CaptureRequest со значением CONTROL_AE_PRECAPTURE_TRIGGER_START, заданным для запроса. Дождитесь обработки запроса, а затем – схождения автоматической экспозиции и автоматического баланса белого.

Хотя предварительная съемка запускается с помощью одного запроса на съемку, ожидание сходимости AE и AWB требует большей сложности. Вы можете отслеживать состояние автоматической экспозиции и состояние автоматического баланса белого с помощью обратного вызова захвата, настроенного на повторяющийся запрос.

Обновление одного и того же повторяющегося обратного вызова позволяет упростить код. Приложениям часто требуется предварительный просмотр, для которого они настраивают повторяющийся запрос при настройке камеры. Таким образом, вы можете установить обратный вызов повторяющегося захвата для этого начального повторяющегося запроса один раз, а затем повторно использовать его для проверки результатов и целей ожидания.

Обновление кода обратного вызова для ожидания конвергенции

Чтобы обновить обратный вызов повторяющейся съемки, используйте следующий фрагмент кода:

Kotlin

private val repeatingCaptureCallback = object : CameraCaptureSession.CaptureCallback() {
    private var targetAeMode: Int? = null
    private var aeModeUpdateDeferred: CompletableDeferred? = null

    private var convergenceDeferred: CompletableDeferred? = null

    suspend fun awaitAeModeUpdate(targetAeMode: Int) {
        this.targetAeMode = targetAeMode
        aeModeUpdateDeferred = CompletableDeferred()
        // Makes the current coroutine wait until aeModeUpdateDeferred is completed. It is
        // completed once targetAeMode is found in the following capture callbacks
        aeModeUpdateDeferred?.await()
    }

    suspend fun awaitAeAwbConvergence() {
        convergenceDeferred = CompletableDeferred()
        // Makes the current coroutine wait until convergenceDeferred is completed, it will be
        // completed once both AE & AWB are reported as converged in the capture callbacks below
        convergenceDeferred?.await()
    }

    private fun process(result: CaptureResult) {
        // Checks if AE mode is updated and completes any awaiting Deferred
        aeModeUpdateDeferred?.let {
            val aeMode = result[CaptureResult.CONTROL_AE_MODE]
            if (aeMode == targetAeMode) {
                it.complete(Unit)
            }
        }

        // Checks for convergence and completes any awaiting Deferred
        convergenceDeferred?.let {
            val aeState = result[CaptureResult.CONTROL_AE_STATE]
            val awbState = result[CaptureResult.CONTROL_AWB_STATE]

            val isAeReady = (
                    aeState == null // May be null in some devices (e.g. legacy camera HW level)
                            || aeState == CaptureResult.CONTROL_AE_STATE_CONVERGED
                            || aeState == CaptureResult.CONTROL_AE_STATE_FLASH_REQUIRED
                    )

            val isAwbReady = (
                    awbState == null // May be null in some devices (e.g. legacy camera HW level)
                            || awbState == CaptureResult.CONTROL_AWB_STATE_CONVERGED
                    )

            if (isAeReady && isAwbReady) {
                // if any non-null convergenceDeferred is set, complete it
                it.complete(Unit)
            }
        }
    }

    override fun onCaptureCompleted(
        session: CameraCaptureSession,
        request: CaptureRequest,
        result: TotalCaptureResult
    ) {
        super.onCaptureCompleted(session, request, result)
        process(result)
    }
}

Java

static class AwaitingCaptureCallback extends CameraCaptureSession.CaptureCallback {
    private int mTargetAeMode;
    private CountDownLatch mAeModeUpdateLatch = null;

    private CountDownLatch mConvergenceLatch = null;

    public void awaitAeModeUpdate(int targetAeMode) {
        mTargetAeMode = targetAeMode;
        mAeModeUpdateLatch = new CountDownLatch(1);
        // Makes the current thread wait until mAeModeUpdateLatch is released, it will be
        // released once targetAeMode is found in the capture callbacks below
        try {
            mAeModeUpdateLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void awaitAeAwbConvergence() {
        mConvergenceLatch = new CountDownLatch(1);
        // Makes the current coroutine wait until mConvergenceLatch is released, it will be
        // released once both AE & AWB are reported as converged in the capture callbacks below
        try {
            mConvergenceLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void process(CaptureResult result) {
        // Checks if AE mode is updated and decrements the count of any awaiting latch
        if (mAeModeUpdateLatch != null) {
            int aeMode = result.get(CaptureResult.CONTROL_AE_MODE);
            if (aeMode == mTargetAeMode) {
                mAeModeUpdateLatch.countDown();
            }
        }

        // Checks for convergence and decrements the count of any awaiting latch
        if (mConvergenceLatch != null) {
            Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE);
            Integer awbState = result.get(CaptureResult.CONTROL_AWB_STATE);

            boolean isAeReady = (
                    aeState == null // May be null in some devices (e.g. legacy camera HW level)
                            || aeState == CaptureResult.CONTROL_AE_STATE_CONVERGED
                            || aeState == CaptureResult.CONTROL_AE_STATE_FLASH_REQUIRED
            );

            boolean isAwbReady = (
                    awbState == null // May be null in some devices (e.g. legacy camera HW level)
                            || awbState == CaptureResult.CONTROL_AWB_STATE_CONVERGED
            );

            if (isAeReady && isAwbReady) {
                mConvergenceLatch.countDown();
                mConvergenceLatch = null;
            }
        }
    }

    @Override
    public void onCaptureCompleted(@NonNull CameraCaptureSession session,
            @NonNull CaptureRequest request,
            @NonNull TotalCaptureResult result) {
        super.onCaptureCompleted(session, request, result);
        process(result);
    }
}

Установите обратный вызов для повторяющегося запроса во время настройки камеры.

В приведенном ниже примере кода показано, как настроить обратный вызов для повторяющегося запроса во время инициализации.

Kotlin

// Open the selected camera
camera = openCamera(cameraManager, cameraId, cameraHandler)

// Creates list of Surfaces where the camera will output frames
val targets = listOf(previewSurface, imageReaderSurface)

// Start a capture session using our open camera and list of Surfaces where frames will go
session = createCameraCaptureSession(camera, targets, cameraHandler)

val captureRequest = camera.createCaptureRequest(
        CameraDevice.TEMPLATE_PREVIEW).apply { addTarget(previewSurface) }

// This will keep sending the capture request as frequently as possible until the
// session is torn down or session.stopRepeating() is called
session.setRepeatingRequest(captureRequest.build(), repeatingCaptureCallback, cameraHandler)

Java

// Open the selected camera
mCamera = openCamera(mCameraManager, mCameraId, mCameraHandler);

// Creates list of Surfaces where the camera will output frames
List targets = new ArrayList<>(Arrays.asList(mPreviewSurface, mImageReaderSurface));

// Start a capture session using our open camera and list of Surfaces where frames will go
mSession = createCaptureSession(mCamera, targets, mCameraHandler);

try {
    CaptureRequest.Builder requestBuilder = mCamera.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
    requestBuilder.addTarget(mPreviewSurface);

    // This will keep sending the capture request as frequently as possible until the
    // session is torn down or session.stopRepeating() is called
    mSession.setRepeatingRequest(requestBuilder.build(), mRepeatingCaptureCallback, mCameraHandler);
} catch (CameraAccessException e) {
    e.printStackTrace();
}

Запуск и ожидание последовательности предварительной съемки

После настройки обратного вызова вы можете использовать следующий пример кода для запуска и ожидания последовательности предварительной съемки.

Kotlin

private suspend fun runPrecaptureSequence() {
    // Creates a new capture request with CONTROL_AE_PRECAPTURE_TRIGGER_START
    val captureRequest = session.device.createCaptureRequest(
        CameraDevice.TEMPLATE_PREVIEW
    ).apply {
        addTarget(previewSurface)
        set(
            CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER,
            CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER_START
        )
    }

    val precaptureDeferred = CompletableDeferred()
    session.capture(captureRequest.build(), object: CameraCaptureSession.CaptureCallback() {
        override fun onCaptureCompleted(
            session: CameraCaptureSession,
            request: CaptureRequest,
            result: TotalCaptureResult
        ) {
            // Waiting for this callback ensures the precapture request has been processed
            precaptureDeferred.complete(Unit)
        }
    }, cameraHandler)

    precaptureDeferred.await()

    // Precapture trigger request has been processed, we can wait for AE & AWB convergence now
    repeatingCaptureCallback.awaitAeAwbConvergence()
}

Java

private void runPrecaptureSequence() {
    // Creates a new capture request with CONTROL_AE_PRECAPTURE_TRIGGER_START
    try {
        CaptureRequest.Builder requestBuilder =
                mSession.getDevice().createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
        requestBuilder.addTarget(mPreviewSurface);
        requestBuilder.set(CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER,
                CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER_START);

        CountDownLatch precaptureLatch = new CountDownLatch(1);
        mSession.capture(requestBuilder.build(), new CameraCaptureSession.CaptureCallback() {
            @Override
            public void onCaptureCompleted(@NonNull CameraCaptureSession session,
                                           @NonNull CaptureRequest request,
                                           @NonNull TotalCaptureResult result) {
                Log.d(TAG, "CONTROL_AE_PRECAPTURE_TRIGGER_START processed");
                // Waiting for this callback ensures the precapture request has been processed
                precaptureLatch.countDown();
            }
        }, mCameraHandler);

        precaptureLatch.await();

        // Precapture trigger request has been processed, we can wait for AE & AWB convergence now
        mRepeatingCaptureCallback.awaitAeAwbConvergence();
    } catch (CameraAccessException | InterruptedException e) {
        e.printStackTrace();
    }
}

Объедините все вместе

Когда все основные компоненты готовы, каждый раз, когда нужно сделать снимок, например когда пользователь нажимает кнопку съемки, все шаги могут выполняться в порядке, указанном в предыдущем обсуждении и примерах кода.

Kotlin

// User clicks captureButton to take picture
captureButton.setOnClickListener { v ->
    // Apply the screen flash related UI changes
    whiteColorOverlayView.visibility = View.VISIBLE
    maximizeScreenBrightness()

    // Perform I/O heavy operations in a different scope
    lifecycleScope.launch(Dispatchers.IO) {
        // Enable external flash AE mode and wait for it to be processed
        enableExternalFlashAeMode()

        // Run precapture sequence and wait for it to complete
        runPrecaptureSequence()

        // Start taking picture and wait for it to complete
        takePhoto()

        disableExternalFlashAeMode()
        v.post {
            // Clear the screen flash related UI changes
            restoreScreenBrightness()
            whiteColorOverlayView.visibility = View.INVISIBLE
        }
    }
}

Java

// User clicks captureButton to take picture
mCaptureButton.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        // Apply the screen flash related UI changes
        mWhiteColorOverlayView.setVisibility(View.VISIBLE);
        maximizeScreenBrightness();

        // Perform heavy operations in a different thread
        Executors.newSingleThreadExecutor().execute(() -> {
            // Enable external flash AE mode and wait for it to be processed
            enableExternalFlashAeMode();

            // Run precapture sequence and wait for it to complete
            runPrecaptureSequence();

            // Start taking picture and wait for it to complete
            takePhoto();

            disableExternalFlashAeMode();

            v.post(() -> {
                // Clear the screen flash related UI changes
                restoreScreenBrightness();
                mWhiteColorOverlayView.setVisibility(View.INVISIBLE);
            });
        });
    }
});

Образцы изображений

Ниже приведены примеры правильной и неправильной реализации мигания экрана.

Неправильный подход

Если мигание экрана реализовано неправильно, результаты будут отличаться в зависимости от устройства, освещения и других условий. Часто у снятых изображений есть проблемы с экспозицией или оттенком цвета. На некоторых устройствах такие ошибки становятся более очевидными при определенных условиях освещения, например при слабом освещении, а не в полной темноте.

В таблице ниже приведены примеры таких проблем. Они сделаны в лаборатории CameraX с источниками теплого белого света. Этот источник теплого белого света позволяет увидеть, что синий оттенок – это реальная проблема, а не побочный эффект источника света.

Среда	Недостаточная экспозиция	Передержка	Оттенок цвета
Темная среда (нет источника света, кроме телефона)
Слабое освещение (дополнительный источник света около 3 люкс)

Если все сделано правильно,

В таблице ниже показаны результаты, которые вы получите, если будете использовать стандартную реализацию для тех же устройств и условий.

Среда	Недостаточная экспозиция (исправлено)	Передержка (исправлено)	Оттенок цвета (фиксированный)
Темная среда (нет источника света, кроме телефона)
Слабое освещение (дополнительный источник света около 3 люкс)

Как видно, качество изображения значительно улучшается при стандартной реализации.

Мигание экрана Оптимизируйте свои подборки Сохраняйте и классифицируйте контент в соответствии со своими настройками.

Общий рабочий процесс

Образцы кода Camera2

Экран приложения закрыт белым оверлеем

Увеличить яркость экрана до максимума

Kotlin

Java

Установить режим автоэкспозиции CONTROL_AE_MODE_ON_EXTERNAL_FLASH

Kotlin

Java

Обратный вызов захвата, который может ожидать обновления режима автоэкспозиции.

Kotlin

Java

Настройте повторяющийся запрос, чтобы включить или отключить режим AE.

Kotlin

Java

Как запустить предварительную съемку

Обновление кода обратного вызова для ожидания конвергенции

Kotlin

Java

Установите обратный вызов для повторяющегося запроса во время настройки камеры.

Kotlin

Java

Запуск и ожидание последовательности предварительной съемки

Kotlin

Java

Объедините все вместе

Kotlin

Java

Образцы изображений

Неправильный подход

Если все сделано правильно,

Мигание экрана

Установить режим автоэкспозиции `CONTROL_AE_MODE_ON_EXTERNAL_FLASH`