API d’ActionScript propres aux applications AIR mobiles

Les API suivantes sont disponibles dans les applications AIR uniquement sur les périphériques mobiles. Elles ne fonctionnent actuellement pas dans Flash Player ou les versions de bureau d’AIR.

API d’orientation de l’écran

L’API d’orientation de l’écran permet de manipuler l’orientation de la scène et de l’iPhone :

• Stage.autoOrients : indique si l’application est définie de façon à réorienter la scène automatiquement lorsque le périphérique pivote. Cette propriété est définie sur true lorsque l’option Orientation auto est sélectionnée dans la boîte de dialogue Paramètres de l’iPhone de Flash Professional CS5. (Vous pouvez également définir l’élément autoOrients sur true dans le fichier descripteur d’application.) Pour plus d’informations, voir Paramètres de l’application iPhone . Vous pouvez annuler la réorientation automatique en ajoutant un écouteur d’événement orientationChanging à l’objet Stage. L’appel de la méthode preventDefault() de cet objet d’événement annule la réorientation automatique.

  Si vous activez l’orientation automatique, définissez la propriété align de la scène comme suit pour optimiser les résultats :

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

• Stage.deviceOrientation : orientation physique du périphérique. La classe StageOrientation définit les valeurs de cette propriété.

• Stage.orientation : orientation actuelle de la scène. La classe StageOrientation définit les valeurs de cette propriété.

• Stage.supportsOrientationChange : définie sur true sur l’iPhone, sur false dans une application AIR.

• Stage.setOrientation() : définit l’orientation de la scène. Cette méthode gère un paramètre unique, à savoir une chaîne qui définit la nouvelle orientation de la scène. Les constantes de la classe StageOrientation définissent les diverses valeurs du paramètre.

• StageOrientation : définit les valeurs d’orientation de la scène. Ainsi, StageOrientation.ROTATED_RIGHT indique une scène qui pivote vers la droite relativement à l’orientation par défaut du périphérique.

• StageOrientationEvent : définit les événements distribués par la scène en cas de changement d’orientation de l’écran. Cet événement se produit lorsque l’utilisateur fait pivoter l’iPhone. Il existe deux types d’événement. La scène distribue l’événement orientationChanging lorsque le périphérique pivote. Pour désactiver la réorientation de la scène, appelez la méthode preventDefault() de l’objet d’événement orientationChanging . La scène distribue l’événement orientationChange une fois la réorientation de la scène terminée.

L’API d’orientation de l’écran ne présente actuellement un intérêt que dans les applications AIR qui s’exécutent sur les périphériques mobiles. Si une application AIR mobile et une application AIR de bureau partagent le code source, utilisez la propriété Stage.supportsOrientationChange pour vérifier si l’API est prise en charge.

L’exemple suivant indique comment réagir à la rotation du périphérique par l’utilisateur :

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; 
}

Dans cet exemple, des commentaires remplacent le code fonctionnel en cas d’orientations diverses de la scène.

Pour modifier l’orientation de la scène, appelez la méthode setOrientation() de l’objet Stage. La définition de l’orientation est une opération asynchrone. Pour vérifier si l’orientation est terminée, écoutez l’événement orientationChange . Le code suivant indique comment activer l’orientation vers la droite de la scène :

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

Lorsque la scène pivote, elle est redimensionnée et l’objet Stage distribue un événement resize . Vous pouvez redimensionner et repositionner sur la scène les objets d’affichage suite à la distribution de l’événement resize .

NativeApplication.systemIdleMode et SystemIdleMode

La propriété NativeApplication.systemIdleMode permet de désactiver le mode Veille de l’iPhone. Par défaut, un iPhone passe en mode Veille s’il ne se produit aucune interaction avec l’écran tactile pendant une période donnée. Le mode Veille risque d’entraîner l’assombrissement de l’écran. Il active également parfois l’activation du mode Verrouillage. Vous pouvez définir cette propriété sur deux valeurs, au choix :

Cette fonctionnalité est prise en charge uniquement sur les périphériques mobiles. Elle n’est pas prise en charge dans les applications AIR qui s’exécutent sur des systèmes d’exploitation de bureau. Dans une application qui s’exécute sur le bureau, le réglage de la propriété NativeApplication.systemIdleMode est sans effet.

Le code suivant illustre la désactivation du mode Veille de l’iPhone :

NativeApplication.nativeApplication.systemIdleMode = SystemIdleMode.KEEP_AWAKE;

CameraRoll

