EKAMELEON - DevBlog ActionScript & ECMAScript

Aller au contenu | Aller au menu | Aller à la recherche

lundi, mars 1 2010

Signals and Receivers

Generality

The "signal engine" include in the package system.signals is a very easy ActionScript 3 messaging tools.

With the Signaler interface we can define objects who communicates by signals and can be use to create a light-weight implementation of the Observer pattern. A signal emit simple values with its own array of receivers (slots). This values can be strongly-typed with an optional internal checking process.

Receivers can be defines with a simple function reference or a custom objects who implements the interface system.signals.Receiver .

Receivers subscribe to real objects, not to string-based channels andEvent string constants are no longer needed like W3C DOM 2/3 event model.

Interfaces

The system.signals package contains two interfaces : Signaler and Receiver.

The Signaler interface is simple but contains all important methods to deploy your signals.

Lire la suite...

mercredi, septembre 30 2009

Vacances à New York ... rattrapé par Flash et Adobe :)

Petit message super minimaliste pour vous annoncer mon retour de vacances (premières vraies vacances depuis des années) et forcément bientôt des nouveautés...

Flash in Times Square (zoom)

En attendant voici deux petites photos qui montrent que même en vacances de l'autre côté de l'atlantique il est vraiment très difficile de ne pas me retrouver proche de la communauté Flash :D

Lire la suite...

jeudi, août 27 2009

D - Chargement de ressources externes ( Partie 5 - localization )

Les ressources de type "i18n" (localisation)

Généralités

Il est très important de pouvoir "localiser" (ou régionaliser) nos applications. Localiser une application permet de rendre dynamique son contenu (texte, sonore ou autres) en créant une interface utilisateur qui peut changer en fonction d'une langue en particulier. La localisation d'une application permet d'améliorer l'accessibilité pour différents utilisateurs et il est certain qu'avec toutes les difficultés que l'on peut avoir pour communiquer de façon général, il est tout de même sympathique de pouvoir le faire avec le plus grand nombre dans le monde entier.

Une bon moteur de localisation permet de changer à tout moment les traductions et éléments graphiques de l'application en fonction de données traduites dans plusieurs langues. Il est certain que le plus souvent la localisation d'un site passe par une page d'accueil simple qui permet de diriger l'utilisateur vers une version spécifique de l'application avec un contenu régionalisé.

