Essayez d'utiliser Firebase Cloud Functions sur Android (Java)

Je suis nouveau sur Android J'ai essayé de faire Hello World en utilisant httpsCallable de Firebase Cloud Functions, je vais donc résumer la procédure.

1. Créez un projet Android

En supposant que le SDK Android lui-même est déjà installé, démarrez d'abord Android Studio et créez un projet.

Sélectionnez Fichier NouveauCréer un nouveau projet

Pour le modèle, sélectionnez ʻEmpty Activity (si vous le souhaitez) et entrez Nom, Nom du package, Enregistrer l'emplacement. Language sélectionne Java`.

2. Préparation du SDK Firebase

Ouvrez le projet Firebase (créez-le si vous ne l'avez pas déjà fait) dans votre navigateur et ajoutez l'application Android. Test_Project_–_設定_–_Firebase_console.png De là, l'écran du didacticiel sera affiché, nous allons donc le présenter tel quel. Sur la première page, entrez d'abord le nom du package qui a été défini précédemment dans Android Studio, puis entrez les éléments facultatifs. Sur la deuxième page, téléchargez google-services.json et allez directement dans le répertoire / app de votre projet Android. Sur la troisième page, modifiez d'abord les paramètres de construction de build.gradle dans la racine du projet.

build.gradle


// Top-level build file where you can add configuration options common to all sub-projects/modules.

buildscript {
    repositories {
        google()
        jcenter()
        
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:3.5.3'
        
        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
        classpath 'com.google.gms:google-services:4.3.3'
    }
}

allprojects {
    repositories {
        google()
        jcenter()
        
    }
}

task clean(type: Delete) {
    delete rootProject.buildDir
}

Confirmez qu'il y a google () à deux endroits, et il est invité à ajouter le module dépendant (com.google.gms: google-services).

Un autre, éditez build.gradle pour chaque application.

app/build.gradle


apply plugin: 'com.android.application'
apply plugin: 'com.google.gms.google-services'

android {
    compileSdkVersion 29
    buildToolsVersion "29.0.2"
    defaultConfig {
        applicationId "com.example.firebaseexample"
        minSdkVersion 16
        targetSdkVersion 29
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation 'androidx.appcompat:appcompat:1.1.0'
    implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
    //implementation 'com.google.firebase:firebase-core:17.2.2' //Ajouter lors de l'utilisation d'Analytics, etc.
    implementation 'com.google.firebase:firebase-functions:19.0.1'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'androidx.test.ext:junit:1.1.1'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
}

Ajoutez la deuxième ligne ʻapply plugin: 'com.google.gms.google-services'et ajoutez les packages dépendants requis. Une liste des packages est disponible ici (https://firebase.google.com/docs/reference/android/packages). Étant donné que nous n'utilisons que Cloud Functions cette fois, nous ajoutons uniquementcom.google.firebase: firebase-functions. Dans la source ci-dessus, chaque version a été remplacée par la dernière version. Pour le support Firebase, la minSdkVersion` doit être 16 ou plus. En d'autres termes, Android 4.1 est la limite inférieure d'utilisation du SDK Firebase actuel.

Il semble que ces étapes peuvent être effectuées en ouvrant la Fenêtre Assistant à partir de Outils Firebase d'Android Studio, mais c'est tout. Donc ça ne me semblait pas si pratique ...

Après cela, si la synchronisation passe avec File Sync Project with Gradle Files, l'installation du SDK est terminée.

3. Créer un écran d'application

Screenshot (Jan 31, 2020 7_47_28 PM).png

Comme ça, créons un écran qui envoie le texte saisi à Cloud Functions et affiche la valeur de retour.

app/src/main/res/layout/activity_main.xml


<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">
    <RelativeLayout
        android:id="@+id/container"
        android:layout_width="match_parent"
        android:layout_height="match_parent">
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="vertical"
            android:gravity="center"
            android:layout_centerVertical="true">
            <TextView
                android:id="@+id/title"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@string/title" />
            <EditText
                android:id="@+id/name"
                android:layout_width="200dp"
                android:layout_height="wrap_content"
                android:layout_marginTop="32dp"
                android:singleLine="true"/>
            <Button
                android:id="@+id/ok_button"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_marginTop="32dp"
                android:text="@string/ok_button"
                android:textColor="@color/colorWhite"
                android:background="@color/colorAccent"
                />
            <TextView
                android:id="@+id/result"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_marginTop="32dp"
                android:text=""/>
        </LinearLayout>
    </RelativeLayout>
</androidx.constraintlayout.widget.ConstraintLayout>

Modifiez les ressources utilisées à l'écran.

app/src/main/res/values/colors.xml


<?xml version="1.0" encoding="utf-8"?>
<resources>
    <color name="colorPrimary">#051E34</color>
    <color name="colorPrimaryDark">#051E34</color>
    <color name="colorAccent">#1A73E8</color>
    <color name="colorWhite">#FFFFFF</color>
</resources>

app/src/main/res/values/strings.xml


<resources>
    <string name="app_name">FirebaseExample</string>
    <string name="title">Enter your name!</string>
    <string name="ok_button">OK</string>
</resources>

4. Mettre en œuvre le traitement

Tout d'abord, ajoutez une autorisation d'accès Internet (avant <application> `) au manifeste. Cela semble fonctionner sans ajouter cela, mais juste au cas où.

app/src/main/AndroidManifest.xml (partie)


<uses-permission android:name="android.permission.INTERNET" />

Ajoutez le traitement à MainActivity.

java:app/src/main/java/.../MainActivity


package com.example.firebaseexample;

import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;

import android.content.Context;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.inputmethod.InputMethodManager;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;

import com.google.android.gms.tasks.Continuation;
import com.google.android.gms.tasks.OnCompleteListener;
import com.google.android.gms.tasks.Task;
import com.google.firebase.functions.FirebaseFunctions;
import com.google.firebase.functions.FirebaseFunctionsException;
import com.google.firebase.functions.HttpsCallableResult;

import java.util.HashMap;
import java.util.Map;

public class MainActivity extends AppCompatActivity {
    private FirebaseFunctions mFunctions;
    private EditText nameInput;
    private TextView resultTextView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //Obtenir le client Cloud Functions
        mFunctions = FirebaseFunctions.getInstance();

        //Obtenir des éléments d'écran
        resultTextView = findViewById(R.id.result);
        nameInput = findViewById(R.id.name);

        //Définir l'écouteur d'événements de clic sur le bouton
        final Button okButton = findViewById(R.id.ok_button);
        okButton.setOnClickListener(new View.OnClickListener() {
            public void onClick(View view) {
                final String name = nameInput.getText().toString();
                helloWorld(name);
                hideInput(view);
            }
        });

        //Traitement pour fermer le clavier lorsque vous appuyez sur l'écran
        final View container = findViewById(R.id.container);
        container.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                hideInput(view);
            }
        });
    }

    /**
     *Fermer le clavier
     * @vue param. Vue cliquée
     */
    private void hideInput(@NonNull View view) {
        InputMethodManager inputMethodManager = (InputMethodManager)
                view.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
        if (inputMethodManager != null) {
            inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(),0);
        }
    }

    /**
     *Accédez à une fonction Cloud Functions
     * @nom du paramètre nom
     * @return task
     */
    private Task helloWorld(String name) {
        //Créer des données à envoyer
        Map<String, Object> data = new HashMap<>();
        data.put("name", name);
        
        //appeler la fonction helloWorld
        return mFunctions
                .getHttpsCallable("helloWorld")
                .call(data)
                .continueWith(new Continuation<HttpsCallableResult, String>() {
                    @Override
                    public String then(@NonNull Task<HttpsCallableResult> task) {
                        String result = (String) task.getResult().getData();
                        return result;
                    }
                })
                .addOnCompleteListener(new OnCompleteListener<String>() {
                    @Override
                    public void onComplete(@NonNull Task<String> task) {
                        if (!task.isSuccessful()) { //En cas d'erreur
                            Exception e = task.getException();
                            if (e instanceof FirebaseFunctionsException) {
                                //Afficher le contenu de l'erreur dans le journal
                                FirebaseFunctionsException ffe = (FirebaseFunctionsException) e;
                                FirebaseFunctionsException.Code code = ffe.getCode();
                                Object details = ffe.getDetails();
                                Log.e("functions error", code.toString());
                                Log.e("functions error", String.valueOf(details));
                            }
                        } else {
                            String result = task.getResult();
                            if (result != null) {
                                resultTextView.setText(result); //Définissez la valeur de retour à l'écran
                            }
                        }
                    }
                });
    }
}

Je ne suis pas habitué au traitement asynchrone en Java, donc cela peut sembler déroutant, mais fondamentalement, si vous suivez ce tutoriel, vous pouvez utiliser Functions en douceur.

** Fonction d'appel depuis l'application | Firebase ** (sélectionnez l'onglet Java Android) https://firebase.google.com/docs/functions/callable

5. Ajouter une fonction

L'implémentation et le déploiement des fonctions sont les mêmes que lorsqu'ils sont utilisés sur le Web. Si vous n'avez pas installé globalement Firebase CLI, installez-le comme suit.

$ npm install -g firebase-tools

Initialisez dans n'importe quel répertoire (même dans le répertoire du projet).

$ firebase init

Après vous être connecté à votre compte et sélectionné un projet, un écran de saisie pour sélectionner la fonction à utiliser apparaît. Sélectionnez Fonctions (touche espace) ici.

? Which Firebase CLI features do you want to set up for this folder? Press Space
 to select features, then Enter to confirm your choices. (Press <space> to selec
t, <a> to toggle all, <i> to invert selection)
 ◯ Database: Deploy Firebase Realtime Database Rules
 ◯ Firestore: Deploy rules and create indexes for Firestore
❯◯ Functions: Configure and deploy Cloud Functions
 ◯ Hosting: Configure and deploy Firebase Hosting sites
 ◯ Storage: Deploy Cloud Storage security rules
 ◯ Emulators: Set up local emulators for Firebase features

Une fois le répertoire functions créé, ajoutez et déployez une fonction qui renvoie simplement une chaîne comme celle-ci.

functions/index.js


const functions = require('firebase-functions');

exports.helloWorld = functions.https.onCall((data, context) => {
  return `Hello ${data.name}`;
});
$ firebase deploy --only functions

6. Courir

Si vous connectez votre appareil Android avec USB et Run,

Screenshot (Jan 31, 2020 8_20_58 PM).png J'ai pu confirmer que `httpsCallable` peut être utilisé sans aucun problème et la valeur de retour est affichée.

Recommended Posts

Essayez d'utiliser Firebase Cloud Functions sur Android (Java)
Essayez la communication en utilisant gRPC sur un serveur Android + Java
Essayez la classification d'image à l'aide de TensorFlow Lite sur Android (JAVA)
Essayez d'utiliser le service sur Android Oreo
Filtre Sobel utilisant OpenCV sur Android (Java)
Essayez d'utiliser l'API Cloud Vision de GCP en Java
[Android] [Java] Télécharger des images sur GCS (Google Cloud Storage) avec Stream à l'aide de Glide
J'ai essayé d'utiliser "nifty cloud mobile backend" et l'authentification "Firebase" sur Kotlin + Android
Essayez d'utiliser RocksDB avec Java
Essayez de gratter en utilisant Java [Note]
Essayez Hello World en utilisant Java brut sur le conteneur Docker
OSX 10.15 (Catalina) Utilisation de Java avec β
Essayez d'implémenter Android Hilt en Java
Essayez Redmine sur le docker Mac
Essayez Quarkus avec IBM Cloud Shell
Essayez d'utiliser Redis avec Java (jar)
Utiliser Java 11 avec Google Cloud Functions
Enregistrer ArrayList à l'aide de GSON sur Android
[Java] Essayez de mettre en œuvre à l'aide de génériques
Essayez d'utiliser le traçage de méthode IBM Java
Remarques sur le traitement des threads Android (java)
Essayez d'utiliser le SDK Java d'Hyperledger Iroha
[Java] Où avez-vous essayé d'utiliser java
Essayez d'utiliser la fonction de mesure en deux points de Firebase Performance Monitoring. [Android]
Essayez d'utiliser le framework Java Nablarch [Application Web]
Essayez d'utiliser l'API Stream en Java
Utilisation de JupyterLab + Java avec WSL sous Windows 10
Appeler java depuis C ++ sur Android NDK
Remarques sur les opérateurs utilisant Java ~ Type chaîne ~
Étude de Java Essayez d'utiliser un scanner ou une carte
Essayez d'utiliser l'API au format JSON en Java
Créer un environnement de développement Java 8 avec AWS Cloud 9
Déployer des programmes Java sur SAP Cloud Platform
Essayez d'utiliser l'API REST de JobScheduler - implémentation Java RestClient--
Essayez d'utiliser l'API Emotion d'Android
Essayez d'utiliser la télécommande Wii en Java
Créer des applications Java avec IBM Cloud Functions
Essayez d'utiliser la classe de test RestClient de JobScheduler REST-API-Java-
Essayez de créer un environnement Java 8 sur Amazon Linux2
Installez java et android-sdk sur Mac en utilisant homebrew
Essayez Azure Service Fabric (Java) sur un environnement Mac-Local
Les débutants essaient d'utiliser Android Studio Partie 2 (traitement des événements)
Essayez d'utiliser Sourcetrail (version win) avec du code Java
Essayez d'utiliser Sourcetrail (version macOS) avec du code Java
Les débutants essaient d'utiliser Android Studio Partie 1 (Hello World)
Essayez une recherche similaire de recherche d'images à l'aide du SDK Java [Recherche]
Essayez d'accéder à l'ensemble de données depuis Java en utilisant JZOS
Traduire à l'aide de l'API Microsoft Translator Text sur Android ~ Implémentation ~
Essayez d'utiliser l'analyse syntaxique de l'API COTOHA en Java
Histoire de l'automatisation des tests avec Appium [Android / java]
Essayez d'utiliser libGDX
Essayez d'utiliser Maven
Essayez d'utiliser powermock-mockito2-2.0.2
Essayez d'utiliser GraalVM
Essayez Java 8 Stream
Essayez d'utiliser jmockit 1.48