Application multi-saveurs basée sur une bibliothèque multi-saveurs dans Android Gradle

Mon application a plusieurs versions pour plusieurs marchés de systèmes de facturation intégrée.

J'ai une seule bibliothèque qui partage le code de base pour tous mes projets. J'ai donc décidé d'ajouter ces systèmes de paiement à cette bibliothèque en tant que saveurs de produits.

La question est la suivante: la bibliothèque Android peut-elle avoir des saveurs de produits?

Si tel est le cas, comment puis-je inclure différentes saveurs dans la saveur respective de l'application?

J'ai beaucoup cherché et je n'ai rien trouvé sur ce scénario. La seule chose proche que j'ai trouvée était celle-ci dans http://tools.android.com/tech-docs/new-build-system/user-guide :

dependencies {
    flavor1Compile project(path: ':lib1', configuration: 'flavor1Release')
    flavor2Compile project(path: ':lib1', configuration: 'flavor2Release')
}

J'ai changé de configuration pour différentes choses mais cela n'a pas fonctionné!

J'utilise Android Studio 0.8.2.

Enfin j'ai découvert comment faire cela, je vais l'expliquer ici pour les autres confrontés au même problème:

L'élément clé est de définir publishNonDefault sur true dans la bibliothèque build.gradle, puis vous devez définir les dépendances comme suggéré par le guide de l'utilisateur.

L'ensemble du projet serait comme ceci:

Bibliothèque build.gradle:

apply plugin: 'com.android.library'

android {        
    ....
    publishNonDefault true
    productFlavors {
        market1 {}
        market2 {}
    }
}

projet build.gradle:

apply plugin: 'com.android.application'

android {
    ....
    productFlavors {
        market1 {}
        market2 {}
    }
}

dependencies {
    ....
    market1Compile project(path: ':lib', configuration: 'market1Release')
    market2Compile project(path: ':lib', configuration: 'market2Release')
}

Vous pouvez maintenant sélectionner la saveur de l'application et le panneau Variantes de construction et la bibliothèque sera sélectionnée en conséquence et toute la construction et l'exécution seront effectuées en fonction de la saveur sélectionnée.

Si vous avez plusieurs modules d'application basés sur la bibliothèque, Android Studio se plaindra du conflit de sélection de variantes, c'est ok, ignorez-le.

Il y a un problème avec la réponse d' Ali . Nous perdons une dimension très importante dans nos variantes de construction. Si nous voulons avoir toutes les options (dans mon exemple ci-dessous 4 (2 x 2)), nous devons simplement ajouter des configurations personnalisées dans le fichier build.gradle du module principal pour pouvoir utiliser tous les multi-buildType multi-saveur dans Build Variants. Nous devons également définir publishNonDefault sur true dans le fichier build.gradle du module de bibliothèque .

Exemple de solution:

Lib build.gradle

android {

    publishNonDefault true

    buildTypes {
        release {
        }
        debug {
        }
    }
    productFlavors {
        free {
        }
        paid {
        }
    }
}

Construction de l'application.

android {

    buildTypes {
        debug {
        }
        release {
        }
    }
    productFlavors {
        free {
        }
        paid {
        }
    }
}

configurations {
    freeDebugCompile
    paidDebugCompile
    freeReleaseCompile
    paidReleaseCompile
}

dependencies {

    freeDebugCompile project(path: ':lib', configuration: 'freeDebug')
    paidDebugCompile project(path: ':lib', configuration: 'paidDebug')
    freeReleaseCompile project(path: ':lib', configuration: 'freeRelease')
    paidReleaseCompile project(path: ':lib', configuration: 'paidRelease')

}

Mise à jour pour Android Plugin 3.0.0 et supérieur

Selon la documentation officielle Android - Migrez les configurations de dépendance pour les modules locaux ,

Avec la résolution des dépendances prenant en charge les variantes, vous n'avez plus besoin d'utiliser des configurations spécifiques aux variantes, telles que freeDebugImplementation, pour les dépendances de modules locaux - le plugin s'en charge pour vous

Vous devez plutôt configurer vos dépendances comme suit:

dependencies {
    // This is the old method and no longer works for local
    // library modules:
    // debugImplementation project(path: ':library', configuration: 'debug')
    // releaseImplementation project(path: ':library', configuration: 'release')

    // Instead, simply use the following to take advantage of
    // variant-aware dependency resolution. You can learn more about
    // the 'implementation' configuration in the section about
    // new dependency configurations.
    implementation project(':library')

    // You can, however, keep using variant-specific configurations when
    // targeting external dependencies. The following line adds 'app-magic'
    // as a dependency to only the "debug" version of your module.

    debugImplementation 'com.example.android:app-magic:12.3'
}

Donc dans la réponse d'Ali, changez

dependencies {
    ....
    market1Compile project(path: ':lib', configuration: 'market1Release')
    market2Compile project(path: ':lib', configuration: 'market2Release')
}

à

implementation project(':lib')