Fonctionnalités importantes du moteur de localisations définies dans AndromedAS :

  • Externalisation des traductions et documents.
  • Utilisation de fichiers ou données externes encodées en UTF8.
  • Moteur dynamique au "runtime". La localisation doit être totalement dynamique et doit intervenir après la compilation (plus léger et plus simple à maintenir)
  • API simplifiée permettant de centraliser les mises à jours de l'interface utilisateur via un mapping utilisant plusieurs stratégies selon les besoins.
  • Par défaut, utilisation du format de donnée eden ou JSON (http://www.json.org). Malgré tout il est assez simple de créer un module de parsing basé sur une autre notation comme du XML.

Dans Flash et surtout dans le framework de base ActionScript nous trouvons la propriété flash.system.Capabilites.language qui permet à tout moment de renvoyer le code langue du système dans lequel l'application swf vient d'être lancée. L'ActionScript se base sur des noms des "codes langue" au format ISO 639-1, par exemple la propriété language aura pour valeur "fr" si le système par défaut est un système français.

Implémentation du moteur de localisation de AndromedAS

Dans AndromedAS le moteur de localisation se trouve dans le package andromeda.i18n.

1 - La classe andromeda.i18n.Lang

La première classe que nous allons étudier dans ce package est la classe andromeda.i18n.Lang qui permet d'énumérer les "codes langue" par défaut définis par la norme ISO 639-1 dans le FlashPlayer.

Cette classe donne un outil simple pour valider dans vos applications les langues disponibles.

Il est ainsi possible d'ajouter d'autres langues en cas de besoin dans la liste des langues par défaut du FlashPlayer mais bien entendu elle ne seront pas prises en compte automatiquement par la propriété flash.system.Capabilities.language (AS3) du FlashPlayer.

Voici un exemple d'utilisation de cette classe :

import asgard.i18n.Lang ;
 
trace( "Lang.ES.toString() : " + Lang.ES.toString() ) ; // es
trace( "Lang.ES.valueOf()  : " + Lang.ES.valueOf()  ) ; // es
trace( "Lang.ES.toSource() : " + Lang.ES.toSource() ) ; // new andromeda.i18n.Lang( "es" , "Spanish" )
trace( "Lang.ES.label      : " + Lang.ES.label      ) ; // Spanish
 
trace( "Lang.get('fr') == Lang.FR : " + ( Lang.get("fr") == Lang.FR ) ) ; // true
trace( "Lang.validate('fr') : " + Lang.validate('fr') ) ; // true
trace( "Lang.validate( Lang.FR ) : " + Lang.validate( Lang.FR ) ) ; // true
 
trace( "Lang.LANGS : " + Lang.LANGS ) ;
// {pl:pl,nl:nl,es:es,tr:tr,it:it,da:da,pt:pt,fi:fi,zh-CN:zh-CN,no:no,ja:ja,de:de,ru:ru,fr:fr,zh-TW:zh-TW,xu:xu,ko:ko,en:en,sv:sv,cs:cs,hu:hu}
 
trace( "Lang.LANGS.size() : " + Lang.LANGS.size() ) ; // 21

2 - Fichier externe et nomenclature

Les données externes permettant la création des différentes versions du contenu de l'application localisée doivent être par défaut au format eden. Le format eden permet de créer rapidement des fichiers de configuration simples.

En général, il est possible d'utiliser une nomenclature spécifique pour créer les fichiers textes externes de localisation. Par exemple pour créer un fichier de configuration en français avec un contexte spécifique, il suffira de créer le fichier :

  • "locale/localize_fr.eden".

Nous isolons donc cette notation en la divisant en 4 éléments distincts : {path}{prefix}{lang}[suffix}

Il existe une interface simple qui permet de créer facilement des objets qui permettent de charger les fichiers de localisation.

Lire la suite...

vendredi, juillet 31 2009

Problème d'utilisation du type * dans les propriétés virtuelles dans Flash CS3 et CS4 en mode "avertissement"

Flash CS3 et Flash CS4 proposent par défaut d'améliorer le débogage AS3 avec un "Mode avertissement". Même si à la base ce mode doit aider le flasheur dans son développement, j'avoue que personnellement je considère les "Warning" notifiés dans le panneau de sortie de Flash pas forcément très bien venus la plupart du temps.

On pourra noter d'ailleurs un bon petit feedback sur le sujet sur le site de ByteArray.org : Warnings mode, the dangerous friend

Je vais donc moi aussi vivement vous conseiller de désactiver dans vos paramètres de publication le "Mode avertissement" de votre document.

D'ailleurs il suffit de coder dans FDT quotidiennement et de compiler normalement avec le compiler FCSH et de revenir de temps en temps dans Flash pour se rendre compte que ce retour est parfois bien 'étonnant' :)

Voyons un exemple simple de classe pour isoler un warning qui pour moi ne peut vraiment pas être considéré comme une erreur :

package
{
    import flash.display.Sprite ;
 
    public class Main extends Sprite
    {
        public function Main()
        {
                _func = function():void
                {
                    trace("hello world") ;
                }           
                function1() ;
                function2() ;
            }
 
            public function get function1():Function
            {
                return _func ;
            }
 
            public function get function2():*
            {
                return _func ;
            }
 
            private var _func:Function ;
        }
    }

Il suffit d'ajouter la classe ci-dessus dans le panneau de propriété d'un nouveau document AS3 et de lancer la compilation.

Résultat nous obtenons dans le panneau de sortie les deux invocations de la fonction (en gros nous attendions ce résultat) mais très étrangement une notification de type "warning" dans le panneau "Erreurs de compilations" de Flash : "Warning: 3553: Valeur de fonction utilisée alors qu'une valeur de type * est attendue. Il semble que des parenthèses () sont absentes après cette référence à une fonction."

Lire la suite...

vendredi, juin 5 2009

AS3 - prototype et overriding

En ActionScript 3 beaucoup de développeurs ignorent ou oublient l'existence de l'objet prototype.

L'objet prototype reste un élément incontournable du langage et même si en AS3 Adobe a fait évoluer le concept pour optimiser les capacités de nos classes via une implémentation basée sur les "traits" il ne faut jamais oublier que l'ActionScript est basé sur les normes ECMAScript est reste avant tout un langage "Prototype Based".

Il est donc toujours possible d'utiliser à tout moment une objet prototype pour déclarer des méthodes sur une classe et profiter du dynamisme de ce standard.

En AS3 nous avons donc 2 manières pour créer des classes et implémenter leurs méthodes et propriétés avec des traits ou/et des prototypes.

Les traits

Toutes les propriétés définies dans les namespaces public, private, protected, internal ou custom dans une classe sont déclarées dans un trait.

Les traits sont des objets implémentés par Adobe pour augmenter les performances des classes dans l'AVM2 (virtual machine) du FlashPlayer et pour diminuer le temps utilisé pour appeler les propriétés d'un objet par rapport à l'utilisation classique basée sur une chaine de prototype.

A la base les traits permettent de copier les méthodes d'une super-classe vers sa classe enfant (de façon très optimisée) pour que l'appel de ces méthodes par la suite soit beaucoup plus rapide.

Les traits ne sont pas directement accessibles au niveau du code AS3 et fonctionnent en tache de fond dans nos applications. Dans la documentation AS3 nous pouvons lire un bon article sur le sujet dans la documentation AS3 officielle The traits object.

Il faut tout de même remarquer la note importante dans cet article qui indique que cette implémentation n'est pas garantie et peut changer ou même disparaitre dans les versions futures de l'ActionScript.

Nous pouvons tout de même rester tranquille à ce niveau là, l'AS3 est bien implémenté maintenant et il n'est pas prêt de disparaitre et dans tous les cas Adobe s'efforce toujours de garder une forte compatibilité d'un FlashPlayer à un autre.

Les traits sont donc très puissants mais en contre-partie limitent grandement certains comportements ECMAScript liés au dynamisme du langage.

En effet si l'on prend le temps de regarder de plus prêt l'implémentation des classes en AS3 certaines spécificités qui faisaient la force du langage ActionScript sont bridées comme par exemple la manipulation du scope des méthodes déclarées dans une classe basée sur les traits ou le fait qu'il est impossible de cibler la fonction constructeur d'une classe et donc il est impossible d'appliquer un apply() ou un call() dessus, etc.

Les prototypes

L'ActionScript depuis sa première version basée sur le standard ECMAScript (à partir de Flash 5) se base sur la norme ECMAScript 262 edition 3 et donc utilise des prototypes.

Chaque classe ActionScript possède un objet appelé "prototype", cette référence est un simple objet générique (donc dynamique) dans lequel il est possible de stoker des méthodes et des attributs qui seront communs à toutes les instances d'une même classe.

Lire la suite...

vendredi, mai 22 2009

Enumération type-safe AS3 (mise à jour)

Voici une petite mise à jour de mon vieux article sur les énumérations type-safe (qui date tout de même de septembre 2006 !!) avec un petit nettoyage avec du code tout en AS3 et quelques explications supplémentaires sur la fin de l'article.

Tous mes articles sont maintenant disponibles en double sur mon blog mais aussi sur des documents publiques sur Google Document :

Google Documents me permet de mettre à jour facilement mes articles et au final de préparer quelques surprises pour les prochains mois ;)

