bundletool
è lo strumento sottostante di Android Studio, Android Gradle.
e Google Play usano per creare un Android App Bundle. bundletool
può convertire un app bundle nei vari APK di cui viene eseguito il deployment sui dispositivi.
Gli Android SDK Bundle (ASB) e i relativi APK sono creati con bundletool
. È
è disponibile anche come strumento a riga di comando, per creare app bundle
L'SDK si raggruppa e ricrea la build lato server di Google Play del
gli APK o il tuo
APK degli SDK abilitati per il runtime.
Scarica bundletool
Se non l'hai già fatto, scarica bundletool
dal
Repository GitHub.
Creare e testare un app bundle
Puoi utilizzare Android Studio o lo strumento a riga di comando bundletool
per creare
Android App Bundle, quindi testa la generazione degli APK da questo app bundle.
Creare un app bundle
Utilizzare Android Studio e il plug-in Android Gradle per
Creare e firmare un Android App Bundle.
Tuttavia, se non è possibile usare l'IDE, ad esempio perché stai usando
un server di build continuo, puoi anche
creare l'app bundle dalla riga di comando
e firmarlo con
jarsigner
Per ulteriori informazioni sulla creazione di app bundle con bundletool
,
vedi
Creare un app bundle utilizzando bundletool.
Generare un insieme di APK dall'app bundle
Dopo aver creato l'Android App Bundle, verifica in che modo Google Play e il comportamento degli APK quando vengono implementati su un dispositivo.
Puoi testare l'app bundle in due modi:
- Utilizza lo strumento a riga di comando
bundletool
in locale. - Carica il bundle su Play Console tramite Google Play usando un canale di test.
Questa sezione spiega come usare bundletool
per testare l'app bundle localmente.
Quando bundletool
genera APK dall'app bundle, include gli elementi generati
APK in un contenitore denominato APK set Archive, che utilizza il file .apks
. Per generare un APK impostato per tutte le configurazioni del dispositivo, la tua app
supportati dall'app bundle, utilizza il comando bundletool build-apks
,
mostrato:
bundletool build-apks --bundle=/MyApp/my_app.aab --output=/MyApp/my_app.apks
Se vuoi implementare gli APK su un dispositivo, devi includere anche il file
le informazioni sulla firma, come mostrato nel comando seguente. Se non specifichi
informazioni sulla firma, bundletool
tenta di firmare i tuoi APK con una chiave di debug
per te.
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
La tabella seguente descrive i vari flag e le opzioni che puoi impostare quando
usando il comando bundletool build-apks
in modo più dettagliato:
Tabella 1. Opzioni per il parametro
Comando bundletool build-apks
Segnala | Descrizione |
---|---|
--bundle=path |
(Obbligatorio) Specifica il percorso dell'app bundle creato con Android Studio. Per saperne di più, leggi Crea il tuo progetto. |
--output=path |
(Obbligatorio) Specifica il nome dell'output
.apks , che contiene tutti gli elementi dell'APK per il tuo
dell'app. Per testare gli artefatti di questo file su un dispositivo, segui i passaggi riportati in
la sezione su come implementare gli APK
a un dispositivo connesso.
|
--overwrite |
Sovrascrive qualsiasi file di output esistente con
il percorso specificato utilizzando l'opzione --output . Se
non includere questo flag e il file di output esiste già, viene restituito
di generazione del prompt.
|
--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 i tuoi APK con una firma di debug
chiave.
|
--ks-pass=pass:password o --ks-pass=file:/path/to/file |
Specifica la password dell'archivio chiavi. Se
specificare una password in testo normale, qualificarla con pass: .
Se passi il percorso di un file che contiene la password,
con file: . Se specifichi un archivio chiavi
il flag --ks senza specificare --ks-pass ,
bundletool richiede l'inserimento di una password dalla riga di comando.
|
--ks-key-alias=alias |
Specifica l'alias della chiave di firma che vuoi per gli utilizzi odierni. |
--key-pass=pass:password o --key-pass=file:/path/to/file |
Specifica la password per la chiave di firma. Se
specificare una password in testo normale, qualificarla con pass: .
Se passi il percorso di un file che contiene la password,
con file: . Se questa password è identica alla password per l'archivio chiavi stesso, puoi omettere questo flag. |
--connected-device |
Indica a bundletool di creare APK che hanno come target
configurazione di un dispositivo connesso. Se non includi questo flag,
bundletool genera APK per tutte le configurazioni dei dispositivi
supportati dall'app.
|
--device-id=serial-number |
Se hai connesso più di un dispositivo, usa questo flag per specificare ID seriale del dispositivo su cui vuoi eseguire il deployment dell'app. |
--device-spec=spec_json |
Fornisce un percorso a
Il file .json che specifica la configurazione del dispositivo che vuoi
scegliere come target. Per saperne di più, vai alla sezione su come
Generare e utilizzare JSON delle specifiche del dispositivo
file.
|
--mode=universal |
Imposta la modalità su universal . Utilizza questa opzione se vuoi
bundletool per creare un singolo APK che includa tutti i seguenti elementi
il codice e le risorse della tua app, in modo che l'APK sia compatibile con tutti
configurazioni dei dispositivi supportate dalla tua app.
Nota: Tieni presente che questi APK sono più grandi di quelli ottimizzati per una particolare configurazione dispositivo. Tuttavia, più facile da condividere con i tester interni che, ad esempio, vuoi testare l'app su più configurazioni di dispositivi. |
--local-testing
|
Attiva l'app bundle per i test locali.
I test locali consentono cicli di test rapidi e iterativi senza la necessità
per caricarle sui server di Google Play.
Per un esempio di come testare l'installazione di un modulo utilizzando
|
Eseguire il deployment di APK su un dispositivo connesso
Dopo aver generato un insieme di APK, bundletool
può implementare gli APK
combinazione di APK del set su un dispositivo connesso.
Ad esempio, se hai connesso un dispositivo con Android 5.0 (livello API 21).
o successiva, bundletool
invia l'APK di base, gli APK dei moduli delle funzionalità e
di configurazione degli APK necessari per eseguire l'app sul dispositivo in questione. In alternativa, se
sul dispositivo connesso sia installato Android 4.4 (livello API 20) o una versione precedente,
bundletool
cerca un APK multiplo compatibile da implementare sul tuo dispositivo.
Per eseguire il deployment della tua app da un set di APK, usa il comando install-apks
e specifica
il percorso dell'APK impostato utilizzando
--apks=/path/to/apks
, come
come mostrato nel seguente comando. Se hai collegato più dispositivi,
specificare un dispositivo di destinazione aggiungendo
--device-id=serial-id
flag.
bundletool install-apks --apks=/MyApp/my_app.apks
Generare un insieme di APK specifico per dispositivo
Se non vuoi creare un insieme di APK per tutte le configurazioni dei dispositivi, la tua app
puoi creare APK che hanno come target solo la configurazione di un
usando l'opzione --connected-device
, come mostrato nel seguente comando.
Se hai più dispositivi connessi, specifica un dispositivo di destinazione includendo
--device-id=serial-id
flag.
bundletool build-apks --connected-device --bundle=/MyApp/my_app.aab --output=/MyApp/my_app.apks
Genera e utilizza i file JSON delle specifiche del dispositivo
bundletool
può generare un set di APK che ha come target un dispositivo
configurazione specificata da un file JSON. Per generare prima un file JSON per
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. Tu
può quindi passare il file a bundletool
per generare un insieme di APK che
scegli come target solo la configurazione descritta nel file JSON, come segue:
bundletool build-apks --device-spec=/MyApp/pixel2.json --bundle=/MyApp/my_app.aab --output=/MyApp/my_app.apks
Crea manualmente un file JSON per le specifiche del dispositivo
Se non hai accesso al dispositivo per cui vuoi creare un APK impostato, ad esempio se vuoi provare la tua app con un dispositivo diverso da quello che hai. puoi creare manualmente un file JSON utilizzando il seguente formato:
{
"supportedAbis": ["arm64-v8a", "armeabi-v7a"],
"supportedLocales": ["en", "fr"],
"screenDensity": 640,
"sdkVersion": 27
}
Puoi quindi passare questo JSON al comando bundle extract-apks
, come descritto
nella sezione precedente.
Estrarre APK specifici per il dispositivo da un set di APK esistente
Se hai già un set di APK da cui vuoi estrarre un sottoinsieme di APK
che hanno come target una specifica configurazione del dispositivo, puoi utilizzare extract-apks
e specificare un JSON di specifica del dispositivo, come segue:
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 APK impostato come dovrebbero
essere fornito compresso tramite cavo, usa il comando get-size total
:
bundletool get-size total --apks=/MyApp/my_app.apks
Puoi modificare il comportamento del comando get-size total
utilizzando la proprietà
i seguenti flag:
Tabella 2. Opzioni per il parametro
Comando get-size total
Segnala | Descrizione |
---|---|
--apks=path |
(Obbligatorio) Specifica il percorso del file di set di APK esistente le cui dimensioni di download vengono misurate. |
--device-spec=path |
Specifica il percorso del file delle specifiche del dispositivo (da
get-device-spec o creata manualmente) da utilizzare per la corrispondenza.
Puoi specificare un percorso parziale per la valutazione di 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 misurare
tutte le dimensioni, specifica ALL .
|
--instant |
Misura le dimensioni di download degli APK ad attivazione istantanea anziché degli APK ad attivazione istantanea
APK installabili. Per impostazione predefinita, bundletool misura
dimensioni di download degli APK installabili.
|
--modules=modules |
Specifica un elenco separato da virgole di moduli nell'APK impostato da considerare
nella misurazione. Il comando bundletool
include eventuali moduli dipendenti per il set specificato. Per impostazione predefinita,
misura le dimensioni di download di tutti i moduli installati durante
primo download.
|
Crea un app bundle con una dipendenza da un bundle SDK (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 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 app bundle. Per la definizione completa di questo file,
vedi il
runtime_enabled_sdk_config.proto
.
Per creare un app bundle con una dipendenza da un bundle SDK, segui i passaggi descritti nella sezione sulle
creare un app bundle utilizzando bundletool e aggiungere una
runtime_enabled_sdk_config.pb
file al file ZIP di ogni modulo dell'app
con codice compilato e risorse.
Alcuni campi importanti nel file runtime_enabled_sdk_config.pb
:
Digest del certificato:il digest SHA-256 del certificato per la chiave utilizzati per firmare gli APK dell'SDK. Corrisponde al certificato nella
SdkMetadata.pb
nel formato Archivio SDK Android.Resources Package ID (ID pacchetto risorse): l'ID pacchetto di tutte le risorse di questo SDK vengono rimappati durante la generazione degli APK per l'incorporamento dell'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 relativa a un bundle SDK (sperimentale)
Per generare APK dall'app bundle, segui i passaggi descritti nella sezione relativa alle
generare un set di APK dall'app bundle
o la sezione dedicata
generare un insieme di APK specifico per dispositivo
e fornisci il comando bundletool build-apks
con gli SDK
dipende dall'app. Questi SDK possono essere forniti in formato SDK bundle o SDK
Formato archivio.
Puoi fornire gli SDK come bundle di SDK aggiungendo il flag --sdk-bundles
, come
che segue:
bundletool build-apks --bundle=app.aab --sdk-bundles=sdk1.asb,sdk2.asb \ --output=app.apks
Puoi fornire gli SDK come archivi degli 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 bundle SDK per i dispositivi che non supportano la libreria di SDK
I dispositivi precedenti ad Android 13 non supportano l'installazione o l'esecuzione di librerie SDK
nel runtime dell'SDK. Bundletool nasconde la complessità della compatibilità con le versioni precedenti
genera più varianti dell'APK impostato dallo stesso app bundle quando
esegui bundletool build-apks
con l'opzione --sdk-bundles
o --sdk-archives
.
Le diverse varianti scelgono come target dispositivi con funzionalità diverse:
- Esiste una variante per i dispositivi più recenti, in cui l'SDK viene installato come separato dell'app e gli APK dell'app non includono contenuti SDK.
- Esistono una o più varianti per i dispositivi meno recenti, in cui vengono aggiunti gli APK dell'SDK all'APK dell'app impostato come suddivisioni aggiuntive dell'APK. Gli APK dell'SDK appartengono all'app pacchetto. In questo caso, il runtime dell'SDK viene emulato nel runtime dell'app nella dispositivo.
Analogamente a come generi APK per app bundle senza dipendenze SDK,
bundletool extract-apks
e bundletool install-apks
restituiscono un insieme filtrato di
APK della variante migliore per il dispositivo connesso o per il dispositivo fornito
.
Per casi d'uso avanzati in cui ti interessa solo generare suddivisioni APK
da un archivio SDK per una specifica app per dispositivi meno recenti, usa
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 in
runtime_enabled_sdk_config.proto
. Ecco cos'è app-properties
questo file ha il seguente aspetto:
{
"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 app
APK che corrispondono ai contenuti dell'SDK nel nome del pacchetto dell'app. Puoi
combinare questi APK con altri APK contenenti i contenuti dell'app. Ad esempio, se
puoi crearle separatamente e in modo incrementale e installarle insieme su un dispositivo
che non supporta il runtime dell'SDK.
Creazione e test di un bundle SDK (sperimentale)
Puoi utilizzare bundletool
per creare un ASB e testare la generazione del
e i file necessari per l'installazione e la distribuzione.
Creare un bundle SDK
Puoi creare il tuo ASB dalla riga di comando e firmarlo utilizzando jarsigner.
Per creare un bundle SDK:
Generare il manifest e le risorse del bundle SDK in formato proto seguendo la stessa procedura prevista per un app bundle.
Pacchettizza il codice compilato dell'SDK e le risorse in un file ZIP di base come per un modulo dell'app.
Genera un file
SdkModulesConfig.pb.json
e unSdkBundleConfig.pb.json
corrispondente al formato descritto in Specifica del bundle SDK Android.Crea il tuo ASB utilizzando il comando
bundletool build-sdk-bundle
, come che 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 i vari flag e le opzioni che puoi impostare quando
usando il comando bundletool build-sdk-bundle
in modo più dettagliato.
Tabella 3. Opzioni per il parametro
Comando bundletool build-sdk-bundle
Segnala | Descrizione |
---|---|
--modules |
(Obbligatorio) Il file del modulo che vuoi creare il modello finale ASB da. |
--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 il Sezione Specifiche del 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 il Sezione Specifiche del 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
La directory dei metadati del bundle SDK e <physical-file> sono
un file esistente contenente i dati non elaborati da archiviare. Il flag può essere
ripetuto.
|
--overwrite |
Se impostata, questa opzione sovrascrive qualsiasi output esistente precedente. |
Generare APK da un bundle SDK
Dopo aver creato l'ASB, puoi testare un bundle SDK a livello locale
generando gli APK utilizzando il comando bundletool build-sdk-apks
, come mostrato
il seguente codice:
bundletool build-sdk-apks --sdk-bundle=sdk.asb --output=sdk.apks
Quando bundletool
genera APK dal tuo bundle SDK, lo strumento include il parametro
APK in un contenitore denominato APK set Archive, che utilizza il file .apks
. bundletool
genera un singolo APK autonomo dal bundle di SDK
che abbia come target tutte le configurazioni dei dispositivi.
Se vuoi eseguire il deployment dell'ASB su un dispositivo, devi includere anche il codice le informazioni sulla firma, come mostrato nel comando seguente:
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 i vari flag e le opzioni che puoi impostare quando
usando il comando bundletool build-sdk-apks
in modo più dettagliato.
Tabella 4. Opzioni per il parametro
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 archiviare il set di APK
da creare. In alternativa, se utilizzi
--output-format=DIRECTORY ,
si tratta del percorso della directory in cui vuoi archiviare gli APK generati.
|
--ks |
Il percorso dell'archivio chiavi da utilizzare per firmare la APK generati. |
--ks-key-alias |
L'alias della chiave da utilizzare nell'archivio chiavi per firmare la APK generati. |
--key-pass |
La password della chiave nell'archivio chiavi da utilizzare per firmare la APK. Se passi la password in testo non crittografato, il valore deve essere preceduto da un prefisso
con Se questo flag non è impostato, la password di un utente. Se il problema persiste, il terminale a riga di comando richiede una password. |
--ks-pass |
La password dell'archivio chiavi da utilizzare per firmare gli APK generati. Se passi la password in testo non crittografato, il valore deve essere preceduto da un prefisso
con Se questo flag non è impostato, a riga di comando richiede l'inserimento di una password. |
--aapt2 |
Il percorso del file 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, che
è stato creato. Se impostato su DIRECTORY , gli APK vengono generati nella
specificata da --output . |
--verbose |
Se impostata, questa opzione stampa informazioni aggiuntive sull'esecuzione del comando nel come output standard. |
--version-code |
Il codice di versione dell'SDK. Si tratta del 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 precedente. |
Esegui il deployment, estrai e misura le dimensioni degli APK dell'SDK
Puoi seguire gli stessi passaggi utilizzati per il deployment delle app APK su un dispositivo connesso, estrazione di uno specifico dispositivo APK di un set di APK esistente e misurano i valori stimati le dimensioni di download degli APK in un set di APK.
Generare un archivio SDK da un bundle SDK
Dopo aver caricato l'ASB sul tuo canale di distribuzione, per
esempio su Google Play, l'ASB viene trasformato in un SDK per Android
Archivio (.asar
) per la distribuzione agli sviluppatori di app tramite Maven. Per ulteriori informazioni
dettagli sul formato, consulta la sezione
Specifica del formato di SDK Archive.
Dopo aver creato l'ASB, puoi testare la generazione di un
Archiviare l'SDK Android in locale utilizzando il comando bundletool build-sdk-asar
, come
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 i vari flag e le opzioni che puoi impostare quando
usando il comando bundletool build-sdk-asar
in modo più dettagliato.
Tabella 5. Opzioni per il parametro
Comando bundletool build-sdk-asar
Segnala | Descrizione |
---|---|
--apk-signing-key-certificate |
(Obbligatorio) Il percorso del certificato di firma dell'APK dell'SDK. Questo è il
corrispondente alla chiave che hai utilizzato per firmare gli APK nel
Comando build-sdk-apks .
|
--output |
(Obbligatorio) Il percorso in cui vuoi inserire il file .asar
è stato creato.
|
--sdk-bundle |
(Obbligatorio) Il percorso del bundle SDK. Deve avere l'estensione
.asb .
|
--overwrite |
Se impostata, questa opzione sovrascrive qualsiasi output esistente precedente. |
Formati SDK abilitati per il runtime (sperimentali)
Gli SDK abilitati per il runtime introducono due formati file Android:
- Il pacchetto SDK Android (
.asb
), utilizzato per pubblicare il l'SDK abilitato per il runtime negli store. - L'archivio SDK Android (
.asar
), utilizzato per distribuire 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 tutte il codice e le risorse SDK, incluso il codice di eventuali librerie dipende. Non include il codice e le risorse di altre risorse abilitate per il runtime SDK da cui dipende l'SDK.
Un bundle SDK Android (ASB) è un file ZIP firmato con l'estensione
.asb
. Le risorse e il codice SDK sono organizzati in modo simile
in un APK. Un ASB contiene inoltre diversi file di configurazione utili
generare gli APK installabili.
![](https://developer.android.com/static/studio/images/command-line/asb-format.png?authuser=9&hl=it)
Il seguente elenco descrive alcuni dei file ASB in dettaglio:
SdkBundleConfig.pb
: un file di configurazione in formato proto, contenente il parametro elenco di SDK abilitati per il runtime da cui dipende il tuo SDK. Per l'intera definizione, consulta lasdk_bundle_config.proto
.modules.resm
: un file ZIP contenente tutti i dati necessari per generare APK dell'SDK.SdkModulesConfig.pb
: un file di configurazione in formato proto. Questo file contiene il nome, la versione e il nome della classe dell'SDK per il il framework (SandboxedSdkProvider
). Per la definizione completa, vedisdk_modules_config.proto
.base/
: il singolo modulo contenente il codice e le risorse 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 in un un APK tipico. I percorsi in queste directory vengono conservati durante la generazione del APK dell'SDK.root/
: questa directory archivia i file che vengono successivamente spostati nella directory principale degli APK dell'SDK. Ad esempio, potrebbe includere risorse basate su Java viene caricato l'SDK utilizzandoClass.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 Includi le 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
Un archivio SDK Android è il formato di distribuzione di un SDK abilitato per il runtime su
Maven. È un file ZIP con estensione .asar
. Il file
contiene tutte le informazioni necessarie agli strumenti di creazione dell'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=9&hl=it)
Nell'elenco che segue vengono descritti alcuni dei file Android SDK Archive in altri contenuti dettaglio:
SdkMetadata.pb
: un file di configurazione in formato proto contenente il parametro Nome, versione e digest del certificato dell'SDK per la chiave utilizzata per firmare APK generati per questo SDK. Per la definizione completa, vedisdk_metadata.proto
.modules.resm
: un file ZIP contenente tutti i dati necessari per generare APK dell'SDK. È uguale al file.resm
nella Pacchetto SDK Android.AndroidManifest.xml
: il file manifest dell'SDK in formato XML di testo.
Risorse aggiuntive
Per scoprire di più sull'utilizzo di bundletool
, guarda
App bundle: test di bundle con bundletool e con Play Console.