Visiblement, Magento se porte plutôt bien ! Une nouvelle version “Professionnelle”, une version iPhone (native), des chiffres tous dans le noir. L’équipe de chaume pas !

L’essentiel des conférences ne s’adressent pas particulièrement aux développeurs, mais plus aux e-commerçants ou aux équipes commerciales des prestataires. Ceci dit, j’ai tout de même trouvé mon compte dans les rencontres et certaines présentations.

Celle de Zend (Utiliser les outils Zend pour le développement et la production) par exemple abordant le monitoring d’application Php. J’avais déjà vu une présentation du genre, mais chaque fois que je revois le zend server en action, je me dis qu’il m’en faut un Ca donne envie de faire des bugs, rien que pour utiliser l’outil. Pour faire simple, entre autres fonctionnalités, le zend server permet de générer une trace particulièrement complète (contenu de la requête, variables, liste des méthodes parcourues) lors d’une erreur. La détection et l’affichage des erreurs sont configurables. Vous pouvez par exemple spécifier à partir de combien de temps une requête est considérer comme lente. La trace peut finalement être exportée et visualisée sur Zend Studio par un développeur. Vous trouverez plus de détails sur le site de zend. En avant première, nous avons également appris qu’une nouvelle version du zend server (cluster manager) permettant de gérer des clusters de zend servers allait sortir dans peu de temps.

J’ai également beaucoup aimé la présentation de Cybercité (Les Do et les Don’t en matière de SEO sous Magento). Celle-ci a d’ailleurs dépassé le cadre de Magento pour aborder les aspects SEO en général. Il était intéressant d’apprendre par exemple que la première place sur Google n’est plus forcément la meilleure. Avec l’apparition des images dans les résultats des recherches sur Google, les positions autour de celles-ci, deviennent aussi particulièrement intéressantes.

Pour le reste, je pense que les participants ont largement trouvé leur compte et le networking a bien fonctionné. En tout cas, l’organisation a été remarquable malgré une demi-heure de retard, mais c’est une constatation très helvétique Bref, globalement une très bonne journée !

Jour 1

Tout d’abord, félicitation à l’équipe pour sa réactivité. En effet, 3 jours plus tôt (le vendredi 12 février) sortait une nouvelle version de Magento CE, la 1.4.0. Et ce lundi 15 février, nous apprenons que la formation portera sur cette nouvelle version et que même les supports de cours ont été mis à jour. Vous trouverez plus d’informations sur la 1.4 ici.

Ce premier cours commence par les présentations et visiblement le niveau des participants est très varié. Certains sont débutants en Php et avec les concepts objets. Pour ma part, je suis certifié en Php et sur le Zend Framework (sur lequel est construit magento). Nous enchaînons avec un petit historique et des exemples de sites sur magento.

L’essentiel de la journée est consacrée à l’installation de magento. Pour cela, l’académie met à disposition des postes Windows 7 avec tous les outils nécessaires : Zend Studio & Zend Server. Personnellement, j’ai pris mon mac, je n’arrive plus à me servir d’un PC depuis une année En parallèle de cette installation, les outils de développement Zend sont présentés, notamment les fonctions de profilage du Zend Server (la version payante est impressionnante !) et l’utilisation du Zend Studio. Gabriel évoque également la terminologie magento ainsi que quelques concepts objets comme le MVC. Pour finir, nous testons les fonctionnalités d’aide au développement offertes par magento, telles qu’un profilage intégré ou la visualisation des noms de blocks.

En résumé cette première journée s’adresse essentiellement à ceux qui n’ont jamais touché magento et si vous avez de bonnes bases en Php et que vous avez déjà installé magento, vous devriez pouvoir commencer votre semaine le mardi. Ceci étant dit, quelques astuces très pratiques sont tout de même délivrées dans le courant de la journée permettant par exemple de bien réaliser un import/export complet.

