Questa pagina è stata tradotta dall'API Cloud Translation.

Creare una raccolta Android

Una libreria Android è strutturalmente uguale a un modulo di app Android. Include tutto il necessario per creare un'app, compresi codice sorgente, di risorse e un manifest Android.

Tuttavia, invece di compilarlo in un APK eseguito su un dispositivo, una libreria Android viene compilata in un file AAR (Android Archive) che puoi usare come dipendenza per un modulo dell'app Android. A differenza dei file JAR, I file AAR offrono le seguenti funzionalità per le app per Android:

I file AAR possono contenere risorse Android e un file manifest, che consente raggruppa in risorse condivise come layout e disegnabili, alle classi e ai metodi Kotlin o Java.
I file AAR possono contenere C/C++ biblioteche per l'utilizzo dal codice C/C++ del modulo dell'app.

Un modulo della biblioteca è utile nelle seguenti situazioni:

Quando si creano più app che utilizzano alcune gli stessi componenti, ad esempio attività, servizi o layout di interfaccia utente
Quando si crea un'app che esiste in più varianti dell'APK, ad esempio una versione senza costi e una a pagamento, che condividono componenti principali

In entrambi i casi, sposta i file che vuoi riutilizzare in un modulo della libreria e quindi aggiungi la libreria come dipendenza per ogni modulo dell'app.

In questa pagina viene spiegato come creare e usare una raccolta Android in maggior dettaglio più avanti in questo modulo. Per indicazioni su come pubblicare una libreria, consulta Pubblicare la raccolta

Crea un modulo della libreria

Per creare un nuovo modulo della libreria nel tuo progetto, procedi come segue:

Fai clic su File > Nuovo > Nuovo modulo.
Nella finestra di dialogo Crea nuovo modulo visualizzata, Fai clic su Raccolta Android e poi su Avanti.
C'è anche un'opzione per creare una libreria Kotlin o Java, che crea un file JAR tradizionale. Sebbene un file JAR sia utile per molti per i progetti, in particolare quando vuoi condividere codice piattaforme, non ti consente di includere risorse Android o file manifest molto utile per il riutilizzo del codice nei progetti Android. Questa guida si concentra sulla creazione di librerie Android.
Assegna un nome alla libreria e seleziona una versione minima dell'SDK per il codice nella raccolta, quindi fai clic su Fine.
Importante: i nomi dei pacchetti di moduli devono essere univoci a livello globale. Non puoi avere due moduli con con lo stesso nome di pacchetto nello stesso progetto.

Una volta completata la sincronizzazione del progetto Gradle, il modulo Libreria viene visualizzato in nel riquadro Progetto. Se non vedi il nuovo modulo assicurati che nel riquadro sia visualizzata la vista Android.

Convertire un modulo dell'app in un modulo della libreria

Se hai già un modulo dell'app con codice che vuoi riutilizzare, puoi convertirlo in un modulo della biblioteca nel seguente modo:

Apri il file build.gradle a livello di modulo, se utilizzi Groovy, o il file build.gradle.kts, se utilizzi Kotlin lo script.
Elimina la riga per applicationId. Solo un modulo dell'app per Android può definire questa impostazione.

Individua il blocco "plugins" all'inizio del file con un aspetto simile al seguente:

Alla moda

  plugins {
      id 'com.android.application'
  }

Kotlin

  plugins {
      id("com.android.application")
  }

Modificalo come segue:

Alla moda

  plugins {
      id 'com.android.library'
  }

Kotlin

  plugins {
      id("com.android.library")
  }

Salva il file e fai clic su File > Sincronizza il progetto con i file Gradle.

La struttura del modulo rimane la stessa, ma ora funziona come una libreria Android. La build crea un file AAR anziché un APK.

Se vuoi creare il file AAR, seleziona il modulo Libreria nel nella finestra Progetto e fai clic su Build > Build APK.

Aggiungi dipendenze con la finestra di dialogo Struttura del progetto

Puoi utilizzare la finestra di dialogo Struttura del progetto per aggiungere dipendenze al tuo progetto. Le seguenti sezioni descrivono come utilizzare la finestra di dialogo per aggiungere delle dipendenze.

