Reconnaître du texte dans des images de manière sécurisée avec Cloud Vision à l'aide de Firebase Auth et de Functions sur Android

Pour appeler une API Google Cloud depuis votre application, vous devez créer une API REST intermédiaire qui gère l'autorisation et protège les valeurs secrètes telles que les clés API. Vous devez ensuite écrire du code dans votre application mobile pour vous authentifier auprès de ce service intermédiaire et communiquer avec lui.

Vous pouvez créer cette API REST à l'aide de Firebase Authentication et de Firebase Functions, qui vous offrent une passerelle sans serveur gérée vers les API Google Cloud. Cette passerelle gère l'authentification et peut être appelée depuis votre application mobile à l'aide de SDK prédéfinis.

Ce guide explique comment utiliser cette technique pour appeler l'API Cloud Vision depuis votre application. Cette méthode permet à tous les utilisateurs authentifiés d'accéder aux services payants de Cloud Vision via votre projet Cloud. Avant de continuer, vérifiez si ce mécanisme d'authentification est suffisant pour votre cas d'utilisation.

L'utilisation des API Cloud Vision est soumise au contrat de licence Google Cloud Platform et aux conditions spécifiques au service, et est facturée en conséquence. Pour en savoir plus sur les informations de facturation, consultez la page Tarifs.

Vous recherchez une solution de reconnaissance de texte sur l'appareil ? Essayez la bibliothèque ML Kit autonome.

Avant de commencer

Configurez votre projet

1. Si ce n'est pas déjà fait, ajoutez Firebase à votre projet Android.

2. Si vous n'avez pas encore activé les API basées sur le cloud pour votre projet, faites-le maintenant :

   1. Ouvrez la Firebase ML page API dans la Firebase console.

   2. Si vous n'avez pas encore mis à niveau votre projet vers le forfait Blaze avec paiement à l'usage, cliquez sur Mettre à niveau pour le faire. (Vous serez invité à effectuer la mise à niveau uniquement si votre projet n'est pas associé au forfait Blaze.)

      Seuls les projets associés au forfait Blaze peuvent utiliser les API basées sur le cloud.

   3. Si les API basées sur le cloud ne sont pas encore activées, cliquez sur Activer les API basées sur le cloud.
3. Configurez vos clés API Firebase existantes pour interdire l'accès à l'API Cloud Vision :
   1. Ouvrez la page Identifiants de la console Cloud.
   2. Pour chaque clé API de la liste, ouvrez la vue d'édition, puis, dans la section "Restrictions de clé" , ajoutez toutes les API disponibles à l'exception de l'API Cloud Vision à la liste.

Déployer la fonction appelable

Ensuite, déployez la fonction Cloud que vous utiliserez pour connecter votre application et l'API Cloud Vision. Le dépôt functions-samples contient un exemple que vous pouvez utiliser.

Par défaut, l'accès à l'API Cloud Vision via cette fonction n'autorise que les utilisateurs authentifiés de votre application à accéder à l'API Cloud Vision. Vous pouvez modifier la fonction pour répondre à différents besoins.

Pour déployer la fonction, procédez comme suit :

1. Clonez ou téléchargez le dépôt functions-samples , puis accédez au répertoire Node-1st-gen/vision-annotate-image :

   git clone https://github.com/firebase/functions-samples
   cd Node-1st-gen/vision-annotate-image
   

2. Installez les dépendances :

   cd functions
   npm install
   cd ..

3. Si vous ne disposez pas de la CLI Firebase, installez-la.
4. Initialisez un projet Firebase dans le vision-annotate-image répertoire. Lorsque vous y êtes invité, sélectionnez votre projet dans la liste.

   firebase init

5. Déployez la fonction :

   firebase deploy --only functions:annotateImage

Ajouter Firebase Authentication à votre application

La fonction appelable déployée ci-dessus refusera toute requête provenant d'utilisateurs non authentifiés de votre application. Si ce n'est pas déjà fait, vous devez ajouter Firebase Authentication à votre application.

Ajouter les dépendances nécessaires à votre application

Ajoutez les dépendances pour les bibliothèques Cloud Functions pour Firebase (client) et gson Android à votre fichier Gradle de module (au niveau de l'application) (généralement <project>/<app-module>/build.gradle.kts ou <project>/<app-module>/build.gradle) :

implementation("com.google.firebase:firebase-functions:22.1.1")
implementation("com.google.code.gson:gson:2.8.6")

Vous pouvez maintenant commencer à reconnaître du texte dans les images.

1. Préparer l'image d'entrée

Pour appeler Cloud Vision, l'image doit être au format d'une chaîne encodée en base64. Pour traiter une image à partir d'un URI de fichier enregistré :

1. Obtenez l'image en tant qu'objet Bitmap :

   Kotlin

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

   Java

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

2. Vous pouvez également réduire la taille de l'image pour économiser de la bande passante. Consultez les tailles d'image recommandées pour Cloud Vision.

   Kotlin

   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

   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

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

   Java

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

3. Convertissez l'objet bitmap en chaîne encodée en base64 :

   Kotlin

   // 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)

   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);

L'image représentée par l'objet Bitmap doit être droite et ne nécessiter aucune rotation supplémentaire.

2. Appeler la fonction appelable pour reconnaître le texte

Pour reconnaître du texte dans une image, appelez la fonction appelable en transmettant une requête JSON Cloud Vision.

1. Commencez par initialiser une instance de Cloud Functions :

   Kotlin

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

   Java

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

2. Définissez une méthode pour appeler la fonction :

   Kotlin

   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))
           }
   }
   

   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()));
                   }
               });
   }
   