Astuces import / export magento :
• cocher la non-vérification des contraintes d’intégrité lors du dump de la base (phpmyadmin)
• la table core_config_data est à mettre à jour après l’import car elle contient les urls d’accès (web/unsecure/base_url et web/secure/base_url)
• le fichier app/etc/local.xml contient les accès DB et autres éléments de configuration à changer lors du changement d’environnement
• le fichier dowloader/pear.ini est à regénérer en cas de changement d’environnement, mais ceci ne peut pas être fait à la main. Pour cela, il faut l’effacer et resauvegarder la config dans magento connect.

Jour 2

Ce deuxième jour est plus instructif. Nous abordons ce matin les concepts liés au templating. Comme beaucoup de choses dans magento, celui ci, pas toujours évident à bien comprendre, est très explosé. Du coup la présentation des différentes interactions entre les interfaces, les thèmes et les skins et surtout la configuration de ces interactions est essentielle pour appréhender toute intégration graphique. De l’association des interfaces ou thèmes différents à un shop dans l’administration magento (assez évident) à la mise en place de quelques retouches graphiques via des modifications du code (pas toujours intuitif dans un premier temps), de nombreux aspects sont abordés.

Le sujet, plustôt vaste, nous occupe toute la journée, mais c’est sans aucun doute les travaux pratiques qui m’instruisent le plus. La mise en place du fichier de configuration (xml) qui décrit les interactions entre les vues (fichiers .phtml) et les templates laisse entrevoir une puissance qui donne envie d’aller plus loin. Les possibilités de redéfinir le contenu d’un layout au fur et à mesure que l’on se ballade dans les fichiers de configuration sont plus qu’intéressantes. Si vous n’avez jamais approché magento, ceci n’est pas forcément très parlant, mais la curiosité du développeur en vous doit être titillée.

Bref, un deuxième jour très intéressant.

Au moment de rendre une page, magento parse absolument tous les fichiers de config (pour autant que le module ou le thème soit inclu) afin de déduire la configuration souhaitée. Ceci permet de redéfinir des bouts de configuration dans son code, ce qui peut être très pratique. Évidemment, ce mécanisme est mis en cache (si celui ci est activé).

Jour 3

Pour commencer ce troisième jour, nous poursuivons les explications liés aux templates. Mais l’essentiel de la matinée est consacrée à l’analyse d’un module. Quelle arborescence constitue un module? Où se trouvent les fichiers ? Comment les lier entre eux ? On replonge du coup dans le fonctionnement des fichiers de configs XML qui décrivent tant de choses dans magento. Nous apprenons par exemple comment surcharger uniquement un produit ou une catégorie.

L’après-midi, le sujet principal est le modèle de données de magento et surtout le concept sur lequel il repose : EAV. S’il est vrai que cette approche ne rend pas la modélisation plus simple, il la rend par contre beaucoup plus flexible, un atout indispensable qui explique aussi la modularité de magento.

Si la première journée m’a un peu inquiétée parce que pas très instructive, les deux jours suivants, avec leur lots d’astuces, de “how-to’s” et de “best practices” m’ont largement rassurés. Pourvu que ça dure !

Dans la config, si vous n’avez pas de type particulier à attribuer à un Block, donnez lui le type par défaut – core/template :

<block type="core/template" name="monblock" as="monblock" >

Jour 4

Aujourd’hui nous créons notre premier module. On commence par déclarer le module. Au début, il ne fait qu’afficher le fameux “Hello World !”. Puis, plus le cours avance, plus il se construit.

Tout y passe… scripts et configuration de l’installation, gestion des versions, création de blocks, de controllers, ajout d’un model, communication avec la base de données grâce aux “Resource Models”, surcharge du core.

Nous modifions les données sans faire une requête sql grâce aux “Varien_Object”. Ce concept, très inspiré du Zend Framework, permet d’avoir du code très lisible et facile à maintenir. Les listes sont affichées grâce à la classe “Varien_Data_Collection” qui facilite entre autres le filtrage des résultats ou encore la pagination.

