Pubblicare più librerie Android come una sola con la libreria combinata

Nei progetti con molti moduli, può essere difficile distribuire le librerie Android agli utenti cercando di mantenere una struttura chiara del progetto. In molti casi, è necessario pubblicare molte più librerie del previsto.

Il plug-in Fused Library incluso in Android Gradle Plugin consente di raggruppare più moduli della libreria Android in un'unica libreria Android pubblicabile. In questo modo puoi modularizzare il codice sorgente e le risorse della tua libreria all'interno della build come preferisci, evitando l'esposizione della struttura del progetto una volta distribuito.

La distribuzione come singola libreria può avere i seguenti vantaggi:

• Dipendenze semplificate:sostituisce più dipendenze della libreria con un singolo AAR, semplificando la configurazione del progetto e la gestione delle versioni per gli utenti
• Dimensioni ridotte della libreria:può migliorare la riduzione del codice, portando a file AAR più piccoli
• Maggiore sicurezza:può offrire un maggiore controllo sui dettagli di implementazione interni delle librerie pubblicate

Creare una libreria unita

Per creare una libreria unita, devi creare un nuovo modulo Android, aggiungere le dipendenze e poi pubblicare la libreria unita.

Aggiungere un nuovo modulo della libreria unita

Per utilizzare il plug-in, devi aggiungere un nuovo modulo Android al tuo progetto:

In questo esempio, il modulo della libreria combinata verrà chiamato myFusedLibrary.

1. Attiva il supporto della libreria unita aggiungendo android.experimental.fusedLibrarySupport=true al file gradle.properties.
2. Aggiungi include(":myFusedLibrary") al file settings.gradle.kts.
3. Aggiungi android-fusedlibrary = { id = "com.android.fused-library", version.ref = "agp" } nella sezione [plugins] del file gradle/libs.versions.toml.
4. Aggiungi alias(libs.plugins.android.fusedlibrary) apply false nel blocco dei plug-in nel file build.gradle.kts di primo livello.
5. Per creare il modulo myFusedLibrary, crea una nuova directory chiamata myFusedLibrary (fai clic con il tasto destro del mouse su "La mia applicazione" > Nuovo > Directory).
6. Crea un file build.gradle.kts nel modulo myFusedLibrary (fai clic con il tasto destro del mouse sul modulo myFusedLibrary > Nuovo > File).
7. Incolla il codice seguente nel file myFusedLibrary/build.gradle.kts:

plugins {
    alias(libs.plugins.android.fusedlibrary)
    `maven-publish`
}

androidFusedLibrary {
    namespace = "com.example.myFusedLibrary"
    minSdk = 21
}

dependencies { }

plugins {
    id 'fused-library'
}

androidFusedLibrary {
    namespace 'com.example.myFusedLibrary'
    minSdk 21
}

dependencies {

}

Aggiungere dipendenze

La funzionalità principale della libreria unita è raggruppare le dipendenze. Il plug-in supporta l'aggiunta di dipendenze di progetti locali e librerie esterne. Per specificare le dipendenze da includere nel pacchetto, utilizza la configurazione include. Le dipendenze transitive non vengono incluse nel pacchetto.

Ad esempio:

dependencies {
    include(project(":image-rendering"))
    include("mycoolfonts:font-wingdings:5.0")
}

dependencies {
    include project(':image-rendering')
    include 'mycoolfonts:font-wingdings:5.0'
}

Pubblicare la libreria unita

Prima di pubblicare una libreria unita, devi acquisire familiarità con la pubblicazione di una libreria Android. La pubblicazione di una libreria unita è simile alla pubblicazione di una libreria Android, ma ci sono alcune differenze fondamentali che devi considerare per pubblicare correttamente la libreria unita:

• Il plug-in Maven Publish deve essere applicato anche a qualsiasi modulo a cui è applicato il plug-in Fused Library.
• La pubblicazione deve ereditare da fusedLibraryComponent perché fornisce le dipendenze necessarie per compilare l'artefatto della libreria unita.

Ecco un esempio di configurazione delle pubblicazioni:

plugins {
    alias(libs.plugins.android.fusedlibrary)
    `maven-publish`
}

androidFusedLibrary { … }

dependencies { … }

publishing {
    publications {
        register<MavenPublication>("release") {
             groupId = "my-company"
             artifactId = "my-fused-library"
             version = "1.0"
             from(components["fusedLibraryComponent"])
        }
    }
}

plugins {
    id 'fused-library'
    id 'maven-publish'
}

androidFusedLibrary { … }

dependencies { … }

publishing {
    publications {
        release(MavenPublication) {
            groupId = "my-company"
            artifactId = "my-fused-library"
            version = "1.0"
            afterEvaluate {
            from components.fusedLibraryComponent
        }
    }
}

Pubblica la libreria unita per il test

Devi eseguire il test in base a una libreria combinata pubblicata da un'app Android o da una libreria Android. Il metodo consigliato è pubblicare nella libreria unita e le dipendenze del progetto in un repository Maven locale.

Per pubblicare gli artefatti della libreria unita in un repository locale, definisci una configurazione simile alla seguente:

plugins {
    alias(libs.plugins.android.fusedlibrary)
    `maven-publish`
}

repositories {
    maven {
        name = "myLocalRepo"
        url = uri(layout.buildDirectory.dir("myLocalRepo"))
    }
}

plugins {
    id 'fused-library'
    id 'maven-publish'
}

repositories {
    maven {
        name 'myLocalRepo'
        url layout.buildDirectory.dir('myLocalRepo')
    }
}

Caricare la libreria unita

Per distribuire la tua raccolta unita, consulta Caricare la raccolta.

Comportamento e misure di salvaguardia

La combinazione di librerie Android presenta complessità che possono rendere difficile al plug-in ragionare sulle priorità. Ad esempio, due librerie con lo stesso classpath causeranno un errore di build durante l'unione della libreria. L'unione delle risorse prenderà in considerazione l'ordine delle dipendenze specificato quando si seleziona una risorsa con lo stesso nome in librerie diverse.

• Le librerie unite possono essere pubblicate solo come artefatto AAR della libreria Android per essere aggiunte come dipendenza.
• La fusione di librerie che utilizzano il data binding non è supportata.
• Non puoi unire più tipi di build e varianti di prodotto all'interno di una singola libreria unita. Crea librerie fuse separate per le diverse varianti.

Per bilanciare la quantità di configurazione necessaria e la facilità d'uso, il plug-in non riuscirà a creare in caso di conflitti ambigui o utilizzerà l'euristica durante l'unione degli artefatti. I dettagli su come vengono uniti gli artefatti sono riportati nella tabella seguente:

 androidFusedLibrary { aarMetadata { minCompileSdk = 21 minCompileSdkExtension = 1 } }

Problemi noti

La libreria unificata è un nuovo plug-in e sono noti problemi in fase di risoluzione per soddisfare tutti i casi d'uso.

• Impossibile generare i file JAR di origine
• Aggiunta di dipendenze di file su altri file .aar
• Nessun supporto per la fusione di artefatti RenderScript e Prefab

Comprendere le dipendenze di una libreria unita

La libreria unita non ha origini e utilizza effettivamente le librerie Android come unica origine, è importante capire da dove provengono i dati. Per elencare le dipendenze unite nell'artefatto risultante e le dipendenze necessarie per creare l'artefatto, esegui l'attività gradle :report nella libreria unita. L'attività genera un report JSON che viene salvato nella directory build/reports della libreria unita.

Per ulteriori informazioni relative alle dipendenze interne dei plug-in, esegui l'attività gradle :dependencies per visualizzare lo stato delle configurazioni dei plug-in.