Utilizzare la raccolta dall'interno dello stesso progetto

Per usare il codice della nuova libreria Android in un'altra app o in un altro modulo della libreria all'interno di per lo stesso progetto, aggiungi una dipendenza a livello di progetto:

Vai a File > Progetto. Struttura > Dipendenze.
Seleziona il modulo che vuoi aggiungere la libreria.
Nella scheda Dipendenze dichiarate, fai clic su e seleziona Dipendenza modulo dal menu.
Nella finestra di dialogo Aggiungi dipendenza modulo, seleziona il modulo della libreria.
Seleziona la configurazione che richiede questa dipendenza oppure implementazione, se applicabile a tutte le configurazioni, fai clic su OK.

Android Studio modifica il file build.gradle o build.gradle.kts del modulo in aggiungi la dipendenza, nel formato seguente:

Alla moda

  implementation project(path: ":example-library")

Kotlin

  implementation(project(":example-library"))

Utilizzare la raccolta in altri progetti

Il modo consigliato per condividere le dipendenze (JAR e AAR) è utilizzare un di un repository, ospitato su un servizio, Maven Central oppure con una struttura di directory sul disco locale. Per ulteriori informazioni sull'utilizzo Repository Maven, consulta Remote di archiviazione dei dati.

Quando una libreria Android viene pubblicata in un Repository Maven, i metadati vengono in modo che le dipendenze della libreria siano incluse che consumano molte build. In questo modo la libreria viene deduplicata automaticamente perché viene utilizzato in più luoghi.

Per usare il codice della tua libreria Android in un altro modulo dell'app di un altro progetto: procedi nel seguente modo:

Passa a File > Struttura del progetto > Dipendenze.
Nella scheda Dipendenze dichiarate, fai clic su e seleziona Dipendenza libreria nel menu.
Nella finestra di dialogo Aggiungi dipendenza libreria, utilizza la casella di ricerca per trovare libreria da aggiungere. Questo modulo cerca nei repository specificati nel blocco dependencyResolutionManagement { repositories {...}} in settings.gradle o settings.gradle.kts.
Seleziona la configurazione che richiede questa dipendenza oppure implementazione, se applicabile a tutte le configurazioni, fai clic su OK.

Controlla il file build.gradle o build.gradle.kts dell'app per verificare che: appare una dichiarazione simile alla seguente (a seconda della configurazione della build selezionato):

Alla moda

  implementation 'com.example:examplelibrary:1.0.0'

Kotlin

  implementation("com.example:examplelibrary:1.0.0")

Aggiungi il tuo AAR o JAR come dipendenza

Per utilizzare il codice della tua libreria Android in un altro modulo dell'app, procedi nel seguente modo:

Vai a File >. Struttura del progetto > Dipendenze.
Nella scheda Dipendenze dichiarate, fai clic su e seleziona Jar Dipendenza nel menu.
Nella finestra di dialogo Aggiungi dipendenza Jar/Aar, inserisci il percorso del tuo AAR o JAR, quindi seleziona la configurazione a cui . Se la libreria deve essere disponibile per tutte le configurazioni, seleziona dell'implementazione.

Controlla il file build.gradle o build.gradle.kts dell'app per verificare che: appare una dichiarazione simile alla seguente (a seconda della configurazione della build selezionato):
Alla moda
```
  implementation files('my_path/my_lib.aar')
```
Kotlin
```
  implementation(files("my_path/my_lib.aar"))
```

Per importare una dipendenza sulla build Gradle in esecuzione al di fuori di Android Studio: aggiungi un percorso alla dipendenza il file build.gradle o build.gradle.kts dell'app. Ad esempio:

Alla moda

dependencies {
    implementation fileTree(dir: "libs", include: ["*.jar", "*.aar"])
}

Kotlin

dependencies {
    implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.jar", "*.aar"))))
}

Per saperne di più sull'aggiunta delle dipendenze Gradle, consulta Aggiungi dipendenze per la build.