Ce module interagis exclusivement avec le frontend magento, alors l’après-midi nous analysons un module existant (le module news créer par l’extension Module Creator) qui interagis également avec le backend. Nous voyons ainsi comment afficher très facilement une liste d’éléments dans l’admin, en sélectionner un pour le modifier, ajouter des fonctionnalités d’exports Excel ou XML et de “Mass Action”.

Que du bonheur !

La liste des modules installés sur votre instance de magento se trouve dans la table “core_resources”. Vous y trouverez aussi la version actuelle du module. Ceci peut être très pratique en développement pour manipuler ses modules.

Jour 5

Dernier jour. Gabriel passe la journée à répondre aux nombreuses questions et nous proposent quelques concepts pas encore abordés.

On survole ainsi le fonctionnement des événements et des observers qui permettent d’éviter parfois de surcharger le core de magento et donc d’être moins sensible aux mises à jour du produit. On complète notre module créé la veille avec des fonctionnalités de traductions et nous testons rapidement un webservice. Enfin, nous observons le fonctionnement des imports / export automatiques depuis l’admin (pas mal, mais un peu limité).

Cette dernière journée permet surtout de répondre aux interrogations de tout le monde et de présenter ses problèmes concrets. On obtient rapidement une solution, une direction à suivre ou à ne pas suivre. Encore une fois beaucoup de temps gagner grâce à l’expertise des membres de l’académie.

Conclusion

Un détail, et pas des moindre, que je n’ai pas précisé est que le prix de la formation inclus le repas du midi qui est (à mon goût) très bon.

En résumé, je pense que cette formation me permettra de gagner énormément de temps sur mes futurs projets magento. Moins de temps sur Google, plus d’efficacité et une meilleure utilisation du framework magento (car c’est aussi un framework). Je dois dire donc, que cette semaine a été très positive et que j’encourage tout futur développeur magento à prendre ce temps pour parfaire ses compétences. Pour les articles techniques, ils arriveront au fur et à mesure que les projets avanceront.

Bonne journée

Cette version apporte son lot de corrections de bugs et de nouvelles fonctionnalités dont certaines particulièrement intéressantes.

Vous trouverez la liste exhaustive des changements ici, ou encore dans cet article.

WYSIWYG & Widgets

Personnellement, ce qui me plaît beaucoup c’est le nouveau WYSIWYG intégré dans le CMS. Ce WYSIWYG est très complet puisqu’il intègre également des widgets.

Il est donc maintenant possible, sans une seule ligne de code, de configurer sa page d’accueil (ou un autre page du CMS) pour présenter un produit en particulier, les nouveaux produits, les derniers produits consultés ou encore des blocks statiques. Vous pourrez même créer vos propres widgets. Certains e-commerçants vont être contents.

Custom variables

Un nouveau système de “custom variables” a également été intégré. Ceci permet de créer une variable personnalisée grâce à une nouvelle interface utilisateur.

Cette variable peut contenir du html et/ou du texte simple. Le but étant ensuite d’intégrer cette variable dans le CMS (de la même manière qu’un widget) ou dans les emails transactionnels. Vous pourriez par exemple avoir votre signature d’email dans une de ces variables et ensuite l’intégrer dans vos emails. Le jour où la signature change, le travail n’est à faire qu’à un seul endroit.

Templates

Le système de gestion des templates a été légèrement modifié, mais à mon avis (et de l’avis de certains experts reconnus) cette modification n’apporte pas grand chose, au contraire.

En effet, un niveau supplémentaire (base) a été ajouté au niveau de la hiérarchie des designs, et même si Varien prétend que ce niveau permet d’améliorer la maintenance, il me semble pas que ce soit une réalité. Cela rend simplement plus sensible vos templates aux mises à jour de magento. La bonne nouvelle, c’est qu’on peut ne pas en tenir compte.

Pour le reste, les nouveautés concernent entre autres des améliorations du cache, des nouvelles possibilités de configurations, une gestion améliorée de la TVA, la possibilité de mettre son site en “maintenance” très facilement… Une belle liste de fonctionnalités qui donnent de bonnes raisons de se réjouir

