Questa pagina è stata tradotta dall'API Cloud Translation.

strumento strumenti

bundletool è lo strumento sottostante che Android Studio, il plug-in Android Gradle e Google Play utilizzano per creare un Android App Bundle. bundletool può convertire un app bundle nei vari APK di cui viene eseguito il deployment sui dispositivi.

Android SDK Bundle (ASB) e i relativi APK sono creati con bundletool. È disponibile anche come strumento a riga di comando, quindi puoi creare app bundle e bundle SDK autonomamente e ricreare la build lato server di Google Play degli APK della tua app o degli APK degli SDK abilitati per runtime.

Scarica `bundletool`

Se non l'hai ancora fatto, scarica bundletool dal repository di GitHub.

Creare e testare un app bundle

Puoi usare Android Studio o lo strumento a riga di comando bundletool per creare il tuo Android App Bundle, quindi testare la generazione di APK da questo app bundle.

Creare un app bundle

Usa Android Studio e il plug-in Android Gradle per creare e firmare un Android App Bundle. Tuttavia, se l'utilizzo dell'IDE non è disponibile, ad esempio perché stai usando un server di compilazione continua, puoi anche creare il tuo app bundle dalla riga di comando e firmarlo utilizzando jarsigner.

Per saperne di più sulla creazione di app bundle con bundletool, consulta Creare un app bundle utilizzando bundletool.

Generare un insieme di APK dall'app bundle

Dopo aver creato l'Android App Bundle, verifica come Google Play lo utilizza per generare APK e come si comportano quando viene implementato su un dispositivo.

Puoi testare il tuo app bundle in due modi:

Utilizza lo strumento a riga di comando bundletool in locale.
Carica il bundle in Play Console tramite Google Play utilizzando un canale di test.

Questa sezione spiega come utilizzare bundletool per testare il tuo app bundle localmente.

Quando bundletool genera APK dall'app bundle, include gli APK generati in un contenitore chiamato archivio set di APK, che utilizza l'estensione file .apks. Per generare a partire dall'app bundle un set di APK per tutte le configurazioni dispositivo supportate dalla tua app, usa il comando bundletool build-apks, come mostrato:

bundletool build-apks --bundle=/MyApp/my_app.aab --output=/MyApp/my_app.apks

Se vuoi eseguire il deployment degli APK su un dispositivo, devi includere anche le informazioni di firma dell'app, come mostrato nel comando seguente. Se non specifichi le informazioni di firma, bundletool tenta di firmare gli APK con una chiave di debug per tuo conto.

bundletool build-apks --bundle=/MyApp/my_app.aab --output=/MyApp/my_app.apks
--ks=/MyApp/keystore.jks
--ks-pass=file:/MyApp/keystore.pwd
--ks-key-alias=MyKeyAlias
--key-pass=file:/MyApp/key.pwd

Nella tabella seguente sono descritti i vari flag e le opzioni che puoi impostare quando utilizzi il comando bundletool build-apks in modo più dettagliato:

Tabella 1. Opzioni per il comando bundletool build-apks