Généralités.

Les énumérations sont utilisées pour réduire les redondances de leur code et garantir le maximum de sécurité.

En ActionScript il n'existe pas de vraie implémentation précise à ce sujet. Il existe donc plusieurs recettes de cuisines pour les utiliser et je vais essayer de vous montre ma façon d'utiliser les énumérations.

Exemple simple d'énumération en utilisant des types primitifs :

package  
{
    public class ApplicationColor
    { 
        public static function getColor( color:uint ):uint
        {
            switch (color)
            {
                case 0xD97F00 : // abricot
                case 0xFFFFFF : // blanc
                case 0xD70079 : // bonbon
                case 0xAE293B : // cerise
                case 0xFF6633 : // corail 
                {
                    return color ;
                }
                default :
                {
                    return 0x000000 ; // black
                }
            }
        }
    }
}

Dans la méthode getColor() ci-dessus nous pouvons constater tout d'abord que la lecture des couleurs n'est pas forcément des plus simples (à moins d'avoir un panneau mélangeur câblé en permanence dans votre esprit), il est assez difficile de définir précisément les couleurs représentées dans la condition switch..case.

De plus si l'on doit réutiliser ces couleurs plus loin dans le code, il va falloir reprendre à chaque fois toutes les primitives. Si au cours de votre développement une couleur change il va falloir mettre en place un refactoring plus ou moins long pour remettre à jour l'ensemble de l'application. En gros il va devenir très rapidement assez compliqué de maintenir le code avec cette sorte d'implémentation.

A noter que j'ai tout de même mi en place quelques petits commentaires pour rendre un peu plus facile la lecture du code mais la lisibilité s'arrête là, il va devenir très lourd de commenter à chaque fois le code.

2 - Exemple un peu plus évolué avec des constantes

Lire la suite...

jeudi, avril 30 2009

La classe asgard.display.Background

Description

La classe Background est une classe simple mais très efficace que j'utilise dans pratiquement tous mes projets AS3. Cette classe hérite de la classe flash.display.Sprite et permet de générer des zones graphiques rectangulaires. Ces zones peuvent aussi bien remplir l'intégralité de la zone visible du FlashPlayer ou plus simplement servir de fond pour divers éléments graphiques d'une application (menus, listes, lecteur vidéo, etc.)

Cette classe utilise les API dynamiques de dessins pour générer très simplement un rectangle coloré (uni ou dégradé) ou texturé en utilisant les outils de dessins disponibles dans PEGAS.

Note : Je ne vais pas rentrer trop dans le détail ici sur le moteur de dessin de PEGAS car cette implémentation nécessite une série de tutoriels précis et complets. Je ne vais donc pas trop parler dans les exemples qui suivent des classes spécifiques de PEGAS mais n'hésitez pas en cas de problème à me poser des questions sur le sujet en attendant que je trouve le temps d'écrire les articles manquants sur le sujet.

Les bases

Pour commencer voyons tout simplement comment créer via quelques lignes de codes une zone rectangulaire avec la classe Background :

import asgard.display.Background ;
 
import pegas.draw.FillStyle ;
 
var area:Background = new Background() ;
 
area.x = 25 ;
area.y = 25 ;
 
area.fill = new FillStyle( 0xD97BD0 , 0.8 ) ;
area.w    = 400 ;
area.h    = 300 ;
 
addChild( area ) ;

Le code ci-dessus permet de générer une zone rectangulaire de 400 pixels de large (w) par 300 pixels de hauteur (h) avec une couleur de remplissage 0xD97BD0 et une transparence de 80% (alpha).

Dans la classe Background nous utilisons les propriétés virtuelles "w" et "h" pour définir la largeur et la hauteur absolues que nous voulons attribuer à notre zone rectangulaire. Je parle ici de taille "absolue" car finalement même si nous attribuons les valeurs 400 et 300, le rectangle n'aura peut être pas au final cette taille si l'on regarde les propriétés classiques "width" et "height" du display, surtout si nous appliquons à notre zone rectangulaire un contour.

Je reprends l'exemple précédent en ajoutant un contour avec la propriété "line" de la classe Background :

import asgard.display.Background ;
 
import pegas.draw.FillStyle ;
import pegas.draw.LineStyle ;
 
var area:Background = new Background() ;
 
area.fill = new FillStyle( 0xD97BD0 , 0.8 ) ;
area.line = new LineStyle( 2, 0xD97BD0, 0.6 ) ;
area.w    = 400 ;
area.h    = 300 ;
 
addChild( area ) ;

Dans l'exemple ci-dessus j'applique sur la zone rectangulaire un contour avec une épaisseur de 2 pixels avec la propriété "line" qui prend pour valeur un objet de type LineStyle. Avec un petit test très simple nous pouvons isoler la différence entre les propriétés w/h et width/height :

Lire la suite...

dimanche, mars 29 2009

Contrôler la timeline de vos animations.

1 - Généralité

Pour contrôler la timeline d'une animation Flash ou d'un MovieClip nous avons l'habitude depuis les toutes premières versions de l'ActionScript d'utiliser les méthodes play(), stop(), gotoAndStop(), etc. de la classe MovieClip.

En AS3 de nouvelles propriétés et méthodes sont apparues pour rendre encore plus souple notre maitrise de la timeline et de nos animations. Nous pouvons noter l'apparition de la classe flash.display.FrameLabel qui permet d'obtenir à n'importe quel moment via un objet typé toutes les informations d'une imagé clé portant une étiquette d'image spécifique. Ou encore la possibilité d'utiliser une méthode non documenté addFrameScript() qui permet d'injecter dans les images clés d'un MovieClip des fonctions selon les besoin au runtime.

Malgré ces outils de base, j'ai eu très vite besoin d'aller un peu plus loin et de standardiser dans l'extension ASGard de VEGAS avec 3 classes bien pratiques pour manipuler le scénario d'un MovieClip.

Ces classes sont :

Pour utiliser ces classes je vous invite à récupérer les sources de VEGAS (pour ceux qui ne l'ont pas encore récupéré les sources AS3 ;)) :

  • http://code.google.com/p/vegas/wiki/InstallVEGASwithSVN?tm=4

Pour toute question sur VEGAS et ses extensions vous pouvez vous inscrire sur le Google Groups du projet : VEGASOS .

Lire la suite...

samedi, février 7 2009

Font case sensitive in MAC OSX

Petite remarque à propos des polices de caractères sur MACOS X dans Flash.

MAC fonts case sensitive J'ai la chance depuis une petite semaine de travailler sous MAC OSX avec un tout nouveau MacBook Pro, c'est mon premier MAC donc je suis un peu comme un gosse qui découvre un nouveau joujou... Il m'a fallu tout se temps pour me mettre sur MAC et franchement là je peux dire qu'il n'y a rien à regretter. Quelques habitudes sur de longues années sur Windows sont encore à perdre mais le bilan reste à l'heure actuelle vraiment largement positif (bien plus que je ne l'espérais).

Reste que le passage d'un Windows XP vers un MAC OSX est une grosse claque au niveau ergonomie, souplesse de l'OS et des applications, et des possibilités (terminal en ligne de commande intégré, SVN, ANT, etc.. déjà installé, etc..).. Maintenant des choses sont vraiment différentes et il est clair qu'à l'heure actuelle pour intégrer convenablement une application Flash (que cela soit pour le FlashPlayer mais aussi pour AIR) il faut absolument avoir un système permettant de tester son code, et le rendu d'un projet sous plusieurs OS sous peine de réaliser après tout ce temps que l'on traine derrière soit des dommages collatéraux assez énormes !

Bon donc pour en revenir au sujet de ce ticket, je me suis rendu compte (super rapidement) que le nom des polices de caractères utilisées dans Flash (ou Flex, c'est pareil..) définies dans les feuilles de style ou dans les objets de type flash.text.TextFormat doivent absolument respecter la sensibilité de la casse des caractères.

Exemple simple de code dans Flash pour illustrer le petit problème rencontré :

var field:TextField = new TextField() ;
 
field.defaultTextFormat = new TextFormat("arial", 14) ;
 
field.x    = 10 ;
field.y    = 10 ;
field.text = "hello world" ;
 
addChild( field ) ;

Si l'on compile l'exemple précédent et que nous utilisons un FlashPlayer sous Windows, pas de soucis la police est bien prise en compte. Alors que si l'on utilise un swf généré avec le code ci-dessus par exemple dans le FlashPlayer 10 MAC OSX, la police n'est pas prise en compte et c'est la police système par défaut (Times je crois) qui est utilisée.

Lire la suite...

jeudi, janvier 1 2009

D - Chargement de ressources externes ( Partie 4 - config )

Très bonne année 2009 et surtout bonne santé !!

Je commence donc cette année avec l'avant dernier article du chapitre D sur les ressources externes des fichiers de configuration d'une fabrique IoC :)

J'aurai pu faire un simple petit article classique mais je préfère faire d'une pierre deux coups ;)

J'espère que cette année 2009 me laissera le temps de continuer mon travail sur la version 2 de VEGAS avec la fusion dans Maashaack de la plupart des packages system.events, system.process et system.ioc !

Sinon la bonne résolution pour 2009 c'est de débuter le projet de GUI AIR pour créer des RIA facilement basé sur eden et IoC + un petit projet qui me tiens à coeur avec Zwetan ... un projet de flibustier et qui sent bon le bateau en pleine mer ou dans l'espace ??... enfin je me comprends lol

Je tiens à remercier tous ceux qui m'ont aidés pendant 2008 et qui ont encore le courage de le faire cette nouvelle année pour faire avancer le projet ;)

PS : Pour ma part j'attends en 2009 des news importantes sur le futur de l'ActionScript avec AS4 !

Je peux maintenant vous laisser le temps pour lire ce nouvel article sur les ressources de type "config". Bonne lecture à tous :)

Lire la suite...

samedi, décembre 13 2008

D - Chargement de ressources externes ( Partie 3 )

Petite introduction

Avec la 3ème partie de ce chapitre nous allons étudier l'utilisation des ressources de type "font", "style" et "xml" dans les fichiers de configuration d'une fabrique IoC basée sur VEGAS et son extension AndromedAS. Ces 3 types de ressources vont vous simplifier la vie pour mettre en place vos applications.

Bonne lecture à tous :)