I was recently playing around with flex, having fun fading in and out stuff when I realized that text components such as LABEL or TEXT where not very “fade friendly”. There was nothing special with my code, no special font or anything, so I googled a little and found out that you need to embed a font for it to be “fadable”, event if it is a system font.

Here is an example :

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml"
                layout="absolute"
                width="200" height="200"
                backgroundAlpha="0"
                backgroundColor="#FFFFFF">

    <mx:Script>
        <![CDATA[
            [Embed(systemFont='Verdana', fontName='myVerdana', mimeType='application/x-font')]
            public var myVerdana:Class;
        ]]>
    </mx:Script>

    <mx:Canvas id="myCanvas"
               backgroundColor="#AAAAAA"
               backgroundAlpha="1"
               width="200" height="150"
               hideEffect="{myFade}"
               showEffect="{myFade}">
        <mx:Text horizontalCenter="0"
                 top="30"
                 color="#000000"
                 text="Embeded Font Text"
                 fontFamily="myVerdana"
                 fontSize="15"/>
        <mx:Text horizontalCenter="0"
                 top="80"
                 color="#000000"
                 text="Non Embeded Font Text"
                 fontSize="15"/>
    </mx:Canvas>

    <mx:Fade id="myFade" duration="1000" />

    <mx:Button click="{myCanvas.visible = !myCanvas.visible}"
                 horizontalCenter="0"
                 top="160"
                 label="Fade In/Out"/>

</mx:Application>

Hope this helps…

Tout d’abord, vérifiez que vous avez les locales nécessaires au niveau du sdk (/Adobe Flex Builder 3/sdks/3.2.0/frameworks/locale/). Pour chaque locale, vous devez avoir un répertoire correspondant (par exemple en_US ou fr_FR). S’il vous en manque un, il suffit simplement de copier un des répertoires existants et de le renommer.

Pour commencer, il nous faut un fichier par langue pour y mettre les traductions nécessaires. Pour cela, il suffit de créer un répertoire locale/ dans votre répertoire src/ :

Dans ce répertoire locale/ vous devrez ensuite créer un répertoire pour chaque langue que vous voulez traduire (ici l’allemand et le français). Enfin, chaque répertoire doit contenir le fichier de traduction qu’on appellera ici “monProjet.properties”.

Les fichiers .properties contiennent une ligne par traduction selon le format de l’exemple ci dessous :

L_LOGIN=identifiant
L_PASSWORD=mot de passe
L_EXIT=quitter

J’ai l’habitude (pour des raisons historiques ) d’écrire mes clés de traduction en majuscule et de les faire commencer par un “L_” mais ce n’est pas une obligation.

Maintenant que nous avons nos fichiers de traductions, il faut dire à l’application qu’ils existent. Pour cela, il suffit de rajouter au fichier monProjet.mxml les quelques lignes suivantes :

    <mx:Metadata>
        [ResourceBundle("monProjet")]
    </mx:Metadata>

Maintenant, chaque fois que vous voudrez traduire un texte, il faudra l’intégrer de la manière suivante à votre code :

    resourceManager.getString('monProjet', 'L_LOGIN');

Reste encore à préciser à votre application quelle est la langue actuellement sélectionnée. Rien de plus simple. La commande ci-dessous permet justement d’indiquer la langue choisie (quelle chance !) :

    resourceManager.localeChain = ['fr_FR'];

Evidemment, pour l’allemand, ça aurait donné :

    resourceManager.localeChain = ['de_DE'];

Une dernier petit détail… la compilation. En effet, lors de la compilation de votre projet, il faut préciser les langues utilisées et l’endroit où se trouvent les fichiers de traduction. Pour cela, dans les propriétés de votre projet, une section (“Flex Compiler”) traite de la compilation. Vous pouvez alors donner des arguments supplémentaires au compilateur. Pour la gestion multilingue, nous allons ajouter ceux-ci :

-locale=fr_FR,de_DE -allow-source-path-overlap=true -source-path=locale/{locale}

Cette fois le tour est joué, votre application est polyglotte.

Voici un très petit exemple qui permet de rapidement tester la fonctionalité :