Segnala	Descrizione
`--bundle=path`	(Obbligatorio) Specifica il percorso dell'app bundle creato con Android Studio. Per scoprire di più, consulta Creare il progetto.
`--output=path`	(Obbligatorio) Specifica il nome del file `.apks` di output, che contiene tutti gli elementi APK della tua app. Per testare gli elementi in questo file su un dispositivo, segui i passaggi nella sezione su come implementare gli APK su un dispositivo connesso.
`--overwrite`	Sovrascrive qualsiasi file di output esistente con il percorso specificato utilizzando l'opzione `--output`. Se non includi questo flag e il file di output esiste già, viene visualizzato un errore di compilazione.
`--aapt2=path`	Specifica un percorso personalizzato per AAPT2. Per impostazione predefinita, `bundletool` include la propria versione di AAPT2.
`--ks=path`	(Facoltativo) Specifica il percorso dell'archivio chiavi di deployment utilizzato per firmare gli APK. Se non includi questo flag, `bundletool` tenta di firmare gli APK con una chiave di firma di debug.
`--ks-pass=pass:password` o `--ks-pass=file:/path/to/file`	Specifica la password dell'archivio chiavi. Se specifichi una password in testo normale, qualificala con `pass:`. Se trasmetti il percorso a un file che contiene la password, qualificalo con `file:`. Se specifichi un archivio chiavi utilizzando il flag `--ks` senza specificare `--ks-pass`, `bundletool` ti chiederà di inserire una password dalla riga di comando.
`--ks-key-alias=alias`	Specifica l'alias della chiave di firma che vuoi utilizzare.
`--key-pass=pass:password` o `--key-pass=file:/path/to/file`	Specifica la password per la chiave di firma. Se specifichi una password in testo normale, qualificala con `pass:`. Se trasmetti il percorso a un file che contiene la password, qualificalo con `file:`. Se la password è identica a quella dell'archivio chiavi, puoi omettere questo flag.
`--connected-device`	Comunica a `bundletool` di creare APK che hanno come target la configurazione di un dispositivo connesso. Se non includi questo flag, `bundletool` genera APK per tutte le configurazioni dispositivo supportate dalla tua app.
`--device-id=serial-number`	Se hai più di un dispositivo connesso, utilizza questo flag per specificare l'ID seriale del dispositivo su cui vuoi eseguire il deployment dell'app.
`--device-spec=spec_json`	Fornisce un percorso a un file `.json` che specifica la configurazione del dispositivo da scegliere come target. Per scoprire di più, consulta la sezione su come generare e utilizzare i file JSON delle specifiche del dispositivo.
`--mode=universal`	Imposta la modalità su `universal`. Utilizza questa opzione se vuoi che `bundletool` crei un singolo APK che includa tutto il codice e le risorse dell'app, in modo che l'APK sia compatibile con tutte le configurazioni dispositivo supportate dalla tua app. Nota: `bundletool` include solo i moduli delle funzionalità che specificano `<dist:fusing dist:include="true"/>` nel file manifest in un APK universale. Per saperne di più, leggi informazioni sul manifest dei moduli delle funzionalità. Tieni presente che questi APK sono più grandi di quelli ottimizzati per una determinata configurazione dispositivo. Tuttavia, sono più facili da condividere con tester interni che, ad esempio, vogliono testare la tua app su più configurazioni dispositivo.
`--local-testing`	Attiva l'app bundle per i test locali. I test locali consentono di eseguire cicli di test rapidi e iterativi senza dover caricare i server su Google Play. Per un esempio di come testare l'installazione dei moduli utilizzando il flag `--local-testing`, consulta Testare le installazioni di moduli a livello locale.

Eseguire il deployment di APK su un dispositivo connesso

Dopo aver generato un insieme di APK, bundletool può eseguire il deployment della giusta combinazione di APK del gruppo in questione su un dispositivo collegato.

Ad esempio, se hai un dispositivo connesso con Android 5.0 (livello API 21) o versioni successive, bundletool esegue il push dell'APK di base, degli APK dei moduli delle funzionalità e degli APK di configurazione necessari per eseguire l'app sul dispositivo. In alternativa, se sul dispositivo connesso è in esecuzione Android 4.4 (livello API 20) o versioni precedenti, bundletool cerca un APK multiplo compatibile da implementare sul dispositivo.

Per eseguire il deployment della tua app da un set di APK, utilizza il comando install-apks e specifica il percorso del set di APK tramite il flag --apks=/path/to/apks, come mostrato nel comando seguente. Se hai più dispositivi connessi, specifica un dispositivo di destinazione aggiungendo il flag --device-id=serial-id.

bundletool install-apks --apks=/MyApp/my_app.apks

Generare un insieme di APK specifico per dispositivo.

Se non vuoi creare un set di APK per tutte le configurazioni dispositivo supportate dalla tua app, puoi creare APK che hanno come target solo la configurazione di un dispositivo connesso, utilizzando l'opzione --connected-device, come mostrato nel comando seguente. Se hai più dispositivi collegati, specifica un dispositivo di destinazione includendo il flag --device-id=serial-id.

