[Anderson Paraibano]

A captura de imagens em dispositivos Android utilizando a API da câmera (Camera2API) é uma tarefa comum para aplicativos que envolvem funcionalidades de fotografia. Neste artigo, abordaremos como dar um tempo adequado até que o foco seja configurado na imagem e, em seguida, tirar a foto desejada utilizando a Camera2API em um aplicativo Android.

A API da câmera no Android fornece um conjunto de classes e interfaces para acessar e controlar a câmera do dispositivo. A Camera2API é uma versão mais recente e aprimorada da API da câmera, que permite um controle mais detalhado sobre os recursos da câmera, como controle de exposição, foco, balanço de branco, entre outros.

Para começar, é necessário configurar e inicializar a câmera no aplicativo Android. Isso envolve a obtenção de uma instância do gerenciador de câmera (CameraManager) e a obtenção da ID da câmera desejada (geralmente, a câmera traseira é a mais utilizada).

Uma vez que a câmera esteja configurada e pronta para ser usada, podemos implementar a funcionalidade de foco antes de tirar uma foto. A API da câmera fornece diferentes modos de foco, como o foco automático contínuo (continuous autofocus) e o foco automático de um único toque (single touch autofocus).

Para implementar um tempo de espera até que o foco esteja configurado na imagem, podemos utilizar uma combinação de eventos assíncronos e um temporizador. A ideia básica é iniciar o processo de foco automático e aguardar um tempo adequado antes de capturar a imagem.

Vamos considerar um exemplo de implementação em Java utilizando a Camera2API:

java
Copy code
// Importe as classes e interfaces necessárias

public class MainActivity extends AppCompatActivity {
private CameraDevice mCameraDevice;
private CaptureRequest.Builder mCaptureRequestBuilder;
private CameraCaptureSession mCaptureSession;

// …

private void initializeCamera() {
CameraManager cameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
String cameraId = null;

try {
cameraId = cameraManager.getCameraIdList()[0];
} catch (CameraAccessException e) {
e.printStackTrace();
}

try {
cameraManager.openCamera(cameraId, new CameraDevice.StateCallback() {
@Override
public void onOpened(@NonNull CameraDevice camera) {
mCameraDevice = camera;
createCaptureSession();
}

@Override
public void onDisconnected(@NonNull CameraDevice camera) {
camera.close();
mCameraDevice = null;
}

@Override
public void onError(@NonNull CameraDevice camera, int error) {
camera.close();
mCameraDevice = null;
}
}, null);
} catch (CameraAccessException e) {
e.printStackTrace();
}
}

private void createCaptureSession() {
try {
mCaptureRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);

SurfaceTexture surfaceTexture = textureView.getSurfaceTexture();
surfaceTexture.setDefaultBufferSize(previewSize.getWidth(), previewSize.getHeight());

Surface previewSurface = new Surface(surfaceTexture);
mCaptureRequestBuilder.addTarget(previewSurface);

mCameraDevice.createCaptureSession(Collections.singletonList(previewSurface),
new CameraCaptureSession.StateCallback() {
@Override
public void onConfigured(@NonNull CameraCaptureSession session) {
mCaptureSession = session;
startPreview();
}

@Override
public void onConfigureFailed(@NonNull CameraCaptureSession session) {
// Handle configuration failure
}
}, null);
} catch (CameraAccessException e) {
e.printStackTrace();
}
}

private void startPreview() {
try {
mCaptureSession.setRepeatingRequest(mCaptureRequestBuilder.build(), null, null);

// Aguarde um tempo adequado antes de tirar a foto
Handler handler = new Handler();
handler.postDelayed(new Runnable() {
@Override
public void run() {
captureImage();
}
}, 2000); // Espera 2 segundos antes de tirar a foto
} catch (CameraAccessException e) {
e.printStackTrace();
}
}

private void captureImage() {
// Configurar a captura da imagem
try {
mCaptureRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, CameraMetadata.CONTROL_AF_TRIGGER_START);
mCaptureRequestBuilder.set(CaptureRequest.JPEG_ORIENTATION, getJpegOrientation());

mCaptureSession.capture(mCaptureRequestBuilder.build(), null, null);
} catch (CameraAccessException e) {
e.printStackTrace();
}
}

// …

@Override
protected void onResume() {
super.onResume();
initializeCamera();
}

@Override
protected void onPause() {
super.onPause();
closeCamera();
}

private void closeCamera() {
if (mCaptureSession != null) {
mCaptureSession.close();
mCaptureSession = null;
}

if (mCameraDevice != null) {
mCameraDevice.close();
mCameraDevice = null;
}
}

// …
}
No exemplo acima, initializeCamera() é chamado no método onResume() da atividade para inicializar a câmera. Em seguida, createCaptureSession() é chamado para configurar a visualização da câmera e o objeto mCaptureRequestBuilder é criado para as capturas subsequentes. Em startPreview(), é chamado setRepeatingRequest() para iniciar a visualização e é configurado um temporizador de 2 segundos antes de chamar captureImage() para tirar a foto. Em captureImage(), é feita a configuração para capturar a imagem.

Lembre-se de adicionar as permissões necessárias no manifesto do seu aplicativo, como a permissão de uso da câmera.

Este artigo explorou como dar um tempo até que o foco esteja configurado na imagem e, em seguida, tirar uma foto utilizando a Camera2API em um aplicativo Android. A implementação pode variar de acordo com as necessidades do seu aplicativo, mas essa abordagem básica pode ser um ponto de partida útil para aprimorar a funcionalidade de captura de imagens em sua aplicação.

[Autor]

Posts