<?xml version="1.0" encoding="utf-8"?>
<mx:WindowedApplication
    xmlns:mx="http://www.adobe.com/2006/mxml"
    layout="absolute"
    creationComplete="init()">
    <mx:Metadata>
        [ResourceBundle("monProjet")]
    </mx:Metadata>
    <mx:Script>
        <![CDATA[
            private function init():void {
                resourceManager.localeChain = ['fr_FR'];
            }
        ]]>
    </mx:Script>
    <mx:Label text="FR" x="10" y="10"
              click="{resourceManager.localeChain = ['fr_FR']}"/>
    <mx:Label text="DE" x="10" y="30"
              click="{resourceManager.localeChain = ['de_DE']}"/>
    <mx:Label x="50" y="20"
              text="{resourceManager.getString('monProjet', 'L_HELLO')}"/>
</mx:WindowedApplication>

Bonne journée.

My particular issue was the following. We had a list of products, each of them having a related picture. Some of these products could be bought, others not yet so we wanted to display the later as “disabled”. In other words, we wanted a nice colorfull picture for some products and a grayscale picture for others but the only picture available to us was the colorfull one.

So we used the ColorMatrixFilter. Here is how :

<?xml version="1.0" encoding="utf-8"?>
<mx:Application
    xmlns:mx="http://www.adobe.com/2006/mxml"
    layout="absolute"
    height="300"
    width="600"
    backgroundGradientAlphas="[0,0]"
    backgroundColor="#FFFFFF">

    <mx:Script>
        <![CDATA[

            private var rLum:Number = 0.212671;
            private var gLum:Number = 0.715160;
            private var bLum:Number = 0.072169;

            [Bindable]
            private var bwMatrix:Array =
                [rLum, gLum, bLum, 0, 0,
                 rLum, gLum, bLum, 0, 0,
                 rLum, gLum, bLum, 0, 0,
                 0, 0, 0, 0.5, 0];

            [Bindable]
            private var imgUrl:String = "http://blog.netinfluence.ch/public/julien/editImgDemo.png";

        ]]>
    </mx:Script>

    <mx:ColorMatrixFilter id="cmf" matrix="{bwMatrix}" />

    <mx:Image source="{imgUrl}" height="300" width="300"/>
    <mx:Image source="{imgUrl}" height="300" width="300"
              left="300" filters="{[cmf]}"/>

</mx:Application>

This is a very simple example. You can actually apply this method to other components than the image one. And if you play around with the matrix and the rgb values, you will find that you can change many things. The best way to see what you can do is to check out this little app : http://afoucal.free.fr/wp-content/ColorMatrixBuilder/ColorMatrix.html

So go ahead and build you own photoshop

Unsatisfied with this first approach, I looked for something else. I finally found that Flex offers a lot of possibilities allowing you to create cool layouts using only code. This makes global modifications to your application a lot easier to manage.

Here is a simple example that does not use one single image :

And here is the code

/*mxml file*/
<?xml version="1.0" encoding="utf-8"?>
<mx:Application
    xmlns:mx="http://www.adobe.com/2006/mxml"
    layout="absolute"
    height="200"
    width="200"
    xmlns:geom="flash.geom.*">
    <mx:Style source="css/style.css"/>
    <mx:Canvas styleName="outsideCanvas"
               height="190" width="190">
        <mx:filters>
            <mx:DropShadowFilter distance="0"
                                 quality="15"
                                 alpha="0.5"
                                 inner="false"/>
        </mx:filters>
        <mx:Canvas styleName="insideCanvas"
                   height="150" width="150"
                   verticalScrollBarStyleName="verticalScrollBar">
            <mx:filters>
                <mx:DropShadowFilter distance="0"
                             quality="15"
                             alpha="0.5"
                             inner="true"/>
            </mx:filters>
            <mx:Canvas verticalScrollPolicy="off"
                       horizontalScrollPolicy="off"
                       styleName="buttonStyle"
                       id="exampleButton" width="80"
                       horizontalCenter="0"
                       verticalCenter="0">
                <mx:Canvas y="1" x="1"
                           width="{exampleButton.width-4}"
                           height="50%"
                           backgroundAlpha="0.5"
                           styleName="insideButton"/>
                <mx:Canvas y="0" x="0" width="100%"
                           height="100%"
                           backgroundAlpha="0.5"
                           visible="{!this.enabled}"
                           styleName="insideButton" />
                <mx:Text text="OK"
                         verticalCenter="0"
                         horizontalCenter="0"
                         paddingTop="4"
                         color="#FFFFFF" />
                <mx:mouseOver>
                    <![CDATA[
    exampleButton.setStyle('backgroundColor', '#DF0021');
                    ]]>
                </mx:mouseOver>
                <mx:mouseOut>
                    <![CDATA[
    exampleButton.setStyle('backgroundColor', '#666666');
                    ]]>
                </mx:mouseOut>
            </mx:Canvas>
        </mx:Canvas>
    </mx:Canvas>