bundletool build-apks --connected-device
--bundle=/MyApp/my_app.aab --output=/MyApp/my_app.apks

Generare e utilizzare file JSON delle specifiche del dispositivo

bundletool può generare un set di APK che ha come target una configurazione del dispositivo specificata da un file JSON. Per generare prima un file JSON per un dispositivo connesso, esegui questo comando:

bundletool get-device-spec --output=/tmp/device-spec.json

bundletool crea un file JSON per il dispositivo nella directory dello strumento. Potrai quindi passare il file a bundletool per generare un set di APK che hanno come target solo la configurazione descritta in quel file JSON, come segue:

bundletool build-apks --device-spec=/MyApp/pixel2.json
--bundle=/MyApp/my_app.aab --output=/MyApp/my_app.apks

Creare manualmente un JSON delle specifiche del dispositivo

Se non hai accesso al dispositivo per cui vuoi creare un set di APK target (ad esempio, se vuoi provare la tua app con un dispositivo che non hai a disposizione), puoi creare manualmente un file JSON utilizzando il seguente formato:

{
  "supportedAbis": ["arm64-v8a", "armeabi-v7a"],
  "supportedLocales": ["en", "fr"],
  "screenDensity": 640,
  "sdkVersion": 27
}

Dopodiché puoi passare questo JSON al comando bundle extract-apks, come descritto nella sezione precedente.

Estrazione di APK specifici per dispositivo da un set di APK esistente

Se hai già impostato un APK e vuoi estrarre da quest'ultimo un sottoinsieme di APK che hanno come target una configurazione del dispositivo specifica, puoi usare il comando extract-apks e specificare un JSON per le specifiche del dispositivo, come indicato di seguito:

bundletool extract-apks
--apks=/MyApp/my_existing_APK_set.apks
--output-dir=/MyApp/my_pixel2_APK_set.apks
--device-spec=/MyApp/bundletool/pixel2.json

Misurare le dimensioni di download stimate degli APK in un set di APK

Per misurare le dimensioni di download stimate degli APK in un set di APK che verrebbero pubblicati come compressi tramite cavo, utilizza il comando get-size total:

bundletool get-size total --apks=/MyApp/my_app.apks

Puoi modificare il comportamento del comando get-size total utilizzando i seguenti flag:

Tabella 2. Opzioni per il comando get-size total

Segnala	Descrizione
`--apks=path`	(Obbligatorio) Specifica il percorso del file set di APK esistente di cui vengono misurate le dimensioni di download.
`--device-spec=path`	Specifica il percorso del file delle specifiche del dispositivo (da `get-device-spec` o creato manualmente) da utilizzare per la corrispondenza. Puoi specificare un percorso parziale per valutare un insieme di configurazioni.
`--dimensions=dimensions`	Specifica le dimensioni utilizzate per il calcolo delle stime delle dimensioni. Accetta un elenco separato da virgole di: `SDK`, `ABI`, `SCREEN_DENSITY` e `LANGUAGE`. Per effettuare misurazioni in tutte le dimensioni, specifica `ALL`.
`--instant`	Misura le dimensioni di download degli APK ad attivazione istantanea anziché degli APK installabili. Per impostazione predefinita, `bundletool` misura le dimensioni di download degli APK installabili.
`--modules=modules`	Specifica un elenco separato da virgole di moduli nell'APK impostato da prendere in considerazione nella misurazione. Il comando `bundletool` include automaticamente tutti i moduli dipendenti per il set specificato. Per impostazione predefinita, il comando misura le dimensioni di download di tutti i moduli installati durante il primo download.

Crea un app bundle con una dipendenza dell'SDK bundle (sperimentale)

Puoi creare il tuo Android App Bundle con una dipendenza Android SDK Bundle (ASB) dalla riga di comando e firmarlo utilizzando jarsigner.

Ogni modulo di app bundle include un file Module Protocol Buffer (.pb): runtime_enabled_sdk_config.pb. Questo file contiene l'elenco di SDK da cui dipende un modulo per app bundle. Per la definizione completa di questo file, consulta il file runtime_enabled_sdk_config.proto.

