API di ActionScript specifiche per applicazioni AIR per dispositivi mobili

Le API seguenti sono disponibili solo in applicazioni AIR su dispositivi mobili. Al momento non possono essere utilizzate nelle versioni Flash Player o desktop di AIR.

API di orientamento dello schermo

L'API di orientamento dello schermo consente di utilizzare l'orientamento dello stage e dell'iPhone:

• Stage.autoOrients : indica se l'applicazione è impostata per fare in modo che lo stage si riorienti automaticamente quando il dispositivo viene ruotato. Questa proprietà è impostata su true quando nella finestra di dialogo delle impostazioni iPhone di Flash Professional CS5 è selezionata l'opzione di orientamento automatico. (Potete anche impostare l'elemento autoOrients su true nel file descrittore dell'applicazione.) Vedete Impostazioni applicazione iPhone . Potete annullare il riorientamento automatico aggiungendo un listener dell'evento orientationChanging per l'oggetto Stage. La chiamata al metodo preventDefault() di questo oggetto evento annulla il riorientamento automatico.

  Quando utilizzate l'orientamento automatico, per risultati ottimali impostate la proprietà align dello Stage sui valori seguenti:

  stage.align = StageAlign.TOP_LEFT; 
  stage.scaleMode = StageScaleMode.NO_SCALE;

• Stage.deviceOrientation : indica l'orientamento fisico del dispositivo. La classe StageOrientation definisce i valori per questa proprietà.

• Stage.orientation : indica l'orientamento attuale dello stage. La classe StageOrientation definisce i valori per questa proprietà.

• Stage.supportsOrientationChange : impostato su true sull'iPhone e su false in un'applicazione AIR.

• Stage.setOrientation() : consente di impostare l'orientamento dello stage. Questo metodo dispone di un solo parametro, che è una stringa che definisce il nuovo orientamento dello stage. Le costanti nella classe StageOrientation definiscono i possibili valori del parametro.

• StageOrientation: definisce i valori di orientamento dello stage. Ad esempio, StageOrientation.ROTATED_RIGHT indica uno stage ruotato a destra rispetto all'orientamento predefinito del dispositivo.

• StageOrientationEvent: definisce eventi inviati dallo Stage quando l'orientamento dello schermo cambia. Questo evento si verifica quando l'utente ruota l'iPhone. Esistono due tipi di eventi. Lo Stage invia l'evento orientationChanging quando il dispositivo viene ruotato. Per impedire che lo stage venga riorientato, chiamate il metodo preventDefault() dell'oggetto evento orientationChanging . Lo Stage invia l'evento orientationChange dopo che lo stage è stato riorientato.

Attualmente, l'API di orientamento dello schermo è utile solo nelle applicazioni AIR su dispositivi mobili. Se un'applicazione AIR per dispositivi mobili e un'applicazione AIR desktop condividono il codice di origine, utilizzate la proprietà Stage.supportsOrientationChange per verificare se l'API è supportata.

Nell'esempio seguente viene mostrato come rispondere alla rotazione del dispositivo da parte dell'utente:

stage.addEventListener(StageOrientationEvent.ORIENTATION_CHANGE, 
            onOrientationChange); 
 
