Reconhecer pontos de referência com segurança usando o Cloud Vision com o Firebase Auth e Functions no Android

Para chamar uma API do Google Cloud usando seu app, crie uma API REST intermediária que gerencie a autorização e proteja valores secretos, como chaves de API. Em seguida, escreva o código no seu app para dispositivos móveis a fim de autenticar e se comunicar com esse serviço intermediário.

Uma maneira de criar essa API REST é usar o Firebase Authentication e o Functions, que oferecem um gateway gerenciado sem servidor para as APIs do Google Cloud. Ele lida com a autenticação e pode ser chamado no seu app para dispositivos móveis com SDKs pré-criados.

Neste guia, você verá como usar essa técnica para chamar a API Cloud Vision do seu app. Esse método permitirá que todos os usuários autenticados acessem os serviços faturados do Cloud Vision no projeto do Cloud. Sendo assim, considere se esse mecanismo de autenticação é suficiente para seu caso de uso antes de continuar.

Antes de começar

Configurar seu projeto

Adicione o Firebase ao seu projeto para Android, caso ainda não tenha feito isso.
Se você ainda não ativou APIs baseadas em nuvem para seu projeto, siga estas etapas:
1. Abra a página de APIs do Firebase ML no Console do Firebase.
2. Se você ainda não fez o upgrade do seu projeto ao plano de preços do Blaze, clique em Fazer upgrade para fazer isso. Você só receberá uma mensagem para fazer upgrade se o projeto não estiver no plano Blaze.
  
  Apenas projetos no nível Blaze podem usar APIs baseadas na nuvem.
3. Caso as APIs baseadas na nuvem ainda não estejam ativadas, clique em Ativar APIs baseadas na nuvem.
Configure as chaves de API do Firebase para proibir o acesso à API Cloud Vision:
1. Abra a página Credenciais do Console do Cloud.
2. Para cada chave de API na lista, abra a visualização de edição e, na seção "Restrições de chave", adicione à lista todas as APIs disponíveis, exceto a API Cloud Vision.

Como implantar a função chamável

Agora, você implantará a função do Cloud que será usada para conectar seu app e a API Cloud Vision. O repositório functions-samples contém um exemplo que pode ser usado.

Por padrão, essa função permitirá que apenas usuários autenticados do seu app acessem a API Cloud Vision. É possível modificar a função para requisitos diferentes.

Para implantar a função, siga estas etapas:

Clone ou faça o download do repositório functions-samples e mude para o diretório vision-annotate-image:
```
git clone https://github.com/firebase/functions-samples
cd vision-annotate-image
```
Instale as dependências:
```
cd functions
npm install
cd ..
```
Se você não tiver a CLI do Firebase, faça a instalação.
Inicialize um novo projeto do Firebase no diretório vision-annotate-image. Quando solicitado, selecione o projeto na lista.
```
firebase init
```

Implante a função:

firebase deploy --only functions:annotateImage

Adicionar o Firebase Auth ao seu app

A função chamável implementada acima rejeitará qualquer solicitação de usuários não autenticados do seu app. Adicione o Firebase Authentication ao app, caso ainda não tenha feito isso.

Adicionar as dependências necessárias ao app

Adicione as dependências das bibliotecas Android do Firebase Functions e do gson ao seu arquivo Gradle (geralmente app/build.gradle) do módulo no aplicativo:

implementation 'com.google.firebase:firebase-functions:20.1.0'
implementation 'com.google.code.gson:gson:2.8.6'

1. Preparar a imagem de entrada

Para chamar o Cloud Vision, a imagem precisa ser formatada como uma string codificada em base64. Para processar uma imagem usando um URI de arquivo salvo:

Consiga a imagem como um objeto Bitmap:

Java

Bitmap bitmap = MediaStore.Images.Media.getBitmap(getContentResolver(), uri);

Kotlin+KTX

var bitmap: Bitmap = MediaStore.Images.Media.getBitmap(contentResolver, uri)

Opcionalmente, diminua a imagem para economizar largura de banda. Confira os tamanhos de imagem recomendados do Cloud Vision.

