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

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

Il plug-in Fused Library in bundle con il plug-in Android Gradle consente di impacchettare più moduli della libreria Android in un'unica libreria Android pubblicabile. In questo modo puoi modulare il codice sorgente e le risorse della libreria all'interno della build come preferisci, evitando al contempo 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 della raccolta ridotte:può migliorare la riduzione del codice, con conseguente riduzione degli AAR
  • Maggiore sicurezza:può offrire un migliore controllo sui dettagli di implementazione interna delle librerie pubblicate

Creare una raccolta combinata

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

Aggiungere un nuovo modulo della raccolta combinata

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

In questo esempio, il modulo della libreria combinata si chiamerà myFusedLibrary.

  1. Attiva il supporto delle librerie fuse 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 denominata 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 seguente testo nel file myFusedLibrary/build.gradle.kts:

Kotlin

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

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

dependencies { }

Groovy

plugins {
    id 'fused-library'
}

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

dependencies {

}

Aggiungi dipendenze

La funzionalità di base della libreria combinata è raggruppare le dipendenze. Il plug-in supporta l'aggiunta di dipendenze del progetto locale e librerie esterne. Per specificare le dipendenze da pacchettizzare, utilizza la configurazione include. Le dipendenze transitive non vengono pacchettizzate.

Ad esempio:

Kotlin

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

Groovy

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

Pubblicare la raccolta unita

Ti consigliamo di acquisire familiarità con la pubblicazione di una libreria Android prima di pubblicare una libreria unita. La pubblicazione di una libreria fusa è simile alla pubblicazione di una libreria Android, ma ci sono alcune differenze fondamentali che devi prendere in considerazione per pubblicare correttamente la libreria fusa:

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

Ecco un esempio di configurazione delle pubblicazioni:

Kotlin

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"])
        }
    }
}

Groovy

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 i test

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

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

Kotlin

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

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

Groovy

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

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

Carica la raccolta unita

Per distribuire la raccolta unita, consulta Caricare la raccolta.

Comportamento e salvaguardie

La combinazione di librerie Android presenta complessità che possono rendere difficile per il plug-in ragionare sulle priorità. Ad esempio, due librerie con lo stesso percorso di classe causeranno un errore di compilazione durante l'unione della libreria. L'unione delle risorse considererà l'ordine delle dipendenze specificate quando viene selezionata una risorsa con lo stesso nome in librerie diverse.

  • Le librerie fuse possono essere pubblicate solo come elemento AAR della raccolta di librerie Android per essere aggiunte come dipendenza.
  • La fusione di librerie che utilizzano il binding dei dati non è supportata.
  • Non puoi unire più tipi di build e varianti di prodotto in un'unica libreria unita. Crea librerie fuse separate per varianti diverse.

Per bilanciare la quantità di configurazione necessaria e la facilità d'uso, il plug-in interromperà la compilazione in caso di conflitti ambigui o utilizzerà l'euristica durante l'unione degli elementi. I dettagli su come vengono fusi gli elementi sono riportati nella tabella riportata di seguito:

Tipo Comportamento
Classi Le librerie con lo stesso percorso di classe causeranno un errore di compilazione durante l'unione della libreria.
Risorse Android L'unione delle risorse prende in considerazione l'ordine delle dipendenze specificate quando si seleziona una risorsa con lo stesso nome in un altro.
Metadati AAR Le versioni dei metadati AAR vengono unite dando la priorità al valore più alto di ogni libreria delle dipendenze. È disponibile un DSL per eseguire l'override di questi valori.

Kotlin

 androidFusedLibrary { aarMetadata { minCompileSdk = 21 minCompileSdkExtension = 1 } }
Risorse Java I file di risorse Java in più librerie con percorsi identici non sono consentiti e causeranno un errore di compilazione.

Problemi noti

La raccolta combinata è un nuovo plug-in e sono in corso lavori per risolvere i problemi noti al fine di soddisfare tutti i casi d'uso.

  • I file lint.jar non sono inclusi nell'AAR unito
  • Aggiunta di dipendenze dei file su altri file .aar
  • Nessun supporto per l'unione di artefatti RenderScript e Prefab

Informazioni sulle dipendenze di una libreria fusa

La raccolta fusa non ha origini e utilizza efficacemente le raccolte Android come unica origine. È importante capire da dove proviene ogni elemento. Per elencare le dipendenze unite nell'elemento risultante e quelle necessarie per compilarlo, esegui l'attività gradle :report sulla libreria unita. Le attività generano un report JSON che viene salvato nella directorybuild/reports della libreria unita.

Per ulteriori informazioni sulle dipendenze dei plug-in interni, esegui il compito gradle :dependencies per visualizzare lo stato delle configurazioni dei plug-in.