Questa pagina è stata tradotta dall'API Cloud Translation.

strumento strumenti

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: `bundletool` include solo i moduli delle funzionalità che specificano `<dist:fusing dist:include="true"/>` in il proprio file manifest in un APK universale. Per saperne di più, leggi le informazioni del modulo delle funzionalità. 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 `--local-testing` flag, vedi 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ò 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 un SdkBundleConfig.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 `pass:`. Ad esempio, `pass:qwerty`. Se la password è la prima riga di un file, devi aggiungere un prefisso al valore con `file:`. Ad esempio: `file:/tmp/myPassword.txt`. 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 `pass:`. Ad esempio, `pass:qwerty`. Se password è la prima riga di un file, devi anteporre al valore il prefisso `file:`. Ad esempio: `file:/tmp/myPassword.txt`. 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.

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

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 la sdk_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, vedi sdk_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 utilizzando 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 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.

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

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, vedi sdk_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.