Java

private Bitmap scaleBitmapDown(Bitmap bitmap, int maxDimension) {
    int originalWidth = bitmap.getWidth();
    int originalHeight = bitmap.getHeight();
    int resizedWidth = maxDimension;
    int resizedHeight = maxDimension;

    if (originalHeight > originalWidth) {
        resizedHeight = maxDimension;
        resizedWidth = (int) (resizedHeight * (float) originalWidth / (float) originalHeight);
    } else if (originalWidth > originalHeight) {
        resizedWidth = maxDimension;
        resizedHeight = (int) (resizedWidth * (float) originalHeight / (float) originalWidth);
    } else if (originalHeight == originalWidth) {
        resizedHeight = maxDimension;
        resizedWidth = maxDimension;
    }
    return Bitmap.createScaledBitmap(bitmap, resizedWidth, resizedHeight, false);
}

Kotlin+KTX

private fun scaleBitmapDown(bitmap: Bitmap, maxDimension: Int): Bitmap {
    val originalWidth = bitmap.width
    val originalHeight = bitmap.height
    var resizedWidth = maxDimension
    var resizedHeight = maxDimension
    if (originalHeight > originalWidth) {
        resizedHeight = maxDimension
        resizedWidth =
                (resizedHeight * originalWidth.toFloat() / originalHeight.toFloat()).toInt()
    } else if (originalWidth > originalHeight) {
        resizedWidth = maxDimension
        resizedHeight =
                (resizedWidth * originalHeight.toFloat() / originalWidth.toFloat()).toInt()
    } else if (originalHeight == originalWidth) {
        resizedHeight = maxDimension
        resizedWidth = maxDimension
    }
    return Bitmap.createScaledBitmap(bitmap, resizedWidth, resizedHeight, false)
}

Java

// Scale down bitmap size
bitmap = scaleBitmapDown(bitmap, 640);

Kotlin+KTX

// Scale down bitmap size
bitmap = scaleBitmapDown(bitmap, 640)

Converta o objeto bitmap em uma string codificada em base64:

Java

// Convert bitmap to base64 encoded string
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.JPEG, 100, byteArrayOutputStream);
byte[] imageBytes = byteArrayOutputStream.toByteArray();
String base64encoded = Base64.encodeToString(imageBytes, Base64.NO_WRAP);

Kotlin+KTX

// Convert bitmap to base64 encoded string
val byteArrayOutputStream = ByteArrayOutputStream()
bitmap.compress(Bitmap.CompressFormat.JPEG, 100, byteArrayOutputStream)
val imageBytes: ByteArray = byteArrayOutputStream.toByteArray()
val base64encoded = Base64.encodeToString(imageBytes, Base64.NO_WRAP)

Bitmap

2. Invocar a função chamável para reconhecer pontos de referência

Para reconhecer pontos de referência em uma imagem, invoque a função chamável transmitindo uma solicitação JSON do Cloud Vision.

Inicialize uma instância do Cloud Functions:

Java

private FirebaseFunctions mFunctions;
// ...
mFunctions = FirebaseFunctions.getInstance();

Kotlin+KTX

private lateinit var functions: FirebaseFunctions
// ...
functions = Firebase.functions

Defina um método para invocar a função:

Java

private Task<JsonElement> annotateImage(String requestJson) {
    return mFunctions
            .getHttpsCallable("annotateImage")
            .call(requestJson)
            .continueWith(new Continuation<HttpsCallableResult, JsonElement>() {
                @Override
                public JsonElement then(@NonNull Task<HttpsCallableResult> task) {
                    // This continuation runs on either success or failure, but if the task
                    // has failed then getResult() will throw an Exception which will be
                    // propagated down.
                    return JsonParser.parseString(new Gson().toJson(task.getResult().getData()));
                }
            });
}

Kotlin+KTX