Dichiara una risorsa pubblica

Le risorse includono tutti i file nella directory res/ del progetto, come le immagini. Tutte le risorse di una biblioteca sono pubbliche per impostazione predefinita. Per rendere tutti risorse implicitamente private, devi definire almeno un attributo specifico come pubblici.

Per dichiarare una risorsa pubblica, aggiungi una dichiarazione <public> al file public.xml della tua raccolta. Se non hai aggiunto elementi pubblici prima di utilizzare le risorse, devi creare il file public.xml Directory res/values/ della tua biblioteca.

Il codice di esempio riportato di seguito crea due risorse stringa pubbliche con il nomi mylib_app_name e mylib_public_string:

<resources>
    <public name="mylib_app_name" type="string"/>
    <public name="mylib_public_string" type="string"/>
</resources>

Per impedire agli utenti della tua libreria di accedere alle risorse previste solo per uso interno, usa questa designazione automatica meccanismo di dichiarazione con la dichiarazione di una o più risorse pubbliche. In alternativa, puoi apportare tutte le risorse private aggiungendo un tag <public /> vuoto. Questo non contrassegna nulla come pubblico e rende private tutte le risorse.

Le risorse che vuoi che rimangano visibili gli sviluppatori che usano la tua libreria dovrebbero essere resi pubblici.

Impostare implicitamente gli attributi come privati impedisce agli utenti della tua raccolta dalla ricezione di suggerimenti per il completamento del codice da risorse della libreria interna e consente agli utenti di rinominare o rimuovere risorse private senza interrompere client della tua libreria. Le risorse private vengono filtrate e filtrate per il completamento del codice e lo strumento Lint ti avvisa quando provi per fare riferimento a una risorsa privata.

Quando si crea una libreria, il plug-in Android Gradle ottiene la risorsa pubblica definizioni e le estrae nel file public.txt, che viene e pacchettizzati all'interno del file AAR.

Considerazioni sullo sviluppo per i moduli delle biblioteche

Durante lo sviluppo dei moduli della libreria e delle app dipendenti, tieni presente i comportamenti e limitazioni seguenti.

Le librerie vengono unite in ordine di priorità.

Dopo aver aggiunto i riferimenti ai moduli della libreria al modulo dell'app Android, puoi impostare la priorità relativa. In fase di creazione, le librerie vengono unite all'app una alla volta, a partire dalla versione la priorità più alta.
Evita conflitti di unione delle risorse.

Gli strumenti di creazione uniscono le risorse di un modulo libreria a quelle di un modulo dell'app dipendente. Se un determinato ID risorsa è definito in entrambi i moduli, risorsa dell'app.

Se si verificano conflitti tra più librerie AAR, la risorsa elencata per prima nell'elenco delle dipendenze (più vicina alla parte superiore del dependencies blocco).

Per evitare conflitti tra le risorse, utilizza classi R non transitive. Se questo non è possibile, valuta la possibilità di utilizzare o un altro schema di denominazione coerente univoco per il modulo (o univoci in tutti i moduli del progetto).
Nelle build multimodulo, le dipendenze JAR vengono trattate come e le dipendenze transitive.

Quando aggiungi una dipendenza JAR a un progetto libreria che restituisce un AAR, il JAR viene elaborato dal modulo della libreria e pacchettizzato con il relativo AAR.

Tuttavia, se il progetto include un modulo della libreria utilizzato da un'app , il modulo dell'app tratta la dipendenza JAR locale della libreria come un una dipendenza transitiva. In questo caso, il JAR locale viene elaborato dall'app che lo utilizza, e non dal modulo della libreria. Questo accelera build incrementali causate da modifiche al codice di una libreria.

Eventuali conflitti delle risorse Java causati da dipendenze JAR locali devono essere risolti nel modulo dell'app che utilizza la libreria.
Un modulo della libreria può dipendere da una libreria JAR esterna.

Puoi sviluppare un modulo della libreria che dipende da una libreria esterna. In questo caso, il modulo dipendente deve creare rispetto a un target che include la libreria esterna.