Et le plugin s'occupera automatiquement des configurations spécifiques aux variantes. J'espère que cela aidera les autres à mettre à niveau le plugin Android Studio vers la version 3.0.0 et supérieure.

Mon plug-in Android est 3.4.0, et je trouve qu'il n'a pas besoin de configuration maintenant.Tout ce dont vous avez besoin est de vous assurer que les flavours et productFlavors dans l'application contiennent un productFlavor de la même saveurDimensions et productFlavors dans les bibliothèques.

Dans build.gradle de mylibrary

apply plugin: 'com.android.library'

android {        
    ....
    flavorDimensions "mylibFlavor"

    productFlavors {
        market1
        market2
    }
}

build.gradle de l'application:

apply plugin: 'com.android.application'

android {
    ....
    flavorDimensions "mylibFlavor", "appFlavor"
    productFlavors {
        market1 {
            dimension "mylibFlavor"
        }
        market2 {
            dimension "mylibFlavor"
        }
        common1 {
            dimension "appFlavor"
        }
        common2 {
            dimension "appFlavor"
        }
    }
}

dependencies {
    ....
    implementation project(path: ':mylibrary')
}

Après la synchronisation, vous pouvez changer toutes les options dans la fenêtre Variantes de construction:

Pour que les versions fonctionnent sur une bibliothèque AAR, vous devez définir defaultPublishConfig dans le fichier build.gradle de votre module de bibliothèque Android.

Pour plus d'informations, voir: Publication de la bibliothèque .

Publication de la bibliothèque

Par défaut, une bibliothèque ne publie que sa version de version. Cette variante sera utilisée par tous les projets référençant la bibliothèque, quelle que soit la variante qu'ils construisent eux-mêmes. Il s'agit d'une limitation temporaire en raison des limitations Gradle que nous travaillons à supprimer. Vous pouvez contrôler quelle variante est publiée:

android {defaultPublishConfig "debug"}

Notez que ce nom de configuration de publication fait référence au nom complet de la variante. La version et le débogage ne sont applicables qu'en l'absence de saveurs. Si vous vouliez changer la variante publiée par défaut tout en utilisant des saveurs, vous écririez:

android {defaultPublishConfig "flavour1Debug"}

Pour le moment, ce n'est pas possible, même si si je me souviens bien, c'est une fonctionnalité qu'ils veulent ajouter. (Édition 2: lien , lien2 )

Edit: Pour le moment, j'utilise l' defaultPublishConfigoption pour déclarer quelle variante de bibliothèque est publiée:

android {
    defaultPublishConfig fullRelease
    defaultPublishConfig demoRelease 
}

Je sais que ce sujet a été fermé, mais juste une mise à jour avec gradle 3.0, voir ceci: https://developer.android.com/studio/build/gradle-plugin-3-0-0-migration.html#variant_aware et grep matchingFallbacksetmissingDimensionStrategy . Il est maintenant beaucoup plus simple de déclarer les dépendances entre les variantes de module.

... et dans ce cas précis avec gradle3.0, comme les saveurs partagent le même nom, gradle les mapperait comme par magie, aucune configuration n'est requise.

J'ai également rencontré un problème lors de la compilation de modules pour diverses options.

Ce que j'ai trouvé:

Il semble que nous n'avons pas besoin d'ajouter publishNonDefault truedans le build.gradlefichier de lib , depuis Gradle 3.0.1 .

Après avoir décompilé une classe a BaseExtensiontrouvé ceci:

public void setPublishNonDefault(boolean publishNonDefault) {
   this.logger.warn("publishNonDefault is deprecated and has no effect anymore. All variants are now published.");
}

Et au lieu de:

dependencies {
...
   Compile project(path: ':lib', configuration: 'config1Debug')
}

Nous devrions utiliser:

dependencies {
...
   implementation project(':lib')
}

La seule chose importante, c'est d'ajouter une configurations {...}partie au fichier build.gradle.

Ainsi, la dernière variante du build.gradlefichier de l'application est:

buildTypes {
   debug {
      ...
   }

   release {
      ...
   }
}

flavorDimensions "productType", "serverType"
productFlavors {
   Free {
      dimension "productType"
      ...
   }
   Paid {
      dimension "productType"
      ...
   }
   Test {
      dimension "serverType"
      ...
   }
   Prod {
      dimension "serverType"
      ...
   }
}

configurations {
   FreeTestDebug
   FreeTestRelease
   FreeProdDebug
   FreeProdRelease
   PaidTestDebug
   PaidTestRelease
   PaidProdDebug
   PaidProdRelease
}

dependencies {
   implementation fileTree(dir: 'libs', include: ['*.jar'])
   implementation project(':lib')
   ...
}

Vous pouvez également utiliser les variantes de filtre pour restreindre les variantes de construction.

N'oubliez pas d'inclure des modules dans le settings.gradlefichier, comme:

include ':app'
include ':lib'
project(':lib').projectDir = new File('app/libs/lib')