4 - Les ressources de type "style"

Cette ressource permet de charger un ou plusieurs fichiers texte contenant une feuille de style au format CSS qui permettra de définir le style des champs de texte dynamiques d'une application. Cette ressource permet en même temps de créer dans la fabrique IoC une définition d'objet qui servira de référence singleton pour utiliser par la suite cette feuille de style (flash.text.StyleSheet).

Commençons par définir dans un fichier texte "style/style.css" une classe de style que nous pourrons charger et utiliser ensuite dans les champs de textes dynamique de notre application.

.my-style 
{ 
    font-family: Verdana;
    font-size: 11px;
    font-weight: bold;
    color: #FEF292; 
}

Pour charger une ressource de type "style" il suffit de définir un objet générique dans l'attribut "imports" d'un fichier de configuration externe d'une fabrique IoC avec la signature suivante :

{ resource : "style/style.css" , type : "style" , id : "style_sheet" }

Lire la suite...

dimanche, décembre 7 2008

D - Chargement de ressources externes ( Partie 2 )

Voici la seconde partie du chapitre D qui traite des chargements de ressources externes pendant l'initialisation d'une fabrique IoC basée sur AndromedAS. Nous allons voir tout particulièrement les ressources de type "assembly".

3 - Les ressources de type "assembly"

