Câmera

Você pode usar a câmera do Google Glass para capturar imagens e vídeos, além de exibir o stream de visualização da câmera em vários casos de uso diferentes.

Visão geral

Você tem duas opções para capturar imagens ou vídeos:

  • Chamar a atividade de câmera integrada com startActivityForResult(). Use essa opção quando possível.

  • Criar sua própria lógica com a API Android Camera. Siga estas diretrizes se estiver usando este método:

    • Tire uma foto com um clique no botão de câmera e um vídeo com um clique longo, assim como o Google Glass faz.
    • Indique ao usuário se uma foto foi tirada ou um vídeo foi gravado.
    • Mantenha a tela ligada durante a captura.

Como compartilhar a câmera com o sistema do Google Glass

Se o Glassware usar as APIs do Android para acessar a câmera, libere temporariamente a câmera quando possível, se os usuários pressionarem o botão da câmera.

  1. Substitua o método onKeyDown() na atividade e intercepte KEYCODE_CAMERA para processar o pressionamento de botões da câmera.

  2. Solte a câmera e retorne false para indicar que você não consumiu o evento para que a câmera de vidro integrada seja iniciada.

  1. Depois que a captura de imagem ou vídeo é realizada, o Google Glass retorna à atividade, onde é possível recuperar a câmera em onResume().

    @Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
    if (keyCode == KeyEvent.KEYCODE_CAMERA) {
        // Stop the preview and release the camera.
        // Execute your logic as quickly as possible
        // so the capture happens quickly.
        return false;
    } else {
        return super.onKeyDown(keyCode, event);
    }
}

@Override
protected void onResume() {
    super.onResume();
    // Re-acquire the camera and start the preview.
}

Capturar imagens ou vídeos

Imagens

Para capturar uma imagem usando o Camera Glassware integrado:

  1. Chame startActivityForResult(Intent, int) com a ação definida como ACTION_IMAGE_CAPTURE.
  2. Em onActivityResult(int, int, android.content.Intent):
    1. Verifique se o requestCode corresponde ao código de solicitação usado ao iniciar a intent de captura de imagem.
    2. Confira se o resultCode corresponde a RESULT_OK.
    3. Consiga o caminho para a miniatura da imagem no extra da Intent com a chave EXTRA_THUMBNAIL_FILE_PATH, se necessário.
    4. O caminho para a imagem completa está disponível no extra do Intent com a chave EXTRA_PICTURE_FILE_PATH. Quando a intent de captura de imagem retorna controle para o Glassware, a imagem pode não ser totalmente gravada no arquivo. Verifique se o arquivo de imagem existe ou use um FileObserver para monitorar o diretório pai. Quando a imagem completa estiver disponível, carregue o arquivo e use-o no Glassware.
private static final int TAKE_PICTURE_REQUEST = 1;

private void takePicture() {
    Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
    startActivityForResult(intent, TAKE_PICTURE_REQUEST);
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == TAKE_PICTURE_REQUEST && resultCode == RESULT_OK) {
        String thumbnailPath = data.getStringExtra(Intents.EXTRA_THUMBNAIL_FILE_PATH);
        String picturePath = data.getStringExtra(Intents.EXTRA_PICTURE_FILE_PATH);

        processPictureWhenReady(picturePath);
        // TODO: Show the thumbnail to the user while the full picture is being
        // processed.
    }

    super.onActivityResult(requestCode, resultCode, data);
}

private void processPictureWhenReady(final String picturePath) {
    final File pictureFile = new File(picturePath);

    if (pictureFile.exists()) {
        // The picture is ready; process it.
    } else {
        // The file does not exist yet. Before starting the file observer, you
        // can update your UI to let the user know that the application is
        // waiting for the picture (for example, by displaying the thumbnail
        // image and a progress indicator).

        final File parentDirectory = pictureFile.getParentFile();
        FileObserver observer = new FileObserver(parentDirectory.getPath(),
                FileObserver.CLOSE_WRITE | FileObserver.MOVED_TO) {
            // Protect against additional pending events after CLOSE_WRITE
            // or MOVED_TO is handled.
            private boolean isFileWritten;

            @Override
            public void onEvent(int event, String path) {
                if (!isFileWritten) {
                    // For safety, make sure that the file that was created in
                    // the directory is actually the one that we're expecting.
                    File affectedFile = new File(parentDirectory, path);
                    isFileWritten = affectedFile.equals(pictureFile);

                    if (isFileWritten) {
                        stopWatching();

                        // Now that the file is ready, recursively call
                        // processPictureWhenReady again (on the UI thread).
                        runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                processPictureWhenReady(picturePath);
                            }
                        });
                    }
                }
            }
        };
        observer.startWatching();
    }
}

Vídeos

Para capturar um vídeo usando o Camera Glassware integrado:

  1. Chame startActivityForResult(Intent, int) com a ação definida como ACTION_VIDEO_CAPTURE.
  2. Em onActivityResult(int, int, android.content.Intent):
    1. Verifique se o requestCode corresponde ao código de solicitação usado ao iniciar a intent de captura de vídeo.
    2. Confira se o resultCode corresponde a RESULT_OK.
    3. Veja o caminho para a miniatura do vídeo no extra do Intent com a chave EXTRA_THUMBNAIL_FILE_PATH para exibir uma visualização, se necessário.
    4. O caminho para o vídeo gravado está disponível no extra do Intent com a chave EXTRA_VIDEO_FILE_PATH.