</mx:Application>

/* CSS file */
Application {
     backgroundGradientAlphas: 1, 1;
     backgroundGradientColors: #FFFFFF, #FFFFFF;
}
.outsideCanvas {
     horizontalCenter:0;
     verticalCenter: 0;
     backgroundAlpha: 1;
     backgroundColor: #EEEEEE;
     cornerRadius: 8;
     borderStyle: solid;
     borderThickness: 2;
     borderColor: #FFFFFF;
}
.insideCanvas {
     horizontalCenter:0;
     verticalCenter: 0;
     backgroundAlpha: 1;
     backgroundColor: #FFFFFF;
     cornerRadius: 8;
     borderStyle: solid;
     borderThickness: 2;
     borderColor: #FFFFFF;
}
.buttonStyle {
     borderColor: #DDDDDD;
     borderStyle:solid;
     borderThickness: 1;
     focusThickness: 0;
     cornerRadius: 6;
     backgroundColor: #666666;
     backgroundAlpha: 1;
}
.insideButton {
     cornerRadius: 3;
     borderColor: #DDDDDD;
     borderStyle: solid;
     borderThickness: 0;
     backgroundColor: #FFFFFF;
}

If this was not an example, the button would have been a component for obvious reusability reasons. You can do this sort of stuff for other components as well such as scrollbars, datagrids, etc… have fun !

After some time looking for a solution on the magento side, I finally found that the problem came from the datatrans configuration. The return URLs were wrong. They were logically set to the same values as you would expect for any other “non datatrans” process :

• Success URL : http://www.website.com/index.php/checkout/onepage/success/
• Error URL: http://www.website.com/index.php/checkout/onepage/failure/
• Cancel URL: http://www.website.com/index.php/checkout/cart/

The problem is that datatrans still has some stuff to do before you can return to the “standard process”, so the URLs you should call look more like this :

• Success URL : http://www.website.com/index.php/datatrans/standard/success/
• Error URL: http://www.website.com/index.php/checkout/onepage/failure/
• Cancel URL: http://www.website.com/index.php/datatrans/standard/cancel/

And you’re on the road again, again…
Hope this helps !

Le principe

D’un côté, l’application AIR et de l’autre, le serveur sur lequel se trouve la nouvelle version de l’application AIR ainsi qu’un fichier update.xml qui décrit cette nouvelle version. Périodiquement, l’application AIR va vérifier sur le serveur la présence d’une nouvelle version et dans un tel cas, la télécharge et l’installe. Ainsi, mettre à jour un parc informatique devient simple et rapide.

L’application AIR

La première chose à faire est d’importer les librairies nécessaires à la mise à jour automatique :

import air.update.ApplicationUpdaterUI;
import air.update.events.UpdateEvent;

Ensuite, il vous faut une méthode qui vérifie si la version présente sur le serveur est plus récente que la version actuelle. Cette méthode peut par exemple être appelée dans votre méthode init() (creationComplete=’init()’).