Les ressources de type "assembly" servent principalement à charger des swf externes ou des images dans l'application principale de la fabrique IoC.

Le plus souvent il sera pratique d'utiliser des ressources au format swf qui serviront de bibliothèques externes partagées contenant des classes non définies dans l'animation principale mais aussi des éléments graphiques, sonores, vidéos, etc.

Ces ressources peuvent donc charger des fichiers de type : swf, jpg, png et gif

Nous avons vu que lorsque nous créons une définition d'objet dans un conteneur léger la propriété "type" de la définition correspond à un type de donnée ou une classe qui doit être présent en mémoire dans l'application au moment de la compilation ou après la compilation (runtime). Dans le cas contraire la fabrique IoC aura du mal à trouver en mémoire la classe (ou fonction constructeur) nécessaire pour créer l'objet correspondant.

Ces ressources permettront également dans un cadre plus étendu de définir dynamiquement une définition d'objet qui sera injectée dans la fabrique une fois le swf ou l'image externe chargé. Cette définition d'objet servira de lien entre la fabrique IoC et l'asset externe chargé dans l'application principale.

Pour utiliser cette fonctionnalité avancée il faut absolument utiliser l'attribut "id" de la ressource définie dans le fichier de configuration externe du contexte IoC du conteneur. Si la ressource de type "assembly" est définie sans un identifiant "id" valide alors le fichier externe sera chargé et placé en mémoire mais la fabrique IoC n'aura aucun moyen de cibler un élément contenu dans le fichier externe chargé.

