Comando ADT package

Il comando -package deve essere eseguito dalla directory dell'applicazione principale. Questo comando prevede le seguenti sintassi:

Creare un pacchetto AIR dai file componenti dell'applicazione:

adt -package 
    AIR_SIGNING_OPTIONS 
    -target packageType 
    -sampler 
    ‑hideAneLibSymbols 
    NATIVE_SIGNING_OPTIONS 
    output 
    app_descriptor 
    FILE_OPTIONS 

Creare un pacchetto nativo dai file componenti dell'applicazione:

adt -package 
    AIR_SIGNING_OPTIONS 
    -target packageType 
    DEBUGGER_CONNECTION_OPTIONS 
    -airDownloadURL URL 
    NATIVE_SIGNING_OPTIONS 
    output 
    app_descriptor 
    -platformsdk path 
    FILE_OPTIONS 

Creare un pacchetto nativo che includa un'estensione nativa dai file applicazione del componente:

adt -package 
    AIR_SIGNING_OPTIONS 
    -migrate MIGRATION_SIGNING_OPTIONS 
    -target packageType 
    DEBUGGER_CONNECTION_OPTIONS 
    -airDownloadURL URL 
    NATIVE_SIGNING_OPTIONS 
    output 
    app_descriptor 
    -platformsdk path 
    FILE_OPTIONS 

Creare un pacchetto nativo da un file AIR o AIRI:

adt -package 
    -target packageType 
    NATIVE_SIGNING_OPTIONS 
    output 
    input_package

Creare un pacchetto di estensioni native dai file componenti l'estensione nativa:

adt -package 
    AIR_SIGNING_OPTIONS     
    -target ane 
    output 
    ANE_OPTIONS
Nota: non è necessario firmare un file ANE; quindi, i parametri AIR_SIGNING_OPTIONS in questo esempio sono opzionali.

AIR_SIGNING_OPTIONS Le opzioni di firma AIR identificano il certificato da utilizzare per firmare un file di installazione AIR. Le opzioni di firma sono descritte in maniera completa in Opzioni di firma codice ADT.

-migrate: questo flag specifica che l'applicazione è firmata con un certificato di migrazione oltre al certificato specificato nei parametri AIR_SIGNING_OPTIONS. Questo flag è valido solo se state creando un'applicazione desktop come programma di installazione nativo e l'applicazione utilizza un'estensione nativa. In altri casi viene rilevato un errore. Le opzioni di firma per il certificato di migrazione sono specificate come parametri MIGRATION_SIGNING_OPTIONS. Tali opzioni di firma sono descritte in maniera completa in Opzioni di firma codice ADT. Tramite il flag -migrate è possibile creare un aggiornamento per un'applicazione di un programma di installazione nativo desktop che utilizza un'estensione nativa e modificare il certificato di firma del codice per l'applicazione, come nel caso della scadenza del certificato originale. Per maggiori informazioni, consultate Firma di una versione aggiornata di un'applicazione AIR.

Il flag -migrate del comando -package è disponibile in AIR 3.6 e versioni successive.