Per creare un app bundle con una dipendenza da SDK bundle, segui i passaggi nella sezione relativa alla creazione di un app bundle utilizzando bundletool e aggiungi un file runtime_enabled_sdk_config.pb al file ZIP di ogni modulo dell'app con le risorse e il codice compilati.

Alcuni campi importanti nel file runtime_enabled_sdk_config.pb:

Digest certificato: il digest SHA-256 del certificato per la chiave utilizzata per firmare gli APK dell'SDK. Corrisponde al certificato nel file SdkMetadata.pb nel formato Android SDK Archive.
ID pacchetto di risorse: l'ID pacchetto a cui vengono rimappate tutte le risorse in questo SDK durante la generazione di APK per incorporare l'SDK nell'app. Ciò consente la compatibilità con le versioni precedenti.

Un SDK può essere visualizzato in un solo modulo. Se più moduli dipendono dallo stesso SDK, questa dipendenza deve essere deduplicata e spostata nel modulo di base. Moduli diversi non possono dipendere da versioni diverse dell'SDK.

Genera APK da un app bundle con una dipendenza dell'SDK bundle (sperimentale)

Per generare APK dall'app bundle, segui i passaggi nella sezione relativa alla generazione di un insieme di APK dall'app bundle o nella sezione relativa alla generazione di un insieme di APK specifico per dispositivo e fornisci il comando bundletool build-apks con gli SDK da cui dipende l'app. Questi SDK possono essere forniti in formato bundle SDK o nel formato SDK Archive.

Puoi fornire gli SDK come bundle SDK aggiungendo il flag --sdk-bundles come segue:

bundletool build-apks --bundle=app.aab --sdk-bundles=sdk1.asb,sdk2.asb \
    --output=app.apks

Puoi fornire gli SDK come archivi di SDK aggiungendo il flag --sdk-archives, come segue:

bundletool build-apks --bundle=app.aab --sdk-archives=sdk1.asar,sdk2.asar \
    --output=app.apks

Genera APK da un app bundle con una dipendenza per SDK bundle per i dispositivi che non supportano la libreria SDK

I dispositivi precedenti ad Android 13 non supportano l'installazione di librerie SDK o l'esecuzione nel runtime dell'SDK. Bundletool nasconde la complessità della compatibilità con le versioni precedenti e genera più varianti del tuo set di APK dallo stesso app bundle quando esegui bundletool build-apks con l'opzione --sdk-bundles o --sdk-archives. Le diverse varianti hanno come target dispositivi con funzionalità diverse:

Esiste una variante per i dispositivi più recenti, in cui l'SDK viene installato come pacchetto separato dall'app e gli APK dell'app non includono contenuti dell'SDK.
Esistono una o più varianti per i dispositivi meno recenti, in cui gli APK dell'SDK vengono aggiunti all'APK dell'app impostato come ulteriori suddivisioni dell'APK. Gli APK dell'SDK appartengono al pacchetto dell'app. In questo caso, il runtime dell'SDK viene emulato nel runtime dell'app sul dispositivo.

In modo simile a come generi APK per app bundle senza dipendenze dell'SDK, bundletool extract-apks e bundletool install-apks restituiscono un insieme filtrato di APK della migliore variante per il dispositivo connesso o per la configurazione del dispositivo fornita.

Per i casi d'uso avanzato in cui ti interessa solo generare suddivisioni dell'APK da un archivio dell'SDK per una specifica app per dispositivi meno recenti, utilizza il comando bundletool build-sdk-apks-for-app come segue:

bundletool build-sdk-apks-for-app --app-properties=app-properties.json \
    --sdk-archive=sdk.asar --output=sdk.apks

Il file app-properties deve contenere i campi descritti nel file runtime_enabled_sdk_config.proto. Ecco l'aspetto del file app-properties:

{
  "package_name": "com.my.app",
  "version_code": 1234,
  "min_sdk_version": 21,
  "resources_package_id": 0x7e
}