Lire la suite...

dimanche, novembre 30 2008

D - Chargement de ressources externes ( Partie 1 )

J'attaque (enfin) les derniers articles sur les ressources externes chargées pendant l'initialisation d'une fabrique IoC. Ces articles vont me permettre de terminer la série d'article déjà commencée depuis quelques mois sur l'implémentation IoC de AndromedAS.

Depuis le dernier article (partie C) pas mal de choses ont bougés au niveau de VEGAS et ses extensions mais je vous en parlerai dans peu de temps dans un autre article ;)

Pour ceux qui découvrent dans cet article le design pattern d'Inversion de contrôle avec VEGAS et qui n'ont pas eu encore le temps de consulter les articles précédents, voici une liste rapide des derniers articles à lire avant d'entamer celui-ci :

Je vous conseille également d'aller faire un tour sur le Google Code du projet :

  • http://code.google.com/p/vegas/
  • http://code.google.com/p/vegas/wiki/InstallVEGASwithSVN

Pour toutes vos questions sur VEGAS et ses extensions ou suivre les nouveautés n'hésitez pas à vous inscrire sur le Google Groups :

1 - Généralité

Un objet "import" peut être défini dans tous les fichiers externes de configuration et d'initialisation d'une fabrique IoC.

Cet objet est facultatif et sera interprété par les chargeurs basés sur la classe andromeda.ioc.net.ObjectFactoryLoader, il contient des objets génériques simples qui permettent de définir une collection de différentes ressources externes qui seront chargées pendant l'initialisation de la fabrique et utilisées ensuite pendant la création des définitions d'objet mais aussi à n'importe quel autre moment dans le cycle de vie de l'application.