function onOrientationChange(event:StageOrientationEvent):void 
{ 
    switch (event.afterOrientation) { 
        case StageOrientation.DEFAULT: 
            // re-orient display objects based on 
            // the default (right-side up) orientation. 
            break; 
        case StageOrientation.ROTATED_RIGHT: 
            // Re-orient display objects based on 
            // right-hand orientation. 
            break; 
        case StageOrientation.ROTATED_LEFT: 
            // Re-orient display objects based on 
            // left-hand orientation. 
            break; 
        case StageOrientation.UPSIDE_DOWN: 
            // Re-orient display objects based on 
            // upside-down orientation. 
            break; 
}

In questo esempio, in caso di orientamenti stage diversi, sono presenti commenti anziché codice funzionante.

Potete cambiare l'orientamento dello stage chiamando il metodo setOrientation() dell'oggetto Stage. L'impostazione dell'orientamento è un'operazione asincrona. Potete verificare quando l'orientamento è completato intercettando l'evento orientationChange . Il codice seguente mostra come impostare lo stage sull'orientamento destro:

stage.addEventListener(StageOrientationEvent.ORIENTATION_CHANGE, 
            onOrientationChange); 
stage.setOrientation(StageOrientation.ROTATED_RIGHT); 
 
function onOrientationChange(event:StageOrientationEvent):void 
{ 
    // Code to handle the new Stage orientation 
}

Mentre lo Stage ruota si ridimensiona e l'oggetto Stage invia un evento resize . Potete ridimensionare e riposizionare gli oggetti di visualizzazione sullo Stage in risposta all'evento resize .

NativeApplication.systemIdleMode e SystemIdleMode

La proprietà NativeApplication.systemIdleMode impedisce che l'iPhone entri nella modalità di inattività. Per impostazione predefinita, un iPhone entra nella modalità di inattività se lo schermo sensibile non viene utilizzato per un certo periodo di tempo. La modalità di inattività può causare la riduzione della luminosità dello schermo. Inoltre, può causare l'attivazione della modalità di blocco. Questa proprietà può essere impostata su uno di due valori:

Questa funzionalità è supportata solo sui dispositivi mobili e non nelle applicazioni AIR in esecuzione su sistemi operativi desktop. In un'applicazione eseguita sul desktop, l'impostazione della proprietà NativeApplication.systemIdleMode non ha alcun effetto.

Nel codice seguente viene mostrato come disattivare la modalità di inattività dell'iPhone:

NativeApplication.nativeApplication.systemIdleMode = SystemIdleMode.KEEP_AWAKE;

CameraRoll

La classe CameraRoll consente di aggiungere un'immagine al rullino fotografico dell'iPhone. Il metodo addBitmapData() aggiunge un'immagine al rullino fotografico dell'iPhone. Il metodo dispone di un solo parametro, bitmapData , che rappresenta l'oggetto BitmapData contenente l'immagine da aggiungere al rullino fotografico.

La funzionalità CameraRoll è supportata solo sui dispositivi mobili e non nelle applicazioni AIR in esecuzione su sistemi operativi desktop. Per verificare in fase di runtime se l'applicazione supporta la funzionalità CameraRoll, controllate la proprietà CameraRoll.supportsAddBitmapData statica.

Dopo aver chiamato il metodo addBitmapData() , l'oggetto CameraRoll invia uno di due eventi:

Il codice seguente aggiunge un'immagine dello stage (un'acquisizione schermo) al rullino fotografico:

if (CameraRoll.supportsAddBitmapData) 
{ 
    var cameraRoll:CameraRoll = new CameraRoll(); 
    cameraRoll.addEventListener(ErrorEvent.ERROR, onCrError); 
    cameraRoll.addEventListener(Event.COMPLETE, onCrComplete); 
    var bitmapData:BitmapData = new BitmapData(stage.stageWidth, stage.stageHeight); 
    bitmapData.draw(stage); 
    cameraRoll.addBitmapData(bitmapData); 
} 
else 
{ 
    trace("not supported."); 
} 
 
function onCrError(event:ErrorEvent):void 
{ 
    // Notify user. 
} 
 
function onCrComplete(event:Event):void 
{ 
    // Notify user. 
}

DisplayObject.cacheAsBitmapMatrix

La proprietà cacheAsBitmapMatrix è un oggetto Matrix che definisce in che modo viene eseguito il rendering di un oggetto di visualizzazione quando cacheAsBitmap è impostata su true . L'applicazione utilizza questa matrice come una matrice di trasformazione quando esegue il rendering della versione bitmap dell'oggetto di visualizzazione.