Il comando bundletool build-sdk-apks-for-app genera il sottoinsieme di APK dell'app che corrisponde ai contenuti dell'SDK sotto il nome del pacchetto dell'app. Puoi combinare questi APK con altri APK contenenti i contenuti dell'app. Ad esempio, se li crei separatamente e in modo incrementale e li installi insieme su un dispositivo che non supporta il runtime dell'SDK.

Crea e testa un bundle SDK (sperimentale)

Puoi utilizzare bundletool per creare un ASB e testare la generazione dei file necessari per l'installazione e la distribuzione.

Crea un bundle SDK

Puoi creare il tuo ASB dalla riga di comando e firmarlo utilizzando jarsigner.

Per creare un bundle SDK:

Genera il manifest e le risorse del bundle SDK in formato proto seguendo gli stessi passaggi previsti per un app bundle.
Pacchettizza le risorse e il codice compilato dell'SDK in un file ZIP di base, come faresti con un modulo dell'app.
Genera un file SdkModulesConfig.pb.json e un file SdkBundleConfig.pb.json, corrispondenti al formato descritto nella specifica bundle SDK Android.
Crea il tuo ASB utilizzando il comando bundletool build-sdk-bundle, come segue:

bundletool build-sdk-bundle --sdk-bundle-config=SdkBundleConfig.pb.json \
    --sdk-modules-config=SdkModulesConfig.pb.json \
    --modules=base.zip --output=sdk.asb

La tabella seguente descrive in maggiore dettaglio i vari flag e le opzioni che puoi impostare quando utilizzi il comando bundletool build-sdk-bundle.

Tabella 3. Opzioni per il comando bundletool build-sdk-bundle

Segnala	Descrizione
`--modules`	(Obbligatorio) Il file del modulo da cui vuoi creare l'ASB finale.
`--output`	(Obbligatorio) Il percorso in cui vuoi creare l'ASB.
`--sdk-modules-config`	(Obbligatorio) Il percorso di un file JSON che descrive la configurazione dei moduli SDK. Per scoprire come formattare il file JSON, consulta la sezione Specifiche bundle SDK Android.
`--sdk-bundle-config`	Il percorso di un file JSON che descrive la configurazione del bundle SDK. Per scoprire come formattare il file JSON, consulta la sezione Specifiche bundle SDK Android.
`--metadata-file`	Il file in cui includere i metadati per l'ASB. Il formato del valore del flag è `<bundle-path>:<physical-file>`, dove `<bundle-path>` indica la posizione del file all'interno della directory dei metadati del bundle SDK e `<physical-file>` è un file esistente che contiene i dati non elaborati da archiviare. Il flag può essere ripetuto.
`--overwrite`	Se impostata, questa opzione sovrascrive qualsiasi output esistente.

Generare APK da un bundle SDK

Dopo aver creato l'ASB, puoi testare un bundle SDK localmente generando i relativi APK utilizzando il comando bundletool build-sdk-apks, come mostrato nel seguente codice:

bundletool build-sdk-apks --sdk-bundle=sdk.asb --output=sdk.apks

Quando bundletool genera APK dal tuo bundle SDK, lo strumento include gli APK in un contenitore chiamato archivio del set di APK, che utilizza l'estensione del file .apks. bundletool genera un singolo APK autonomo dal bundle SDK che ha come target tutte le configurazioni dispositivo.

Se vuoi eseguire il deployment dell'ASB su un dispositivo, devi includere anche le informazioni di firma dell'app, come mostrato nel seguente comando:

bundletool build-sdk-apks --sdk-bundle=sdk.asb --output=sdk.apks \
    --ks=keystore.jks \
    --ks-pass=file:/keystore.pwd \
    --ks-key-alias=KeyAlias \
    --key-pass=file:/key.pwd

La tabella seguente descrive in maggiore dettaglio i vari flag e le opzioni che puoi impostare quando utilizzi il comando bundletool build-sdk-apks.

Tabella 4. Opzioni per il comando bundletool build-sdk-apks

