android - tag - Implementar Firebase dentro de una biblioteca

pod googletagmanager

Question

Quiero implementar el sistema de notificaciones Friebase dentro de una biblioteca que deseo usar como SDK en muchas aplicaciones.

Firebase está solicitando ahora un ID de aplicación, pero lo estoy implementando dentro de una biblioteca, por lo tanto no tengo ID de aplicación.

¿Cómo podría lograr mi objetivo de poder enviar notificaciones a mis aplicaciones que usan mi biblioteca?

Gracias por adelantado.

Answer 1

Por lo que sé, no puedes.

Cada proyecto Firebase necesita identificadores de paquetes para identificar de forma única cada una de sus aplicaciones.

También debe configurar cada módulo con su propio google-services.json , que se genera específicamente para cada ID.

En caso de que pueda usar el mismo paquete para todas sus aplicaciones, un dispositivo o la misma Play Store no podrían diferenciar una de otra, por lo que no es una opción.

Podría extraer toda la lógica de Firebase en su biblioteca, pero aún así tendría que configurar cada aplicación para proporcionar un ID de paquete único, y también tendría que enviar una notificación a cada ID.

Answer 2

Sé que esta es una pregunta antigua con una respuesta aceptada, pero todas las respuestas tienen un gran inconveniente: requieren que el usuario de su biblioteca haga un trabajo además de agregar su biblioteca a su aplicación. Hay una manera de hacerlo sin preocupar al usuario de su biblioteca en absoluto si su biblioteca se está descargando de un repositorio de Maven.

Nota: este método es un hack y no es compatible con Firebase. Cuando le pregunté a Firebase Support, recibí la siguiente respuesta:

Los SDK de Firebase no están destinados a proyectos de bibliotecas . Las características disponibles en Firebase se integraron en un nivel de aplicación y no en un módulo por biblioteca o biblioteca, por lo que no es posible o no se admite el caso de uso para tener esto integrado en un proyecto de biblioteca.

Sin embargo, he encontrado una manera de hacerlo y alguien puede encontrarlo útil, así que aquí está:

Este es un ejemplo para usar la base de datos en tiempo real, pero debería funcionar para todos los SDK de Firebase.

En el proyecto principal de build.gradle agregue el repositorio mavenCentral:

allprojects {
    repositories {
        ...
        mavenCentral()
    }
}

En el build.gradle del proyecto de su biblioteca, agregue Google Play Services (como una dependencia, no como un complemento):

compile ''com.google.android.gms:play-services-gcm:11.0.4''

Agregue los SDK de Firebase relevantes (con la misma versión que Google Play Services):

compile ''com.google.firebase:firebase-core:11.0.4''
compile ''com.google.firebase:firebase-database:11.0.4''

Registre su SDK como proyecto en Firebas, descargue es google-services.json y ábralo con cualquier editor de texto.

En las strings.xml su biblioteca, agregue las siguientes líneas y complete estas líneas con datos de google-services.json

<string name="gcm_defaultSenderId">project_number</string>
<string name="google_api_key">current_key</string>
<string name="google_app_id">mobilesdk_app_id</string>
<string name="google_crash_reporting_api_key">current_key</string>
<string name="google_storage_bucket">storage_bucket</string>
<string name="firebase_database_url">firebase_url</string>
<string name="default_web_client_id">client_id</string>
<string name="project_id">project_id</string>

Eso es todo. Puede usar Firebase Realtime Database en su biblioteca, luego compilarlo y publicarlo en Maven (la publicación en Maven es esencial, de lo contrario, el usuario de su biblioteca tendrá que agregar las dependencias manualmente). Cuando se activa desde dentro de una aplicación, se utilizará su base de datos.

Tenga en cuenta que este método puede causar excepciones y un comportamiento inesperado si el usuario de su biblioteca utilizará los servicios de Google Play o Firebase, ¡así que úselo bajo su propio riesgo!

Answer 3

Todos estos son un poco complicados o demasiado trabajo, aquí hay un bonito y sencillo ejemplo (irónico, porque es un post largo, pero vale la pena).

Es posible utilizar el código de FireBase en el proyecto de su biblioteca, por supuesto, la aplicación consumidora deberá registrar la aplicación y obtener el archivo de ID de aplicación / google-services.json .

Pero su biblioteca no lo hace, y no debería preocuparse por eso, es el trabajo de las aplicaciones consumidoras hacer eso, no su biblioteca.

Aquí hay un breve ejemplo del uso del firebase-messaging dentro de un proyecto de biblioteca.

El build.gradle del módulo de YourLibrary :

// Other typical library set up 
apply plugin: ''com.android.library''

android {
    compileSdkVersion 27

    defaultConfig {
        minSdkVersion 16
        targetSdkVersion 27
        versionCode 1
        versionName ''1.0''

        // Don’t for get your library’s proguard file!
        consumerProguardFiles ''proguard-rules.pro''
    }
}

ext {
    currentFirebaseVersion = "11.8.0"
}

dependencies {
    /* 
    Here we depend on the firebase messaging dependency (via compileOnly),
    allowing us to use the FireBase API within our library module.

    I exclude that org.json module because it may cause build warnings, this 
    step isn’t totally necessary.

    NOTE: You should use `compileOnly` here so the dependency is
    not added to the build output You will be allowed to use the 
    dependency in your library. If the consuming app wants to use firebase
    they’ll need to depend on it (using `implementation`).
    */
    compileOnly("com.google.firebase:firebase-messaging:$currentFirebaseVersion") {
        exclude group: ''org.json'', module: ''json''
    }
}