// Création de la variable appUpdater - merci Blindheit
public var appUpdater:ApplicationUpdaterUI = new ApplicationUpdaterUI();
public function checkForUpdates():void
{
    appUpdater.addEventListener(UpdateEvent.INITIALIZED, updateCheckNow);
    appUpdater.updateURL = "http://server/update.xml";
    appUpdater.delay = 0.1;
    appUpdater.isCheckForUpdateVisible = false;
    appUpdater.initialize();
}

Quelques petites explications supplémentaires :

• updateURL est l’url du fichier update.xml qui se trouve sur le serveur
• le delay est l’interval de temps (en jours) séparant deux vérifications de la version sur le seveur
• isCheckForUpdateVisible permet d’activer ou de désactiver la fenêtre qui demande à l’utilisateur si il veut en effet regarder si une mise à jour existe. Ici, elle est désactivée parce que je la trouve superflue. Il existe également d’autres options permettant de jouer avec l’affichage des fenêtres.
• initialize() active le processus
• Enfin, grâce à l‘addEventListener, la méthode updateCheckNow est appelée au retour de initialize. Ceci permet, grâce à la fonction checkNow(), de forcer un appel au serveur lors du lancement initial de l’application.

public function updateCheckNow(event:UpdateEvent):void
{
    appUpdater.checkNow();
}

Voilà pour l’application AIR.

Côté serveur

Sur le serveur vous devez mettre l’application AIR et un fichier update.xml qui décrit la nouvelle version de l’application. Au niveau de l’application, vous devez mettre à jour le numéro de version qui se trouve dans le fichier nomxxx-app.xml. Ensuite ce numéro de version doit se retrouver dans le fichier update.xml :

<update xmlns="http://ns.adobe.com/air/framework/update/description/1.0">
    <version>0.2</version>
    <url>http://server/nomxxx.air</url>
    <description>
        Nouvelle version 0.2 de nomxxx
    </description>
</update>

Il ne reste plus qu’à installer votre version 0.1 sur votre ordinateur, à déposer la version 0.2 sur le serveur et lorsque vous lancez la version 0.1, elle ira automatiquement vérifier le fichier update.xml qui se trouve sur le serveur et la mise à jour se fera ensuite automatiquement.

Remarque :

• Vérifier bien que l’application qui ouvre par défaut vos fichiers AIR est bien la bonne. Dans le cas contraire, la mise à jour plantera au moment de l’installation de la nouvelle version puisqu’elle ne pourra pas se lancer automatiquement.

Voilà, bon devs !

1- Si votre application s’appelle “demo”, vous devez avoir un fichier qui se nomme : demo-app.xml. Ouvrez ce fichier et faites les modifications suivantes :

• remplacez
  <!– <systemChrome></systemChrome> –>
  par
  <systemChrome>none</systemChrome>
• selon le look de votre application, il peut être intéressant de rendre le fond transparent. Pour cela, remplacez
  <!– <transparent></transparent> –>
  par
  <transparent>true</transparent>

2- Il ne reste plus qu’à modifier votre fichier demo.mxml en rajoutant dans la balise <mx:WindowedApplication> l’attribut showFlexChrome=”false”

• <mx:WindowedApplication showFlexChrome=”false”>

Voilà, c’est déjà fini. Vous pouvez maintenant laissez exprimer votre esprit artistique sans barrières

Avant	Après

Notice: Zend_Loader::Zend_Loader::registerAutoload is deprecated as of 1.8.0 and will be removed with 2.0.0; use Zend_Loader_Autoloader instead in /path/Zend/Loader.php on line 207

Pas de panique, c’est simplement la nouvelle gestion des espaces de noms (namespaces) du Zend Framework qui n’est plus compatible. La solution présentée ici et que vous trouverez également dans cet article permet de contourner le problème. Si vous deviez refaire une application en 1.8, il serait probablement préférable de passer par Zend_Application, Zend_Tool_Framework et Zend_Tool_Project.

Pour en revenir à notre cas, vous devez avoir un endroit dans votre code, probablement dans le bootstrap, où vous “lancer” l’autoload :

require_once "../library/Zend/Loader.php";
Zend_Loader::registerAutoload();