Segnala	Descrizione
`--sdk-bundle`	(Obbligatorio) Il percorso del bundle SDK. Deve avere l'estensione `.asb`.
`--output`	(Obbligatorio) Per impostazione predefinita, il percorso in cui vuoi creare l'archivio del set di APK. In alternativa, se utilizzi `--output-format=DIRECTORY`, questo è il percorso della directory in cui vuoi che vengano archiviati gli APK generati.
`--ks`	Il percorso dell'archivio chiavi che vuoi utilizzare per firmare gli APK generati.
`--ks-key-alias`	L'alias della chiave da utilizzare nell'archivio chiavi per firmare gli APK generati.
`--key-pass`	La password della chiave nell'archivio chiavi da usare per firmare gli APK generati. Se trasmetti la password in chiaro, devi far precedere il valore da `pass:`. Ad esempio, `pass:qwerty`. Se la password è la prima riga di un file, devi far precedere il valore da `file:`. Ad esempio, `file:/tmp/myPassword.txt`. Se questo flag non è impostato, viene provato a utilizzare la password dell'archivio chiavi. Se il problema persiste, il terminale a riga di comando ti chiede di inserire una password.
`--ks-pass`	La password dell'archivio chiavi da utilizzare per firmare gli APK generati. Se trasmetti la password in chiaro, devi far precedere il valore da `pass:`. Ad esempio, `pass:qwerty`. Se la password è la prima riga di un file, devi far precedere il valore da `file:`. Ad esempio `file:/tmp/myPassword.txt`. Se questo flag non è impostato, il terminale a riga di comando richiede una password.
`--aapt2`	Il percorso del programma binario AAPT2 da utilizzare.
`--output-format`	Il formato di output per gli APK generati. Per impostazione predefinita, questa opzione è impostata su `APK_SET`, che inserisce gli APK nell'archivio del set di APK creato. Se viene impostato su `DIRECTORY`, gli APK vengono inseriti nella directory specificata da `--output`.
`--verbose`	Se impostata, questa opzione stampa informazioni aggiuntive sull'esecuzione del comando nell'output standard.
`--version-code`	Il codice versione dell'SDK. Questo è il codice di versione utilizzato dalla piattaforma Android per installare l'APK, non la versione dell'SDK. Questa opzione può essere impostata su un valore arbitrario. Se non viene configurato, il valore predefinito è 0.
`--overwrite`	Se impostata, questa opzione sovrascrive qualsiasi output esistente.

Esegui il deployment, estrai e misura le dimensioni degli APK dell'SDK

Puoi seguire gli stessi passaggi utilizzati per le app per implementare gli APK su un dispositivo connesso, estrarre gli APK specifici del dispositivo da un set di APK esistente e misurare le dimensioni di download stimate degli APK in un set di APK.

Generare un archivio SDK da un bundle SDK

Dopo il caricamento nel tuo canale di distribuzione, ad esempio Google Play, l'ASB viene trasformato in un Android SDK Archive (.asar) per la distribuzione agli sviluppatori di app tramite Maven. Per ulteriori dettagli sul formato, consulta la sezione sulla specifica del formato dell'archivio SDK.

Dopo aver creato l'ASB, puoi testare la generazione di un archivio SDK Android in locale utilizzando il comando bundletool build-sdk-asar, come mostrato nel seguente codice:

bundletool build-sdk-asar --sdk-bundle=sdk.asb --output=sdk.asar \
    --apk-signing-key-certificate=keycert.txt

La tabella seguente descrive in maggiore dettaglio i vari flag e le opzioni che puoi impostare quando utilizzi il comando bundletool build-sdk-asar.

Tabella 5. Opzioni per il comando bundletool build-sdk-asar

Segnala	Descrizione
`--apk-signing-key-certificate`	(Obbligatorio) Il percorso del certificato di firma dell'APK dell'SDK. Questo è il certificato corrispondente alla chiave che hai utilizzato per firmare gli APK nel comando `build-sdk-apks`.
`--output`	(Obbligatorio) Il percorso in cui vuoi creare il file `.asar`.
`--sdk-bundle`	(Obbligatorio) Il percorso del bundle SDK. Deve avere l'estensione `.asb`.
`--overwrite`	Se impostata, questa opzione sovrascrive qualsiasi output esistente.