La classe CameraRoll permet d’ajouter une image au dossier Pellicule de l’iPhone. La méthode addBitmapData() ajoute une image au dossier Pellicule de l’iPhone. Elle ne gère qu’un seul paramètre, bitmapData . Ce paramètre correspond à l’objet BitmapData contenant l’image à ajouter au dossier Pellicule.

La fonctionnalité CameraRoll est prise en charge uniquement sur les périphériques mobiles. Elle n’est pas prise en charge dans les applications AIR qui s’exécutent sur des systèmes d’exploitation de bureau. Pour vérifier à l’exécution si l’application prend en charge la fonction CameraRoll, vérifiez la propriété CameraRoll.supportsAddBitmapData statique.

Une fois la méthode addBitmapData() appelée, l’objet CameraRoll distribue l’un des deux événements suivants :

Le code suivant ajoute une image de la scène (une capture d’écran) au dossier Pellicule :

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 propriété cacheAsBitmapMatrix est un objet Matrix qui définit le mode de rendu d’un objet d’affichage si cacheAsBitmap est défini sur true . Cette matrice fait office de matrice de transformation lors du rendu de la version bitmap de l’objet d’affichage par l’application.

Lorsque la propriété cacheAsBitmapMatrix est définie, l’application conserve une image bitmap en mémoire cache dont le rendu est basé sur cette matrice au lieu de la matrice d’affichage. (La matrice d’affichage est la valeur de la propriété transform.concatenatedMatrix de l’objet d’affichage.) Si cette matrice ne correspond pas à la matrice d’affichage, l’image bitmap est mise à l’échelle et subit une rotation si besoin est.

Un objet d’affichage dont la propriété cacheAsBitmapMatrix est définie n’est rendu que si la valeur de cacheAsBitmapMatrix change. L’image bitmap est mise à l’échelle ou subit une rotation conformément à la matrice d’affichage.

Si les deux types de rendu (processeur graphique et unité centrale) exploitent la propriété cacheAsBitmapMatrix , l’impact de cette dernière est généralement plus important sur le rendu basé sur le processeur graphique.

Le code suivant utilise par exemple une représentation d’image bitmap non transformée de l’objet d’affichage :

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

Le code suivant utilise une représentation d’image bitmap qui correspond au rendu en cours :

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

En règle générale, la matrice d’identité ( new Matrix() ) ou transform.concatenatedMatrix est suffisante. Vous disposez toutefois d’une autre matrice, telle la matrice de réduction d’échelle, pour envoyer par téléchargement une image bitmap différente au processeur graphique. Ainsi, l’exemple suivant applique une matrice cacheAsBitmapMatrix correspondant à une mise à l’échelle de 0,5 sur les axes x et y. L’objet bitmap utilisé par le processeur graphique est de taille inférieure. Ce dernier ajuste toutefois sa taille en fonction de la propriété transform.matrix de l’objet d’affichage :

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

En règle générale, sélectionnez une matrice qui transforme l’objet d’affichage de sorte à obtenir la taille requise dans l’application. Par exemple, si l’application affiche la version bitmap du sprite à laquelle a été appliquée une mise à l’échelle de 0,5, utilisez une matrice qui produit une mise à l’échelle de 0,5. Si l’application affiche le sprite dans une taille supérieure aux dimensions en cours, utilisez une matrice dont le facteur de mise à l’échelle est identique.

La taille des objets d’affichage dont vous définissez la propriété cacheAsBitmapMatrix est limitée pour des raisons pratiques (1 020 pixels sur 1 020 pixels au plus). Le nombre total de pixels de tous les objets d’affichage dont la propriété cacheAsBitmapMatrix est définie est limité pour des raisons pratiques (environ quatre millions de pixels au plus).

Vous devez tenir d’un grand nombre de facteurs lorsque vous utilisez cacheAsBitmapMatrix et l’accélération matérielle. Il est important d’identifier les objets d’affichage pour lesquels cette propriété doit être définie. Pour plus d’informations sur l’utilisation de cette propriété, voir Accélération matérielle .

Vous pouvez utiliser la fonction de diagnostic de rendu sur GPU pour diagnostiquer l’utilisation du processeur graphique dans les versions de débogage de votre application. Pour plus d’informations, voir Débogage d’une application iPhone .

Notes relatives à la mise en réseau

L’utilisation des modèles d’URL suivants avec la fonction nativigateToURL() entraîne l’ouverture d’un document dans une application externe :

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);

Une application iPhone peut se fier à des certificats racine auto-signés installés pour authentifier un serveur au cours d’une transaction sécurisée, telle une requête https. Un serveur devrait envoyer non seulement le certificat feuille, mais également tous les certificats intermédiaires liés au certificat racine.