1-1 - Utilisation de plusieurs fichiers de configuration pour initialiser le conteneur léger.

Le fichier de configuration principal chargé par la classe ECMAObjectLoader peut être découpé en plusieurs sous fichiers chargés récursivement les uns dans les autres.

Pour charger des sous fichiers de configuration dans un fichier externe, il faut insérer à la base de l'objet principal contenu dans le DOM de configuration un attribut "imports" de type Array qui contiendra une suite d'objets génériques qui définissent les fichiers que l'on souhaite charger.

Exemple :

imports =
[
    { resource : "logging.eden"    } ,
    { resource : "view.eden"       } ,
    { resource : "controller.eden" } 
] ;

Chaque fichier chargé ci-dessus contiendra lui aussi des définitions d'objet ou d'autres définitions de ressources qui permettront d'initialiser le conteneur léger et l'application. Cette utilisation basique pour charger des ressources au format eden est en quelque sorte la partie immergée de l'iceberg car il est possible d'aller beaucoup plus loin avec l'attribut "import".

Lire la suite...

jeudi, octobre 30 2008

AS3 - Problème avec sécurisation de la classe NetStream

Voici un petit problème intéressant qui tourne autour de la classe flash.net.NetStream en AS3 et de la sécurisation des flux vidéos avec une diffusion sur un serveur Flash Media Interactive Server 3.

J'avais déjà écris un article traitant sur la sécurité appliquée dans le FlashPlayer lors de la capture d'une image provenant d'un flux vidéo en streaming via FMS avec la méthode BitmapData.draw() mais cette fois ci je vais m'attarder sur la sécurisation au niveau de la lecture et de l'enregistrement d'un flux vidéo avec les méthodes NetStream.publish() et NetStream.play().

Il est possible depuis les premières versions de Flash Media Server de sécuriser côté serveur pour un client en particulier le flux audio et vidéo avec les méthodes SSAS : Client.readAccess et Client.writeAccess.

Exemple dans une application "test" avec un fichier "main.asc" très simple :

/**
 * Invoked when the application is started.
 */
application.onAppStart = function()
{
    trace("application start") ;
}
 
/**
 * Invoked when the application is stopped.
 */
