הוספת תוויות לתמונות באופן מאובטח באמצעות Cloud Vision באמצעות Firebase Auth ו-Functions ב-Android

כדי לקרוא ל-Google Cloud API מהאפליקציה, צריך ליצור API ל-REST ביניים שמטפל באימות ומגן על ערכים סודיים כמו מפתחות API. לאחר מכן צריך לכתוב קוד באפליקציה לנייד כדי לבצע אימות של השירות המתווך הזה ולתקשר איתו.

אחת הדרכים ליצור את ממשק ה-API ל-REST היא באמצעות Firebase Authentication and Functions, שמספק שער מנוהל ללא שרת לממשקי Google Cloud API שמטפל באימות, ואפשר לקרוא אליו מהאפליקציה לנייד באמצעות ערכות SDK מוכנות מראש.

במדריך הזה נסביר איך להשתמש בשיטה הזו כדי לבצע קריאה ל-Cloud Vision API מהאפליקציה. השיטה הזו תאפשר לכל המשתמשים המאומתים לגשת לשירותים של Cloud Vision שמוגדרים לחיוב דרך הפרויקט שלכם ב-Cloud. לכן, לפני שממשיכים, כדאי לבדוק אם מנגנון האימות הזה מספיק לתרחיש לדוגמה שלכם.

לפני שמתחילים

הגדרת הפרויקט

1. אם עדיין לא עשיתם זאת, מוסיפים את Firebase לפרויקט Android.

2. אם עדיין לא הפעלתם ממשקי API מבוססי-ענן בפרויקט, עליכם לעשות זאת עכשיו:

   1. פותחים את דף ממשקי ה-API של Firebase ML במסוף Firebase.

   2. אם עדיין לא שדרגתם את הפרויקט לתוכנית התמחור Blaze, לוחצים על שדרוג כדי לעשות זאת. (הבקשה לשדרוג תוצג רק אם הפרויקט לא נמצא בתוכנית Blaze).

      רק בפרויקטים ברמת Blaze אפשר להשתמש בממשקי API מבוססי-Cloud.

   3. אם ממשקי ה-API מבוססי-הענן עדיין לא מופעלים, לוחצים על Enable Cloud-based APIs.
3. מגדירים את מפתחות ה-API הקיימים של Firebase כך שלא יאפשרו גישה ל-Cloud Vision API:
   1. פותחים את הדף Credentials במסוף Cloud.
   2. לכל מפתח API ברשימה, פותחים את תצוגת העריכה ובקטע Key Restrictions מוסיפים לרשימת כל ממשקי ה-API הזמינים למעט Cloud Vision API.

פריסת הפונקציה שניתן לקרוא לה

בשלב הבא, פורסים את Cloud Function שתשמש כגשר בין האפליקציה ל-Cloud Vision API. המאגר functions-samples מכיל דוגמה שאפשר להשתמש בה.

כברירת מחדל, הגישה ל-Cloud Vision API דרך הפונקציה הזו תאפשר רק למשתמשים מאומתים באפליקציה שלכם לגשת ל-Cloud Vision API. אפשר לשנות את הפונקציה בהתאם לדרישות שונות.

כדי לפרוס את הפונקציה:

1. משכפלים או מורידים את מאגר functions-samples ומעבירים את הנתיב לספרייה Node-1st-gen/vision-annotate-image:

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

2. יחסי תלות של התקנות:

   cd functions
   npm install
   cd ..

3. אם ה-CLI של Firebase לא מותקן, מתקינים אותו.
4. מאתחלים פרויקט Firebase בספרייה vision-annotate-image. כשמוצגת בקשה, בוחרים את הפרויקט ברשימה.

   firebase init

5. פורסים את הפונקציה:

   firebase deploy --only functions:annotateImage

הוספת Firebase Auth לאפליקציה

הפונקציה הניתנת לקריאה שפרוסה למעלה תדחה כל בקשה ממשתמשים לא מאומתים באפליקציה. אם עדיין לא עשיתם זאת, תצטרכו להוסיף את Firebase Auth לאפליקציה.

הוספת יחסי התלות הנדרשים לאפליקציה

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

עכשיו אתם מוכנים לתייג תמונות.

1. הכנת קובץ הקלט

1. אחזור התמונה כאובייקט Bitmap:

   Kotlin

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

   Java

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

2. אפשר גם לשנות את הגודל של התמונה כדי לחסוך ברוחב הפס. גודל התמונה המומלץ ב-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. ממירים את אובייקט הבייטמאפ למחרוזת בקידוד 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);

התמונה שמיוצגת על ידי האובייקט Bitmap חייבת להיות מוצבת בצורה זקופה, ללא צורך בסיבוב נוסף.

2. קריאה לפונקציה הניתנת לקריאה כדי לתייג את התמונה

1. קודם צריך לאתחל מכונה של Cloud Functions:

   Kotlin

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

   Java

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

2. מגדירים שיטה להפעלת הפונקציה:

   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. יוצרים את בקשת ה-JSON עם Type שמוגדר כ-LABEL_DETECTION:

   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("maxResults", JsonPrimitive(5))
   feature.add("type", JsonPrimitive("LABEL_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("maxResults", new JsonPrimitive(5));
   feature.add("type", new JsonPrimitive("LABEL_DETECTION"));
   JsonArray features = new JsonArray();
   features.add(feature);
   request.add("features", features);
   

4. לבסוף, מפעילים את הפונקציה:

   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. אחזור מידע על אובייקטים מתויגים

for (label in task.result!!.asJsonArray[0].asJsonObject["labelAnnotations"].asJsonArray) {
    val labelObj = label.asJsonObject
    val text = labelObj["description"]
    val entityId = labelObj["mid"]
    val confidence = labelObj["score"]
}

for (JsonElement label : task.getResult().getAsJsonArray().get(0).getAsJsonObject().get("labelAnnotations").getAsJsonArray()) {
    JsonObject labelObj = label.getAsJsonObject();
    String text = labelObj.get("description").getAsString();
    String entityId = labelObj.get("mid").getAsString();
    float score = labelObj.get("score").getAsFloat();
}