private fun annotateImage(requestJson: String): Task<JsonElement> {
    return functions
            .getHttpsCallable("annotateImage")
            .call(requestJson)
            .continueWith { task ->
                // This continuation runs on either success or failure, but if the task
                // has failed then result will throw an Exception which will be
                // propagated down.
                val result = task.result?.data
                JsonParser.parseString(Gson().toJson(result))
            }
}

Crie uma solicitação JSON com Type LANDMARK_DETECTION:

Java

// Create json request to cloud vision
JsonObject request = new JsonObject();
// Add image to request
JsonObject image = new JsonObject();
image.add("content", new JsonPrimitive(base64encoded));
request.add("image", image);
//Add features to the request
JsonObject feature = new JsonObject();
feature.add("maxResults", new JsonPrimitive(5));
feature.add("type", new JsonPrimitive("LANDMARK_DETECTION"));
JsonArray features = new JsonArray();
features.add(feature);
request.add("features", features);

Kotlin+KTX

// Create json request to cloud vision
val request = JsonObject()
// Add image to request
val image = JsonObject()
image.add("content", JsonPrimitive(base64encoded))
request.add("image", image)
//Add features to the request
val feature = JsonObject()
feature.add("maxResults", JsonPrimitive(5))
feature.add("type", JsonPrimitive("LANDMARK_DETECTION"))
val features = JsonArray()
features.add(feature)
request.add("features", features)

Por fim, invoque a função:

Java

annotateImage(request.toString())
        .addOnCompleteListener(new OnCompleteListener<JsonElement>() {
            @Override
            public void onComplete(@NonNull Task<JsonElement> task) {
                if (!task.isSuccessful()) {
                    // Task failed with an exception
                    // ...
                } else {
                    // Task completed successfully
                    // ...
                }
            }
        });

Kotlin+KTX

annotateImage(request.toString())
        .addOnCompleteListener { task ->
            if (!task.isSuccessful) {
                // Task failed with an exception
                // ...
            } else {
                // Task completed successfully
                // ...
            }
        }

3. Ver informações sobre os pontos de referência reconhecidos

Se a operação de reconhecimento de ponto de referência for bem-sucedida, uma resposta JSON de BatchAnnotateImagesResponse será retornada no resultado da tarefa. Cada objeto na matriz landmarkAnnotations representa um ponto de referência reconhecido na imagem. Para cada ponto de referência, é possível receber as coordenadas delimitadoras na imagem de entrada, o nome do ponto de referência, a latitude e a longitude, o ID da entidade do Mapa de informações dele (se disponível) e a pontuação de confiança da correspondência. Exemplo:

Java

for (JsonElement label : task.getResult().getAsJsonArray().get(0).getAsJsonObject().get("landmarkAnnotations").getAsJsonArray()) {
    JsonObject labelObj = label.getAsJsonObject();
    String landmarkName = labelObj.get("description").getAsString();
    String entityId = labelObj.get("mid").getAsString();
    float score = labelObj.get("score").getAsFloat();
    JsonObject bounds = labelObj.get("boundingPoly").getAsJsonObject();
    // Multiple locations are possible, e.g., the location of the depicted
    // landmark and the location the picture was taken.
    for (JsonElement loc : labelObj.get("locations").getAsJsonArray()) {
        JsonObject latLng = loc.getAsJsonObject().get("latLng").getAsJsonObject();
        double latitude = latLng.get("latitude").getAsDouble();
        double longitude = latLng.get("longitude").getAsDouble();
    }
}

Kotlin+KTX

for (label in task.result!!.asJsonArray[0].asJsonObject["landmarkAnnotations"].asJsonArray) {
    val labelObj = label.asJsonObject
    val landmarkName = labelObj["description"]
    val entityId = labelObj["mid"]
    val score = labelObj["score"]
    val bounds = labelObj["boundingPoly"]
    // Multiple locations are possible, e.g., the location of the depicted
    // landmark and the location the picture was taken.
    for(loc in labelObj["locations"].asJsonArray) {
        val latitude = loc.asJsonObject["latLng"].asJsonObject["latitude"]
        val longitude = loc.asJsonObject["latLng"].asJsonObject["longitude"]
    }
}