Multi-Flavour-App basierend auf der Multi-Flavour-Bibliothek in Android Gradle

Meine App hat mehrere Varianten für In-App-Abrechnungssysteme für mehrere Märkte.

Ich habe eine einzige Bibliothek, die den Basiscode für alle meine Projekte teilt. Also beschloss ich, diese Zahlungssysteme als Produktvarianten zu dieser Bibliothek hinzuzufügen.

Die Frage ist, kann die Android-Bibliothek Produktaromen haben?

Wenn ja, wie kann ich verschiedene Geschmacksrichtungen in die jeweilige Geschmacksrichtung der App einbeziehen?

Ich habe viel gesucht und nichts zu diesem Szenario gefunden. Das einzige, was ich in der Nähe gefunden habe, war das in http://tools.android.com/tech-docs/new-build-system/user-guide:

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

Ich habe die Konfiguration auf verschiedene Dinge geändert, aber es hat nicht funktioniert!

Ich verwende Android Studio 0.8.2.

Endlich habe ich herausgefunden, wie das geht, ich werde es hier für andere erklären, die das gleiche Problem haben:

Der Schlüsselteil besteht darin, publishNonDefault in der Bibliothek build.gradle auf true zu setzen. Dann müssen Sie Abhängigkeiten definieren, wie im Benutzerhandbuch vorgeschlagen.

Das ganze Projekt würde so aussehen:

Bibliothek build.gradle:

apply plugin: 'com.android.library'

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

Projekt build.gradle:

apply plugin: 'com.android.application'

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

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

Jetzt können Sie das App-Flavor und das Build-Varianten-Bedienfeld auswählen, und die Bibliothek wird entsprechend ausgewählt, und alle Build- und Ausführungsvorgänge werden basierend auf dem ausgewählten Flavor durchgeführt.

Wenn Sie mehrere App-Module haben, die auf der Bibliothek basieren, beschwert sich Android Studio über Konflikte bei der Variantenauswahl. Es ist in Ordnung, ignorieren Sie es einfach.

Es gibt ein Problem mit der Ali-Antwort. Wir verlieren eine sehr wichtige Dimension in unseren Build-Varianten. Wenn wir alle Optionen haben wollen (in meinem Beispiel unten 4 (2 x 2)), müssen wir nur hinzufügen benutzerdefinierte Konfigurationen in Hauptmodul build.gradle Datei, um alle Multi-Flavor Multi-BuildType in verwenden zu können Build Variants. Wir müssen auch einstellen publishNonDefault wahr in dem Bibliotheksmodul build.gradle Datei.

Beispiellösung:

Lib build.gradle

android {

    publishNonDefault true

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

App build.gradle

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

}

Update für Android Plugin 3.0.0 und höher

Laut der offiziellen Android-Dokumentation – Migrieren Sie Abhängigkeitskonfigurationen für lokale Module,

Mit der variantenbewussten Abhängigkeitsauflösung müssen Sie keine variantenspezifischen Konfigurationen wie freeDebugImplementation mehr für lokale Modulabhängigkeiten verwenden – das Plugin erledigt das für Sie

Stattdessen sollten Sie Ihre Abhängigkeiten wie folgt konfigurieren:

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

Also in Alis Antwort, ändern

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

zu

implementation project(':lib')

Und das Plugin kümmert sich automatisch um variantenspezifische Konfigurationen. Ich hoffe, es hilft anderen, das Android Studio Plugin auf 3.0.0 und höher zu aktualisieren.

Mein Android-Plugin ist 3.4.0, und ich finde, dass es jetzt keine Konfigurationen benötigt. Alles, was Sie brauchen, ist sicherzustellen, dass die FlavorDimensions und ProductFlavors in der Anwendung ein ProductFlavor mit den gleichen FlavorDimensions und ProductFlavors in Bibliotheken enthalten.Zum Beispiel:

In build.gradle von mylibrary

apply plugin: 'com.android.library'

android {        
    ....
    flavorDimensions "mylibFlavor"

    productFlavors {
        market1
        market2
    }
}

build.gradle der Anwendung:

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

Nach der Synchronisierung können Sie alle Optionen im Fenster „Build Variants“ umschalten:

Damit die Varianten in einer AAR-Bibliothek funktionieren, müssen Sie defaultPublishConfig in der Datei build.gradle Ihres Android-Bibliotheksmoduls definieren.

Weitere Informationen finden Sie unter: Bibliotheksveröffentlichung.

Bibliotheksveröffentlichung

Standardmäßig veröffentlicht eine Bibliothek nur ihre Release-Variante. Diese Variante wird von allen Projekten verwendet, die auf die Bibliothek verweisen, egal welche Variante sie selbst bauen. Dies ist eine vorübergehende Einschränkung aufgrund von Gradle-Einschränkungen, an deren Entfernung wir arbeiten. Sie können steuern, welche Variante veröffentlicht wird:

android { defaultPublishConfig “debug” }

Beachten Sie, dass dieser Veröffentlichungskonfigurationsname auf den vollständigen Variantennamen verweist. Release und Debug sind nur anwendbar, wenn keine Flavors vorhanden sind. Wenn Sie die veröffentlichte Standardvariante ändern möchten, während Sie Flavors verwenden, würden Sie schreiben:

Android { defaultPublishConfig “flavor1Debug” }

Ich bin auch auf ein Problem beim Kompilieren von Modulen für verschiedene Optionen gestoßen.

Was ich gefunden habe:

Es sieht so aus, als müssten wir nicht hinzufügen publishNonDefault true in libs build.gradle Datei, da Klasse 3.0.1.

Nach dem Dekompilieren einer Klasse BaseExtension Ich habe es gefunden:

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

Und statt:

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

Wir sollten … benutzen:

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

Wichtig ist nur, a hinzuzufügen configurations {...} Teil zum build.gradle.

Also die finale Variante von App’s build.gradle Datei ist:

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

Außerdem können Sie verwenden Varianten filtern Build-Varianten einzuschränken.

Ps vergessen Sie nicht, Module in die einzufügen settings.gradle Datei, wie:

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

Im Moment ist es nicht möglich, obwohl, wenn ich mich richtig erinnere, es eine Funktion ist, die sie hinzufügen möchten. (Änderung 2: Verknüpfung, link2 )

Edit: Im Moment verwende ich die defaultPublishConfig Option zum Deklarieren, welche Bibliotheksvariante veröffentlicht wird:

android {
    defaultPublishConfig fullRelease
    defaultPublishConfig demoRelease 
}