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: 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 |
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 fileSdkBundleConfig.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 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 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.
![](https://developer.android.com/static/studio/images/command-line/asb-format.png?authuser=8&hl=it)
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 filesdk_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 filesdk_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 metodoClass.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.
![](https://developer.android.com/static/studio/images/command-line/asar-format.png?authuser=8&hl=it)
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 filesdk_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.