application.onAppStop = function()
{
    trace("application stop") ;
}
 
/**
 * Invoked when a new client is connected.
 */
application.onConnect = function( client , key )
{
        trace("application connect") ;
 
        application.acceptConnection( client ) ;
 
        client.readAccess  = "/public" ;
        client.writeAccess = "/public" ;
}
 
/**
 * Invoked when a client is disconnected.
 */
application.onDisconnect = function( client )
{
    trace("application disconnect") ;
}

Pour le moment aucun problème majeur à part dans le cadre d'une utilisation AS3 dans les dernières versions du FlashPlayer 9 et bien entendu dans le FlashPlayer 10 dans le cas particulier d'un utilisateur qui essaierait de lire ou enregistrer un flux vidéo sur un canal non défini dans les méthodes readAccess et writeAccess côté serveur.

Voyons un code simple AS3 dans Flash CS3 qui illustrera le problème :

Lire la suite...

samedi, septembre 13 2008

C - Configuration d'une fabrique IoC

Nous allons aborder dans cet article la configuration des fabriques IoC.

Pour ceux qui découvrent dans cet article le design pattern d'Inversion de contrôle avec VEGAS et qui n'ont pas eu encore le temps de consulter les articles précédents, voici une liste rapide des derniers articles à lire avant d'entamer celui-ci :

Comme toujours je vous rappelle rapidement les liens importants pour installer VEGAS et poser des questions à propos des concepts définis dans mes articles :

Pour ceux qui débarquent dans l'aventure, et qui ne savent pas encore ce que représente VEGAS, comment l'installer etc.. Je vous propose d'aller faire un tour rapide sur le Google Code du projet :

  • http://code.google.com/p/vegas/
  • http://code.google.com/p/vegas/wiki/InstallVEGASwithSVN

Pour toutes vos questions sur VEGAS et ses extensions n'hésitez pas à vous inscrire sur le Google Groups du projet :

VEGASoS : http://groups.google.com/group/vegasos

Introduction

Les fabriques IoC dans AndromedAS sont configurables. Il est possible de définir les paramètres généraux de configuration d'une fabrique en alimentant le contenu de sa propriété "config".

La propriété "config" est un objet de type andromeda.ioc.factory.ObjectConfig. Voici la liste de ses attributs disponibles dans cet objet de configuration :

config

Défini un objet servant de configuration globale dans la fabrique ou l'application utilisant cette fabrique.

defaultInitMethod

Défini le nom de la méthode par défaut à utiliser dans toutes définitions d'objet au moment de l'initialisation d'un objet généré avec l'une d'elles.

defaultDestroyMethod

Défini le nom de la méthode par défaut à utiliser dans toutes définitions d'objet au moment de supprimer un objet singleton généré avec l'une d'elles.

identify

Défini globalement la politique d'identification automatique des objet qui implémentent l'interface Identifiable générés dans la fabrique IoC.

locale

Défini un objet localisé servant de base pour alimenter les définitions d'objet de la fabrique selon les besoins avec des valeurs localisées.

lock

Défini globalement la politique du mode de sécurité implémenté par tous les objets ILockable générés via la fabrique IoC.

root

Défini la référence de la scène principale de l'application liée à la fabrique IoC, cette valeur permet d'utiliser dans les attributs "ref" des définitions d'objet l'expression "#root"

throwError

Défini ou désactive la diffusion des erreurs pendant l'initialisation de la fabrique. Par défaut cet attribut est true.

typeAlias

Défini les alias utilisés au moment de filtrer les types dans les définitions d'objet (si la propriété typePolicy a pour valeur "alias" ou "all").

typeExpression

Défini les expressions de formatage utilisées pour filtrer les types dans les définitions d'objet (si la propriété typePolicy a pour valeur "expression" ou "all").

typePolicy

Défini la politique de filtrage du type défini dans les définitions d'objet du conteneur léger au moment d'instancier un nouvel objet pour un identifiant donné.

useLogger

Défini le mode de diffusion des messages d'information, warning, erreurs, etc. de la fabrique entre un simple trace() ou le modèle de log défini dans VEGAS.

Lire la suite...

- page 1 de 8