Il suffit de remplacer ces lignes par les suivantes, et le tour est joué :

require_once "../library/Zend/Loader/Autoloader.php";
$autoloader = Zend_Loader_Autoloader::getInstance();
$autoloader->setFallbackAutoloader(true);

Amusez-vous bien avec le Zend Framework.

En effet, iTunes U permet depuis quelques semaines un accès simple à une formation sur le développement sur iPhone. Il s’agit des cours donnés aux étudiants de Stanford qui ont été enregistrés et “podcastisés” sut iTune. C’est accès est gratuit et l’enseignement de qualité, c’est Stanford tout de même…

Le seul pré-requis est d’avoir un mac avec Xcode et de bonnes bases dans un langage de programmation quelconque, ensuite on s’installe et on apprend. Le cours vient avec son site web (slides, exercices, etc).

Bon cours

Liens :

http://itunes.stanford.edu/
http://www.stanford.edu/class/cs193p/cgi-bin/index.php

SYSTEME :

PHP 5.2.9
Mac OSX 10.5.6 LEOPARD
2.4 GHz Intel Core 2 Duo
Darwin 9.6.0

TELECHARGEMENT :

• Téléchargez PHP depuis http://www.php.net/downloads.php
• Choisir une des deux archives suivantes :
  
• Déposez et ouvrez l’archive où vous voulez.
  Personnellement, je la conserve dans le répertoire “Téléchargements”, mais c’est un choix comme un autre.

CONFIGURE :

Si vous avez déjà la version php “par défaut” qui fonctionne, vous pouvez récupérer votre chaîne “configure” avec un phpinfo().

La chaîne ci-dessous n’est qu’un exemple, il se peut qu’elle demande quelques modifications pour être cohérente avec votre système. Vous remarquerez le début de la chaîne qui indique que l’architecture qui sera utilisée est sur 64bits.

CFLAGS="-arch x86_64" ./configure '--prefix=/usr' '--mandir=/usr/share/man' '--infodir=/usr/share/info' '--disable-dependency-tracking' '--with-apxs2=/usr/sbin/apxs' '--with-ldap=/usr' '--with-kerberos=/usr' '--enable-cli' '--with-zlib-dir=/usr' '--enable-trans-sid' '--with-xml' '--enable-exif' '--enable-ftp' '--enable-mbstring' '--enable-mbregex' '--enable-dbx' '--enable-sockets' '--with-iodbc=/usr' '--with-curl=/usr' '--with-config-file-path=/etc' '--sysconfdir=/private/etc' '--with-mysql-sock=/var/mysql' '--with-mysqli=/usr/bin/mysql_config' '--with-mysql=/usr/local/mysql' '--with-openssl' '--with-xmlrpc' '--with-xsl=/usr' '--without-pear'

Dans le répertoire que vous venez de télécharger, vous trouverez le script configure.
Vous pouvez donc lancez la commande ci-dessus (en ayant fait vos modifications si nécessaires).

MAKE :

Tapez ensuite la commande suivante :

make test

Allez boire un café (ou autre chose, ça fonctionne aussi), parce que cette étape est assez longue (5/10 minutes). A la fin de cette étape, vous allez avoir un résumé des tests effectués et un certains nombre d’entre eux auront échoués (~20). Pas d’inquiétude, c’est normal.

INSTALL :

Il ne reste plus qu’à lancer la commande ci-dessous :

sudo make install

et à redémarrer apache et Voilà !

REMARQUES :

• La string configure proposée est minimale, il vous faudra la compléter si vous voulez ajouter certaines options comme gd2 par exemple. Mais vous pouvez maintenant compilez votre php librement comme le demande bon nombre de tutoriaux.
• FreeType pose quelques problèmes
• Voici un lien intéressant pour ceux qui voudrait ajouter des modules sans les compilés. En effet, ce site propose une liste de modules déjà compilés en 64 bits : http://www.viames.it/mac-os-x.html
• Tout ceci est-il bien nécessaire puisque ZendServer simplifie considérablement toutes ces procédures.