Se cacheAsBitmapMatrix è impostata, l'applicazione conserva un'immagine della bitmap memorizzata nella cache di cui effettua il rendering utilizzando questa matrice, anziché la matrice di visualizzazione. (La matrice di visualizzazione è il valore della proprietà transform.concatenatedMatrix dell'oggetto di visualizzazione.) Se questa matrice non corrisponde alla matrice di visualizzazione, la bitmap viene ridimensionata e ruotata in base alle esigenze.

Per un oggetto di visualizzazione con impostata la proprietà cacheAsBitmapMatrix , il rendering viene eseguito solo quando il valore di cacheAsBitmapMatrix cambia. La bitmap viene ridimensionata e ruotata come appropriato in modo che sia conforme alla matrice di visualizzazione.

I rendering basati su CPU e GPU traggono entrambi vantaggio dall'utilizzo della proprietà cacheAsBitmapMatrix , anche se i benefici per il rendering GPU sono maggiori.

Ad esempio, il codice seguente utilizza una rappresentazione bitmap non trasformata dell'oggetto di visualizzazione:

matrix:Matrix = new Matrix(); // creates an identity matrix 
mySprite.cacheAsBitmapMatrix = matrix; 
mySprite.cacheAsBitmap = true;

Il codice seguente utilizza una rappresentazione bitmap che corrisponde al rendering corrente:

mySprite.cacheAsBitmapMatrix = mySprite.transform.concatenatedMatrix; 
mySprite.cacheAsBitmap = true;

In genere, la matrice dell'identità ( new Matrix() ) o transform.concatenatedMatrix è sufficiente. Tuttavia, potete utilizzare un'altra matrice, ad esempio una matrice ridotta, per caricare una bitmap diversa nella GPU. L'esempio seguente applica una matrice cacheAsBitmapMatrix che è ridotta di un fattore 0,5 sugli assi x e y. Le dimensioni dell'oggetto bitmap utilizzato dalla GPU sono inferiori, tuttavia la GPU regola le sue dimensioni in modo che corrispondano alla proprietà transform.matrix dell'oggetto di visualizzazione:

matrix:Matrix = new Matrix(); // creates an identity matrix 
matrix.scale(0.5, 0.5); // scales the matrix 
mySprite.cacheAsBitmapMatrix = matrix; 
mySprite.cacheAsBitmap = true;

In generale, scegliete una matrice che trasformi l'oggetto di visualizzazione nelle dimensioni con cui appare nell'applicazione. Ad esempio, se l'applicazione visualizza la versione bitmap dello sprite ridotta della metà, utilizzate la matrice che riduce della metà. Se l'applicazione visualizza lo sprite più grande rispetto alle sue dimensioni correnti, utilizzate una matrice che ingrandisce di quel fattore.

Per le dimensioni degli oggetti di visualizzazione per i quali la proprietà cacheAsBitmapMatrix è impostata esiste un limite pratico di 1020 x 1020 pixel. Per il numero totale di pixel di tutti gli oggetti di visualizzazione per i quali la proprietà cacheAsBitmapMatrix è impostata esiste un limite pratico di circa quattro milioni di pixel.

L'utilizzo della proprietà cacheAsBitmapMatrix e dell'accelerazione hardware richiede diverse considerazioni. È importante sapere quali oggetti di visualizzazione devono avere la proprietà impostata e quali no. Per informazioni importanti sull'utilizzo di questa proprietà, vedete Accelerazione hardware .

Potete utilizzare la funzione di diagnostica del rendering GPU per diagnosticare l'uso della GPU nelle build di debug dell'applicazione. Per ulteriori informazioni, vedete Debug di un'applicazione iPhone .

Note sulla connettività di rete

L'uso degli schemi URL seguenti con la funzione nativigateToURL() causa l'apertura di un documento in un'applicazione esterna:

str = "mailto:test@example.com"; 
var urlReq:URLReq = new URLRequest(str); 
navigateToURL(urlReq);

str = "sms:1-415-555-1212"; 
var urlReq:URLReq = new URLRequest(str); 
navigateToURL(urlReq);

str = "tel:1-415-555-1212"; 
var urlReq:URLReq = new URLRequest(str); 
navigateToURL(urlReq);

Un'applicazione iPhone potrebbe basarsi su certificati principali autofirmati per l'autenticazione server durante una transazione protetta, ad esempio una richiesta https. Un server deve inviare non solo il certificato foglia ma anche tutti i certificati intermedi che si concatenano al certificato principale.