-target Il tipo di pacchetto da creare. I tipi di pacchetto supportati sono:
  • air - un pacchetto AIR. "air" è il valore predefinito e non occorre specificare il flag -target quando si creano file AIR o AIRI.

  • airn - un pacchetto di applicazione nativo per dispositivi che usano il profilo tv esteso.

  • ane - un pacchetto di estensioni native AIR

  • Target del pacchetto Android:

    • apk - un pacchetto Android. Un pacchetto prodotto con questo target può essere installato solo su un dispositivo Android, non su un emulatore.

    • apk-captive-runtime - un pacchetto Android che contiene sia l'applicazione che una versione autonoma del runtime AIR. Un pacchetto prodotto con questo target può essere installato solo su un dispositivo Android, non su un emulatore.

    • apk-debug - un pacchetto Android con informazioni di debug supplementari. (I file SWF nell'applicazione devono a loro volta essere compilati con il supporto per il debug.)

    • apk-emulator - un pacchetto Android da utilizzare su un emulatore senza supporto per il debug. (Utilizzate il valore target apk-debug per consentire il debug sia sugli emulatori che sui dispositivi.)

    • apk-profile - un pacchetto Android che supporta le prestazioni dell'applicazione e i profili di memoria.

  • Target del pacchetto iOS:

    • ipa-ad-hoc - un pacchetto iOS per la distribuzione ad hoc.

    • ipa-app-store - un pacchetto iOS per la distribuzione su Apple App Store.

    • ipa-debug - un pacchetto iOS con informazioni di debug supplementari. (I file SWF nell'applicazione devono a loro volta essere compilati con il supporto per il debug.)

    • ipa-test - un pacchetto iOS compilato con informazioni di debug o di ottimizzazione.

    • ipa-debug-interpreter - funzionalità equivalente a un pacchetto di debug, ma con compilazione più rapida. Tuttavia, il codice byte ActionScript viene interpretato e non tradotto in codice macchina. Di conseguenza, l'esecuzione del codice risulta più lenta in un pacchetto interprete.

    • ipa-debug-interpreter-simulator - Funzionalmente equivalente a ipa-debug-interpreter, ma compilato per iOS Simulator. Solo per Macintosh. Se usate questa opzione, dovete anche includere l'opzione -platformsdk, specificando il percorso di iOS Simulator SDK.

    • ipa-test-interpreter - funzionalità equivalente a un pacchetto di test, ma con compilazione più rapida. Tuttavia, il codice byte ActionScript viene interpretato e non tradotto in codice macchina. Di conseguenza, l'esecuzione del codice risulta più lenta in un pacchetto interprete.

    • ipa-test-interpreter-simulator - Funzionalmente equivalente a ipa-test-interpreter, ma compilato per iOS Simulator. Solo per Macintosh. Se usate questa opzione, dovete anche includere l'opzione -platformsdk, specificando il percorso di iOS Simulator SDK.

  • native - un programma di installazione desktop nativo. Il tipo di file prodotto è il formato di installazione nativo del sistema operativo nel quale il comando viene eseguito:

    • EXE - Windows

    • DMG - Mac

    • DEB - Ubuntu Linux (AIR 2.6 o versioni precedenti)

    • RPM - Fedora o OpenSuse Linux (AIR 2.6 o versioni precedenti)

    Per ulteriori informazioni, consultate Creazione del pacchetto di un file di installazione nativo desktop.

-sampler (solo per iOS, AIR 3.4 e versioni successive) Abilita il campionatore ActionScript basato sulla telemetria in applicazioni iOS. Tramite questo flag potete creare un profilo dell'applicazione con Adobe Scout. Anche se con Scout è possibile creare il profilo di qualsiasi contenuto su piattaforma Flash, abilitando una telemetria dettagliata potrete analizzare più in profondità la temporizzazione delle funzioni ActionScript, DisplayList, il rendering Stage3D e molto altro ancora. Tenete presente che l'uso di questo flag rallenta leggermente le prestazioni, pertanto non va usato per applicazioni di produzione.

-hideAneLibSymbols (solo per iOS, AIR 3.4 e versioni successive) Gli sviluppatori di applicazioni possono utilizzare più estensioni native da più origini e, se i file ANE condividono un nome simbolo comune, ADT genera un errore di "simbolo duplicato nel file dell'oggetto". In alcuni casi, questo errore si può addirittura manifestare con un blocco del sistema in fase di runtime. Potete utilizzare l'opzione hideAneLibSymbols per specificare se rendere visibili o meno i simboli della libreria ANE solo alle origini della libreria stessa (sì) o a livello globale (no):

  • - Consente di nascondere i simboli ANE, risolvendo eventuali problemi di conflittualità dei simboli.

  • no - (Predefinito) Non nasconde i simboli ANE. Questo è il comportamento precedente a AIR 3.4.

-embedBitcode (solo iOS, AIR 25 e successive) Gli sviluppatori di applicazioni possono utilizzare l'opzione embedBitcode per specificare se includere bitcode nelle loro applicazioni iOS specificando sì o no. Il valore predefinito di questa opzione se non specificato è no.

DEBUGGER_CONNECTION_OPTIONS Le opzioni di connessione del debugger specificano quando un pacchetto di debug deve tentare di connettersi a un debugger remoto in esecuzione su un altro computer oppure intercettare una connessione da un debugger remoto. Questo set di opzioni è supportato solo per i pacchetti di debug per dispositivi mobili (con target apk-debug e ipa-debug). Queste opzioni sono descritte in Opzioni per la connessione del debugger.

-airDownloadURL Specifica un URL alternativo per scaricare e installare il runtime AIR su dispositivi Android. Se non è specificato, un'applicazione AIR reindirizza l'utente al runtime AIR su Android Market se il runtime non è già installato.

Se l'applicazione è distribuita tramite un canale commerciale diverso da Android Market (che è amministrato da Google), potreste dover specificare l'URL per scaricare il runtime AIR da tale canale. Alcuni spazi commerciali alternativi non ammettono le applicazioni che devono essere scaricate da URL esterni. Questa opzione è supportata solo per i pacchetti Android.

NATIVE_SIGNING_OPTIONS Le opzioni di firma native identificano il certificato da utilizzare per firmare un file di pacchetto nativo. Queste opzioni di firma consentono di applicare una firma utilizzata dal sistema operativo nativo, non dal runtime AIR. Per il resto le opzioni sono identiche a AIR_SIGNING_OPTIONS e descritte in maniera completa in Opzioni di firma codice ADT.

Le firme native sono supportate in Windows e Android. In Windows è necessario specificare sia le opzioni di firma AIR che le opzioni di firma native. In Android è possibile specificare solo le opzioni di firma native.

In molti casi potete utilizzare lo stesso certificato di firma del codice per applicare sia una firma AIR che una firma nativa. Tuttavia, questa possibilità non è disponibile in tutti i casi. Ad esempio, la politica di Google per le applicazioni inviate a Android Market prevede che tutte le app debbano essere firmate con un certificato valido almeno fino all'anno 2033. Ciò significa che un certificato emesso da un'autorità di certificazione ben nota, assolutamente raccomandato quando si applica una firma AIR, non deve invece essere utilizzato per firmare un'app Android. (Nessuna autorità di certificazione emette certificati di firma codice con un periodo di validità così lungo.)

output Il nome del file di pacchetto da creare. L'estensione del file è opzionale. Se non la specificate, viene aggiunta un'estensione appropriata per il valore -target e il sistema operativo.

app_descriptor Il percorso del file descrittore dell'applicazione. Può essere specificato come percorso assoluto o come percorso relativo alla directory corrente. Il file descrittore dell'applicazione viene rinominato come application.xml nel file AIR.

-platformsdk Il percorso del kit SDK della piattaforma per il dispositivo di destinazione:
  • Android - Il kit AIR 2.6+ SDK include i tool di Android SDK necessari per implementare i comandi ADT richiesti. Impostate questo valore solo per utilizzare una versione differente di Android SDK. Inoltre, il percorso del kit SDK della piattaforma non deve essere specificato nella riga di comando se la variabile d'ambiente AIR_ANDROID_SDK_HOME è già impostata. (Se entrambi i dati sono impostati, viene utilizzato il percorso indicato sulla riga di comando.)

  • iOS - AIR SDK viene fornito con una versione autonoma di iOS SDK. L'opzione -platformsdk consente di compilare applicazioni con un SDK esterno in modo da non essere vincolati all'uso del kit iOS SDK autonomo. Ad esempio, se avete creato un'estensione con l'ultimo SDK per iOS, potete specificare quello stesso SDK quando compilate l'applicazione. Inoltre, quando usate ADT con iOS Simulator, dovete anche includere l'opzione -platformsdk, specificando il percorso di iOS Simulator SDK.

Gli sviluppatori dell'applicazione -arch possono utilizzare questo argomento per creare APK per piattaforme x86, tramite i seguenti valori:

  • APK pacchetti armv7 - ADT per piattaforma Android armv7.

  • APK pacchetti x86 - ADT per piattaforma Android x86.

armv7 è il valore predefinito quando non è specificato alcun valore

FILE_OPTIONS Identifica i file dell'applicazione da includere nel pacchetto. Le opzioni per i file sono descritte in maniera completa in Opzioni per file e percorsi. Non specificate le opzioni file quando create un pacchetto nativo da un file AIR o AIRI.

input_airi Da specificare quando create un pacchetto nativo da un file AIRI. Le opzioni AIR_SIGNING_OPTIONS sono necessarie se il target è air (oppure non specificato).

input_air Da specificare quando create un pacchetto nativo da un file AIR. Non specificate le opzioni AIR_SIGNING_OPTIONS.

ANE_OPTIONS Identifica le opzioni e i file per la creazione di un pacchetto di estensioni native. Le opzioni del pacchetto di estensioni sono descritte dettagliatamente in Opzioni per le estensioni native.

Esempi di comando -package ADT

Creare pacchetti di specifici file dell'applicazione nella directory corrente per un'applicazione AIR basata su SWF:

adt –package -storetype pkcs12 -keystore cert.p12 myApp.air myApp.xml myApp.swf components.swc

Creare pacchetti di specifici file dell'applicazione nella directory corrente per un'applicazione AIR basata su HTML:

adt –package -storetype pkcs12 -keystore cert.p12 myApp.air myApp.xml myApp.html AIRAliases.js image.gif

Creare pacchetti di tutti i file e sottodirectory nella directory di lavoro corrente:

adt –package -storetype pkcs12 -keystore ../cert.p12 myApp.air myApp.xml .
Nota: il file archivio di chiavi contiene la chiave privata impiegata per firmare l'applicazione. Non includete mai il certificato per la firma nel pacchetto AIR! Se sono stati utilizzati caratteri jolly nel comando ADT, collocate il file archivio di chiavi in una posizione differente, in modo che non venga incluso nel pacchetto. In questo esempio il file archivio di chiavi, cert.p12, risiede nella directory principale.

Creare pacchetti solo dei file principali e di una sottodirectory images:

adt –package -storetype pkcs12 -keystore cert.p12 myApp.air myApp.xml myApp.swf images

Creare pacchetti di un'applicazione basata su HTML e di tutti i file nelle sottodirectory HTML, scripts e images:

adt –package -storetype pkcs12 -keystore cert.p12 myApp.air myApp.xml index.html AIRALiases.js html scripts images

Creare un pacchetto del file application.xml e del file SWF principale situato in una directory di lavoro (release/bin):

adt –package -storetype pkcs12 -keystore cert.p12 myApp.air release/bin/myApp.xml –C release/bin myApp.swf 

Creare un pacchetto di risorse da più di una posizione del file system di creazione. In questo esempio, prima della creazione del pacchetto le risorse dell'applicazione sono situate nelle seguenti cartelle:

/devRoot 
    /myApp 
        /release 
            /bin 
                myApp-app.xml 
                myApp.swf or myApp.html 
    /artwork 
        /myApp 
            /images 
                image-1.png 
                ... 
                image-n.png 
    /libraries 
        /release 
            /libs 
                lib-1.swf 
                lib-2.swf 
                lib-a.js 
                AIRAliases.js

L'esecuzione del seguente comando ADT dalla directory /devRoot/myApp:

adt –package -storetype pkcs12 -keystore cert.p12 myApp.air release/bin/myApp-app.xml  
    –C release/bin myApp.swf (or myApp.html) 
    –C ../artwork/myApp images  
    –C ../libraries/release libs

determina la seguente struttura di pacchetti:

/myAppRoot 
    /META-INF 
        /AIR 
            application.xml 
            hash 
    myApp.swf or myApp.html 
    mimetype 
    /images 
        image-1.png 
        ... 
        image-n.png 
    /libs 
        lib-1.swf 
        lib-2.swf 
        lib-a.js 
        AIRAliases.js

Eseguire ADT come programma Java per un'applicazione semplice basata su SWF (senza impostare il percorso di classe):

java –jar {AIRSDK}/lib/ADT.jar –package -storetype pkcs12 -keystore cert.p12 myApp.air myApp.xml myApp.swf 

Eseguire ADT come programma Java per un'applicazione semplice basata su HTML (senza impostare il percorso di classe):

java –jar {AIRSDK}/lib/ADT.jar –package -storetype pkcs12 -keystore cert.p12 myApp.air myApp.xml myApp.html AIRAliases.js

Eseguire ADT come programma Java (con il percorso di classe Java impostato in modo da includere il pacchetto ADT.jar):

java -com.adobe.air.ADT –package -storetype pkcs12 -keystore cert.p12 myApp.air myApp.xml myApp.swf 

Eseguire ADT come attività Java in Apache Ant (anche se in genere è consigliabile usare il comando ADT direttamente negli script Ant). I percorsi visualizzati negli esempi si riferiscono a Windows:

<property name="SDK_HOME" value="C:/AIRSDK"/> 
<property name="ADT.JAR" value="${SDK_HOME}/lib/adt.jar"/> 
 
target name="package"> 
    <java jar="${ADT.JAR}" fork="true" failonerror="true"> 
        <arg value="-package"/> 
        <arg value="-storetype"/> 
        <arg value="pkcs12"/> 
        <arg value="-keystore"/> 
        <arg value="../../ExampleCert.p12"/> 
        <arg value="myApp.air"/> 
        <arg value="myApp-app.xml"/> 
        <arg value="myApp.swf"/> 
        <arg value="icons/*.png"/> 
    </java> 
</target>
Nota: su alcuni computer, i caratteri a doppio byte nei percorsi del file system possono essere interpretati erroneamente. Se ciò si verifica, provate a impostare il JRE usato per eseguire ADT in modo da utilizzare il set di caratteri UTF-8. Questa impostazione viene effettuata in modo predefinito nello script utilizzato per avviare ADT su Mac e Linux. Nel file adt.bat di Windows, oppure quando eseguite ADT direttamente da Java, specificate l'opzione -Dfile.encoding=UTF-8 nella riga di comando Java.