// Other typical library set up. But nothing else relating Firebase.

Esto es todo lo que necesitas hacer en el proyecto de tu biblioteca. NO aplique el complemento gms aquí, y no agregue la ruta de clases de servicios de google a las bibliotecas build.gradle .

Ahora aquí está cómo configurar su aplicación de consumo:

El nivel superior de construcción de MyClientApp :

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

buildscript {
    repositories {
        google() // You know the drill...
    }
    // Any other set up you might have...

    dependencies {
        classpath ''com.android.tools.build:gradle:3.0.1''
        /*
        Here in your client app’s top-level build.gradle you add the
        google-services to the app’s classpath.
        */
        classpath ''com.google.gms:google-services:3.2.0''
        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }
}
// Other basic stuff...
allprojects {
    apply plugin: ''maven''
    apply plugin: ''maven-publish''

    repositories {
        jcenter()
        google()
    }
}

Ahora necesitamos configurar el módulo de aplicaciones consumidor build.gradle , es simple. Simplemente necesitamos aplicar el complemento, y dependemos del módulo de biblioteca que creamos que contiene todo el código de FireBase .

El nivel de módulo de MyClientApp es build.gradle :

buildscript {
    repositories {
        google()
        mavenLocal()
    }
}
apply plugin: ''com.android.application''

android {
    compileSdkVersion 27
    defaultConfig {
        applicationId "com.your.application.that.can.use.firebase"
        minSdkVersion 16
        targetSdkVersion 27
        versionCode 1
        versionName ''1.0''
    }
    //other typical set up
}

ext {
    currentFirebaseVersion = "11.8.0"
}

dependencies {
    implementation(''com.your.library:YourLibrary:1.0@aar'') {
        transitive = true
        // Use the consuming application''s FireBase module, so exclude it
        // from the dependency. (not totally necessary if you use compileOnly
        // when declaring the dependency in the library project).
        exclude group: ''com.google.firebase''
        // Exclude the "plain java" json module to fix build warnings.
        exclude group: ''org.json'', module: ''json''
    }

    implementation("com.google.firebase:firebase-messaging:$currentFirebaseVersion") {
        // Exclude the "plain java" json module to fix build warnings.
        exclude group: ''org.json'', module: ''json''
    }
}

// Needs to be at the bottom of file.
apply plugin: ''com.google.gms.google-services''

Algunas cosas a tener en cuenta:

• Debe aplicar el complemento de servicios de google en la parte inferior (solo en el módulo de cliente build.gradle ).
• Dependa del módulo de biblioteca que tenga el código de FireBase , pero excluya su versión del módulo de FireBase , en favor de su propia versión de dependencia.
• La aplicación depende de su propia versión de FireBase .
• classpath ''com.google.gms:google-services:3.1.1'' solo va en el nivel superior build.gradle la aplicación del build.gradle .
• Por supuesto, deberá registrar la aplicación cliente y colocar google-services.json en el proyecto de su aplicación cliente.
• Defina los Service Firebase necesarios en el manifiesto de su aplicación (o use la fusión de manifiesto y combínelos desde el proyecto de su biblioteca)
• Agregue la google_play_services_version metadatos google_play_services_version al google_play_services_version de su aplicación cliente.
• La biblioteca puede / debe usar compileOnly al declarar la dependencia de FireBase .

Ahora podrá usar el código de FireBase en su aplicación que definió en su biblioteca que usa FireBase . ¡O puedes dejar que el módulo de tu biblioteca haga todo el trabajo de FireBase !

Por supuesto, esto generalmente se usa para las bibliotecas internas, ya que los marcos como Firebase no fueron diseñados para implementarse en módulos de biblioteca, pero a veces es necesario, por lo que esta es una solución simple y no intrincada para el problema. Se puede usar en proyectos que se distribuyen a través de maven. Mi biblioteca usa esto y nunca causó ningún problema.

Actualizar:

Debe utilizar compileOnly al declarar la dependencia de Firebase del módulo de biblioteca. Al hacerlo, la dependencia no se agregará a la salida de compilación. Pero se le permitirá usar la dependencia en su biblioteca. Si la aplicación consumidora quiere usar Firebase, tendrá que depender de ella manualmente (utilizando la implementation ). Esto ayudará a reducir las dependencias innecesarias / el aumento de volumen en las aplicaciones y la forma "correcta" de declarar una dependencia como esta. Nota: Es posible que deba realizar verificaciones de tiempo de ejecución para asegurarse de que la biblioteca esté disponible antes de usar su código en su módulo.

Answer 4

Una opción es hacer que el usuario de su biblioteca cree un proyecto de Firebase y luego pase el archivo resultante google-services.json a su aplicación, entonces su biblioteca puede depender de eso.

Answer 5

Sí, realmente puede hacer esto, en su biblioteca build.gradle ponga esto dentro del campo defaultConfig

buildConfigField("String", "FIREBASE_APP_KEY", "/"${firebaseAppKey}/"")

Luego dentro de las gradle.properties tu proyecto gradle.properties

firebaseAppKey = <yourFirebaseAppSecret>;

Para cada proyecto / aplicación, debe definir esta variable en su gradle.properties .

Tendrá que crear una aplicación Firebase para cada proyecto , pero su biblioteca ahora puede tener el SDK de Firebase.

Cuando desee acceder a este valor de variable de entorno, utilice BuildConfig.FIREBASE_APP_KEY (por ejemplo, ejemplifique la base de fuego).