Formati SDK abilitati per il runtime (sperimentale)

Gli SDK abilitati per il runtime introducono due formati file Android:

Il bundle SDK Android (.asb), utilizzato per pubblicare l'SDK abilitato per runtime negli store.
Android SDK Archive (.asar), utilizzato per distribuire l'SDK abilitato per il runtime su Maven.

Formato del bundle SDK Android

Un bundle SDK è un formato di pubblicazione per gli SDK abilitati per il runtime. Contiene tutto il codice e le risorse dell'SDK, incluso il codice di qualsiasi libreria da cui dipende l'SDK. Non include il codice e le risorse di altri SDK abilitati per il runtime da cui dipende l'SDK.

Un Android SDK Bundle (ASB) è un file ZIP firmato con l'estensione .asb. Le risorse e il codice dell'SDK sono organizzati in modo simile a ciò che puoi trovare in un APK. Un ASB contiene anche diversi file di configurazione che consentono di generare gli APK installabili.

**Figura 1.** I contenuti di un bundle SDK Android.

Il seguente elenco descrive alcuni dei file ASB in modo più dettagliato:

SdkBundleConfig.pb: un file di configurazione in formato proto contenente l'elenco di SDK abilitati per il runtime da cui dipende il tuo SDK. Per la definizione completa, consulta il file sdk_bundle_config.proto.
modules.resm: un file ZIP contenente tutti i dati necessari per generare gli APK dall'SDK.
SdkModulesConfig.pb: un file di configurazione in formato proto. Questo file contiene il nome dell'SDK, la versione e il nome della classe del punto di ingresso dell'SDK per il framework (SandboxedSdkProvider). Per la definizione completa, consulta il file sdk_modules_config.proto.
base/: il singolo modulo contenente il codice e le risorse dell'SDK.
- manifest/: il manifest dell'SDK in formato proto.
- dex/: il codice compilato in formato DEX. È possibile fornire più file DEX.
- res/, lib/, assets/: queste directory sono identiche a quelle di un APK tipico. I percorsi in queste directory vengono conservati durante la generazione degli APK dell'SDK.
- root/: questa directory archivia i file che vengono successivamente riposizionati nella directory principale degli APK dell'SDK. Ad esempio, potrebbe includere risorse basate su Java caricate dall'SDK con il metodo Class.getResource(). Vengono conservati anche i percorsi all'interno di questa directory.
BUNDLE-METADATA: questa directory include file di metadati che contengono informazioni utili per strumenti o store. Questi file di metadati potrebbero includere mappature ProGuard e l'elenco completo dei file DEX dell'SDK. I file in questa directory non sono pacchettizzati negli APK dell'SDK.

Formato Android SDK Archive

Android SDK Archive è il formato di distribuzione di un SDK abilitato per il runtime su Maven. Si tratta di un file ZIP con l'estensione .asar. Il file contiene tutte le informazioni necessarie agli strumenti di creazione delle app per generare un Android App Bundle che dipende dall'SDK abilitato per il runtime.

**Figura 2.** I contenuti di un bundle Android SDK Archive.

Il seguente elenco descrive in modo più dettagliato alcuni dei file Android SDK Archive:

SdkMetadata.pb: un file di configurazione in formato proto contenente il nome dell'SDK, la versione e il digest del certificato per la chiave utilizzata per firmare gli APK generati per questo SDK. Per la definizione completa, consulta il file sdk_metadata.proto.
modules.resm: un file ZIP contenente tutti i dati necessari per generare gli APK dall'SDK. È uguale al file .resm nel Bundle SDK Android.
AndroidManifest.xml: il file manifest dell'SDK in formato testuale XML.

Risorse aggiuntive

Per scoprire di più sull'utilizzo di bundletool, guarda App Bundle: Test bundle con bundletool e Play Console.