3. Créez la requête JSON. L'API Cloud Vision est compatible avec deux types de détection de texte : TEXT_DETECTION et DOCUMENT_TEXT_DETECTION. Pour connaître la différence entre les deux cas d'utilisation, consultez la documentation sur la fonctionnalité OCR de Cloud Vision.

   Kotlin

   // 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("type", JsonPrimitive("TEXT_DETECTION"))
   // Alternatively, for DOCUMENT_TEXT_DETECTION:
   // feature.add("type", JsonPrimitive("DOCUMENT_TEXT_DETECTION"))
   val features = JsonArray()
   features.add(feature)
   request.add("features", features)
   

   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("type", new JsonPrimitive("TEXT_DETECTION"));
   // Alternatively, for DOCUMENT_TEXT_DETECTION:
   //feature.add("type", new JsonPrimitive("DOCUMENT_TEXT_DETECTION"));
   JsonArray features = new JsonArray();
   features.add(feature);
   request.add("features", features);
   

   Vous pouvez également fournir des indications de langue pour faciliter la détection de la langue (consultez les langues acceptées) :

   Kotlin

   val imageContext = JsonObject()
   val languageHints = JsonArray()
   languageHints.add("en")
   imageContext.add("languageHints", languageHints)
   request.add("imageContext", imageContext)
   

   Java

   JsonObject imageContext = new JsonObject();
   JsonArray languageHints = new JsonArray();
   languageHints.add("en");
   imageContext.add("languageHints", languageHints);
   request.add("imageContext", imageContext);
   

4. Enfin, appelez la fonction :

   Kotlin

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

   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
                       // ...
                   }
               }
           });
   

3. Extraire le texte des blocs de texte reconnus

Si l'opération de reconnaissance de texte réussit, une réponse JSON de BatchAnnotateImagesResponse est renvoyée dans le résultat de la tâche. Les annotations de texte se trouvent dans l' fullTextAnnotation objet.

Vous pouvez obtenir le texte reconnu sous forme de chaîne dans le champ text. Exemple :

Kotlin

val annotation = task.result!!.asJsonArray[0].asJsonObject["fullTextAnnotation"].asJsonObject
System.out.format("%nComplete annotation:")
System.out.format("%n%s", annotation["text"].asString)

Java

JsonObject annotation = task.getResult().getAsJsonArray().get(0).getAsJsonObject().get("fullTextAnnotation").getAsJsonObject();
System.out.format("%nComplete annotation:%n");
System.out.format("%s%n", annotation.get("text").getAsString());

Vous pouvez également obtenir des informations spécifiques aux régions de l'image. Pour chaque block, paragraph, word et symbol, vous pouvez obtenir le texte reconnu dans la région et les coordonnées de délimitation de la région. Exemple :

Kotlin

for (page in annotation["pages"].asJsonArray) {
    var pageText = ""
    for (block in page.asJsonObject["blocks"].asJsonArray) {
        var blockText = ""
        for (para in block.asJsonObject["paragraphs"].asJsonArray) {
            var paraText = ""
            for (word in para.asJsonObject["words"].asJsonArray) {
                var wordText = ""
                for (symbol in word.asJsonObject["symbols"].asJsonArray) {
                    wordText += symbol.asJsonObject["text"].asString
                    System.out.format(
                        "Symbol text: %s (confidence: %f)%n",
                        symbol.asJsonObject["text"].asString,
                        symbol.asJsonObject["confidence"].asFloat,
                    )
                }
                System.out.format(
                    "Word text: %s (confidence: %f)%n%n",
                    wordText,
                    word.asJsonObject["confidence"].asFloat,
                )
                System.out.format("Word bounding box: %s%n", word.asJsonObject["boundingBox"])
                paraText = String.format("%s%s ", paraText, wordText)
            }
            System.out.format("%nParagraph: %n%s%n", paraText)
            System.out.format("Paragraph bounding box: %s%n", para.asJsonObject["boundingBox"])
            System.out.format("Paragraph Confidence: %f%n", para.asJsonObject["confidence"].asFloat)
            blockText += paraText
        }
        pageText += blockText
    }
}

Java

for (JsonElement page : annotation.get("pages").getAsJsonArray()) {
    StringBuilder pageText = new StringBuilder();
    for (JsonElement block : page.getAsJsonObject().get("blocks").getAsJsonArray()) {
        StringBuilder blockText = new StringBuilder();
        for (JsonElement para : block.getAsJsonObject().get("paragraphs").getAsJsonArray()) {
            StringBuilder paraText = new StringBuilder();
            for (JsonElement word : para.getAsJsonObject().get("words").getAsJsonArray()) {
                StringBuilder wordText = new StringBuilder();
                for (JsonElement symbol : word.getAsJsonObject().get("symbols").getAsJsonArray()) {
                    wordText.append(symbol.getAsJsonObject().get("text").getAsString());
                    System.out.format("Symbol text: %s (confidence: %f)%n", symbol.getAsJsonObject().get("text").getAsString(), symbol.getAsJsonObject().get("confidence").getAsFloat());
                }
                System.out.format("Word text: %s (confidence: %f)%n%n", wordText.toString(), word.getAsJsonObject().get("confidence").getAsFloat());
                System.out.format("Word bounding box: %s%n", word.getAsJsonObject().get("boundingBox"));
                paraText.append(wordText.toString()).append(" ");
            }
            System.out.format("%nParagraph:%n%s%n", paraText);
            System.out.format("Paragraph bounding box: %s%n", para.getAsJsonObject().get("boundingBox"));
            System.out.format("Paragraph Confidence: %f%n", para.getAsJsonObject().get("confidence").getAsFloat());
            blockText.append(paraText);
        }
        pageText.append(blockText);
    }
}