Implementar uma visualização

Ao adicionar uma visualização ao seu app, use a PreviewView, que é uma View que pode ser cortada, redimensionada e girada para que a exibição fique adequada.

A visualização da imagem é transmitida para uma superfície dentro da PreviewView quando a câmera é ativada.

Usar a PreviewView

A implementação de uma visualização para o CameraX usando PreviewView envolve as seguintes etapas, abordadas nas próximas seções:

1. Como opção, configurar um CameraXConfig.Provider.
2. Adicionar uma PreviewView ao seu layout.
3. Solicitar um ProcessCameraProvider.
4. Na criação de View, verifique se ProcessCameraProvider existe.
5. Selecionar uma câmera e vincular o ciclo de vida e casos de uso.

O uso de PreviewView tem algumas limitações. Ao usar PreviewView, não é possível realizar nenhuma destas ações:

• Criar uma SurfaceTexture para configurar em TextureView e Preview.SurfaceProvider.
• Recuperar a SurfaceTexture na TextureView e configurá-la em Preview.SurfaceProvider.
• Conseguir a Surface da SurfaceView e configurá-la em Preview.SurfaceProvider.

Se qualquer um desses eventos acontecer, a Preview interromperá o streaming de frames para a PreviewView.

[Opcional] Configurar um CameraXConfig.Provider

Se você quiser um bom controle sobre quando o CameraX é inicializado, implemente a interface CameraXConfig.Provider na classe Application. A maioria dos apps não exige esse nível de controle.

import androidx.camera.camera2.Camera2Config
import androidx.camera.core.CameraXConfig

public class MyCameraXApplication : Application(),  CameraXConfig.Provider {
  override fun getCameraXConfig(): CameraXConfig {
    return Camera2Config.defaultConfig()
  }
}

import androidx.camera.camera2.Camera2Config;
import androidx.camera.core.CameraXConfig;

public class MyCameraXApplication extends Application implements CameraXConfig.Provider {
    @NonNull
    @Override
    public CameraXConfig getCameraXConfig() {
        return Camera2Config.defaultConfig();
    }
}

Adicionar uma PreviewView ao layout

O exemplo a seguir mostra uma PreviewView em um layout:

<FrameLayout
    android:id="@+id/container">
        <androidx.camera.view.PreviewView
            android:id="@+id/previewView" />
</FrameLayout>

Solicitar um CameraProvider

O código a seguir mostra como solicitar um CameraProvider:

import androidx.camera.lifecycle.ProcessCameraProvider
import com.google.common.util.concurrent.ListenableFuture

class MainActivity : AppCompatActivity() {
    private lateinit var cameraProviderFuture : ListenableFuture<ProcessCameraProvider>
    override fun onCreate(savedInstanceState: Bundle?) {
        cameraProviderFuture = ProcessCameraProvider.getInstance(this)
    }
}

import androidx.camera.lifecycle.ProcessCameraProvider
import com.google.common.util.concurrent.ListenableFuture

public class MainActivity extends AppCompatActivity {
    private ListenableFuture<ProcessCameraProvider> cameraProviderFuture;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        cameraProviderFuture = ProcessCameraProvider.getInstance(this);
    }
}

Verificar a disponibilidade do CameraProvider

Depois de solicitar um CameraProvider, verifique se a inicialização foi bem-sucedida quando a visualização for criada. O código a seguir mostra como fazer isso:

cameraProviderFuture.addListener(Runnable {
    val cameraProvider = cameraProviderFuture.get()
    bindPreview(cameraProvider)
}, ContextCompat.getMainExecutor(this))

cameraProviderFuture.addListener(() -> {
    try {
        ProcessCameraProvider cameraProvider = cameraProviderFuture.get();
        bindPreview(cameraProvider);
    } catch (ExecutionException | InterruptedException e) {
        // No errors need to be handled for this Future.
        // This should never be reached.
    }
}, ContextCompat.getMainExecutor(this));

Para ver um exemplo da função bindPreview usada nesta amostra, consulte o código fornecido na próxima seção.

Selecionar uma câmera e vincular o ciclo de vida e casos de uso

Após criar e confirmar o CameraProvider, faça o seguinte:

1. Crie uma Preview.
2. Especifique a opção LensFacing da câmera desejada.
3. Vincule a câmera selecionada e os casos de uso ao ciclo de vida.
4. Conecte a Preview à PreviewView.

O código a seguir mostra um exemplo:

fun bindPreview(cameraProvider : ProcessCameraProvider) {
    var preview : Preview = Preview.Builder()
            .build()

    var cameraSelector : CameraSelector = CameraSelector.Builder()
          .requireLensFacing(CameraSelector.LENS_FACING_BACK)
          .build()

    preview.setSurfaceProvider(previewView.getSurfaceProvider())

    var camera = cameraProvider.bindToLifecycle(this as LifecycleOwner, cameraSelector, preview)
}

void bindPreview(@NonNull ProcessCameraProvider cameraProvider) {
    Preview preview = new Preview.Builder()
            .build();

    CameraSelector cameraSelector = new CameraSelector.Builder()
            .requireLensFacing(CameraSelector.LENS_FACING_BACK)
            .build();

    preview.setSurfaceProvider(previewView.getSurfaceProvider());

    Camera camera = cameraProvider.bindToLifecycle((LifecycleOwner)this, cameraSelector, preview);
}

Você concluiu a implementação da visualização da câmera. Crie seu app e confirme se a visualização aparece no app e funciona conforme o esperado.

Outros recursos

Para saber mais sobre o CameraX, consulte os seguintes recursos.

Codelab

Exemplo de código