Tieni presente che sia il modulo della libreria sia l'app dipendente devono la libreria esterna nei relativi file manifest in un file <uses-library>.
Il valore minSdkVersion del modulo dell'app deve essere uguale o superiore a quella definita dalla libreria.

Una libreria viene compilata come parte del modulo dell'app dipendente, quindi le API utilizzate nel modulo della libreria deve essere compatibile con la versione della piattaforma su cui l'app supportati da questo modulo.
Ogni modulo della libreria crea la propria classe R.

Quando crei moduli dell'app dipendenti, i moduli della libreria vengono compilati in un file AAR e poi aggiunto al modulo dell'app. Di conseguenza, ogni libreria ha la sua Classe R, denominata in base al nome del pacchetto della libreria.

Il corso R generato dal modulo principale e il modulo Libreria è creato in tutti i pacchetti necessari, incluso quello del modulo principale e le librerie pacchetti.
Un modulo della libreria potrebbe includere la propria configurazione ProGuard .

Se hai un progetto libreria che utilizzi per creare e pubblicare un AAR, puoi aggiungere un file di configurazione ProGuard alla configurazione di compilazione della libreria. Se il plug-in Android Gradle applica le regole ProGuard specificate. Gli strumenti di creazione incorporano questo file all'interno del file AAR generato per la libreria in maggior dettaglio più avanti in questo modulo. Quando aggiungi la libreria a un modulo dell'app, il file ProGuard della libreria viene aggiunto al file di configurazione ProGuard (proguard.txt) di il modulo dell'app.

Incorporando un file ProGuard nel modulo della libreria, contribuisci a garantire che i moduli dell'app che dipendono dalla libreria non devono aggiornare manualmente File ProGuard per utilizzare la raccolta. Quando il sistema di compilazione di Android Studio nella tua app, usa le istruzioni sia del modulo dell'app sia della libreria. Quindi... non è necessario eseguire uno shrinker di codice nella libreria in un passaggio separato.

Per aggiungere le regole ProGuard al tuo progetto libreria, specifica il nome del file con la proprietà consumerProguardFiles all'interno del defaultConfig blocco dei build.gradle della tua biblioteca build.gradle.kts file.

Ad esempio, i seguenti set di snippet lib-proguard-rules.txt come configurazione ProGuard della libreria file:
Alla moda
```
android {
    defaultConfig {
        consumerProguardFiles 'lib-proguard-rules.txt'
    }
    ...
}
```
Kotlin
```
android {
    defaultConfig {
        consumerProguardFiles("lib-proguard-rules.txt")
    }
    ...
}
```
Tuttavia, se il modulo della libreria fa parte di una build multimodulo che si compila in un APK e non genera un AAR, esegui il codice riducendo solo il modulo dell'app che utilizza la libreria. Per scoprire di più sulle regole di ProGuard e sul loro utilizzo, leggi Ridurre, offuscare e ottimizzare Google Cloud.
Testare un modulo della libreria è quasi uguale testare un'app.

La differenza principale è che la libreria e le sue dipendenze incluse automaticamente come dipendenze dell'APK di test. Ciò significa che l'APK di test non include solo il proprio codice, ma anche l'AAR della libreria e tutte le sue dipendenze. Poiché non esiste un'app separata in fase di test, l'attività androidTest installa (e disinstalla) solo il test .

Durante l'unione più file manifest, Gradle segue l'ordine di priorità predefinito e unisce il file manifest della libreria al file manifest principale dell'APK di test.

Struttura di un file AAR

L'estensione del file per un file AAR è .aar e il tipo di artefatto Maven è aar. Il file stesso è un file ZIP. L'unica voce obbligatoria è /AndroidManifest.xml.

Un file AAR può anche includere uno o più dei seguenti elementi facoltativi voci:

/classes.jar
/res/
/R.txt
/public.txt
/assets/
/libs/name.jar
/jni/abi_name/name.so (dove abi_name è uno dei ABI supportate da Android)
/proguard.txt
/lint.jar
/api.jar
/prefab/ per l'esportazione di dati nativi biblioteche