Conférence Titanium + Alloy au JUG Montpellier

SoiréeTitanium MobileDamien LaureauxJUG Montpellier20 Mars 2013

Présentation

Damien Laureaux@timoa

Développeur mobile dans une SSII de Montpellier, je développe des applications

iPhone, iPad et Android depuis plus de 3 ans en utilisant le framework Appcelerator Titanium.

Certifié "Titanium Certified App Developer", "Titanium Certified Mobile Developer", je fais partie de la centaine d'experts sélectionnés par Appcelerator pour aider la communauté Titanium via le programme "Titan".

AppceleratorTitaniumPrésentation d'Appcelerator Titanium

La plateforme Appcelerator

Appcelerator Titanium est une plateforme ouverte de développement pour créer des applications natives entre les différents terminaux mobiles et systèmes d'exploitation, dont iOS, Android, Windows, BlackBerry, Tizen, HTML5 et bientôt Windows Phone.

La plateforme Appcelerator

La plateforme Appcelerator

Le framework Titanium

Il comprend un SDK open source avec plus de 5 000 APIs, Titanium Studio, un puissant IDE basé sur Eclipse, et Alloy, un framework MVC.

Cycle de vie d'une application

Des services complémentaires

Pour répondre à ce cycle de vie, Appceleratora construit un ensemble de services complémentaires dont :

● Appcelerator Analytics● Appcelerator Cloud Services● Appcelerator Functional Test *● Appcelerator Performance Management *

* disponible depuis le 30 janvier 2013 mais peu d'informations pour le moment.

Le choix de milliers d'entreprises

Appcelerator Titanium est la plateforme de développement mobile la plus plébiscitée pour des milliers d'entreprises, y compris eBay, Merck, Mitsubishi Electric, NBC et PayPal.

+50 000 applications mobiles

Avec plus de 50 000 applications mobiles déployées sur 110 000 000 de terminaux, le framework Titanium aide les entreprises à déployer 60% plus vite et obtenir un avantage concurrentiel significatif.

Simplifie le dévelopement

Titanium simplifie le processus de développement des applications mobiles permettant aux développeurs de développer rapidement, tester, compiler et publier des applications mobiles en utilisant JavaScript.

Les développeurs ayant de l'expérience en développementWeb peuvent devenir productifs immédiatement pour créer des applications natives mobiles riches à partir d'une seule base de code sans avoir à gérer de multiples outils de développement, de langages et méthodologies.

Simplifie le développement

Plateformes compatibles

Le SDK Titanium permet de créer des applications pour les plateformes suivantes :● iPhone● iPad● Android mobile & tablette● Mobile Web (HTML5)● BlackBerry 10● Liseuse Nook Color● Assistant de navigation Denso● Tizen (Intel / Samsung OS basé sur Linux)

Exemple d'application Titanium

Le futur de Titanium

Développements en cours :

● Windows Phone 8 (fin 2013)● Windows 8 (fin 2013)

Licence Appcelerator

Appcelerator a choisi la licence Apache 2 pour le SDK Titanium ainsi que pour Titanium Studio, ce qui les rend gratuits pour une utilisation personnelle et commerciale.

Titanium VSPhoneGapComparaison entre Titaniumet PhoneGap

Titanium VS PhoneGap

De loin, Titanium et PhoneGap paraissent similaire...

Le but commun est de créer une application mobile cross-platform en utilisant des langages comme le JavaScript.

Ils sont tous les 2 open-sources et sponsorisés par de grosses sociétés.

L'approche de PhoneGap

L'approche de PhoneGap est de proposer une application native socle dans laquelle on va embarquer des pages HTML5 et du JavaScript pour communiquer avec celle-ci.

Les pages HTML5 sont affichées dans une fenêtre navigateur (WebView) proposée sur la plupart des plateformes.

Points forts de PhoneGap

La création d'une application mobile simple est facilitée par l'utilisation du HTML5 et JS.

C'est pour cela que l'équipe de PhoneGap n'a implémentée qu'une partie des API natives, ce qui permet ainsi de porter PhoneGap sur d'autres plateformes plus rapidement.

L'accès au développement mobile est ainsi facilité pour les développeurs Web.

Points faibles de PhoneGap

La qualité du rendu est dépendant de la plateforme... iOS utilise Webkit comme moteur de rendu et offre les meilleurs performances mais celui d'Android est juste fonctionnel sur les versions 2.x

Le support d'HTML5 peut être incomplet entre navigateurs et donc entre les plateformes.

Points faibles de PhoneGap

Les performances sont donc variables d'un OS à un autre et les animations de transition sont gérées en JavaScript et n'utilise pas l'accélération matérielle (GPU).

Comparé à du natif, la surcouche navigateur + moteur JavaScript rend une application PhoneGap plus lente et réactive dès lors que l'on utilise beaucoup de données ou traitement (liste, animation, etc).

Points faible de PhoneGap

Le workflow peut être aussi un point noir si l'on utilise pas PhoneGap Build car il faut configurer et utiliser un IDE par plateforme :

● XCode pour iOS● Eclipse pour Android● Visual Studio pour Windows Phone● etc...

Titanium StudioPrésentation de l'IDE Titanium Studio

Présentation

A l'origine, Aptana Studio était un IDE open source basé sur Eclipse et adapté au développement Web (PHP, HTML, CSS, Javascript, Python ou encore Ruby).

Aptana a été racheté par Appcelerator et c'est comme ça qu'est né Titanium Studio.

Fonctionnalités spécifiques

En plus des fonctionnalités d'Eclipse, celles héritées d'Aptana, Titanium Studio apporte d'autres fonctions indispensables :● Gestion de projet (création pas à pas,

éditeur pour tiapp.xml, nettoyage des projets)

● Configuration de projet (choix de l'API, réglages émulateurs, etc...)

● Console de sortie et filtres● Menu "Démarrer" et "Déploiement"● Déploiement mobile et distribution (stores)

Autres fonctions de Ti Studio

● Intégration de Git, SVN, etc...● Navigateur intégré pour les tests HTML/Web● Déploiement HTML/Web, PHP (ftp, sftp,ftps)● Déploiement et distribution pour PHP, Ruby

(Engine Yard, RedHat Cloud, Capistrano)

Espace de travail de Ti Studio

Dashboard de Titanium Studio

Chaîne d'outils

Pour créer une application mobile de bout en bout, il faut un certain nombre d'outils pour :

● La gestion du projet● Ecrire le code source● Compiler le code source● Debugger l'applicaton● Simuler l'application● Signer et distribuer l'application

La chaîne d'outils pour Android

Exemple de la chaîne d'outils nécessaire à la création d'une application Android native.

La chaîne d'outils pour iOS

Exemple de la chaîne d'outils nécessaire à la création d'une application iOS native.

La chaîne d'outils Titanium Studio

Avec Titanium Studio, l'ensemble de la chaîne nécessaire à un projet mobile est traité en utilisant un seul logiciel.

JavaScript+ mobile = Titanium Mobile

L'environnement Javascript de Ti

Interpréteur V8 / Rhino sous Android et JavaScriptCore sous iOS.

Le code est exécuté dans un "contexte exclusif", similaire au thread JS dans un navigateur.

Le fichier app.js définit le contexte "racine" de l'application et la plupart du temps, un contexte suffit.

Base d'une application JavaScript

Pour la plupart des développeurs, le 1er projet Titanium est leur première application écrite en JavaScript.

Il est important d'adhérer à certaines règles :● Protéger le scope global (variables globales)● Être modulaire● S'efforcer de garder le code DRY (Don't

Repeat Yourself)

Namespaces

JavaScript partage un seul espace de nom global et unique.

Placez vos variables dans cet espace pour :● Prévenir des collisions● Fournir un "conteneur" pour vos variables● Suivre le modèle de Titanium :

Titanium.UI, Titanium.App, Titanium.API, ...

Namespaces

Création de l'objet qui servira de variable globale pour l'application :

var MyApp = {};

MyApp.someproperty = 'foo';

MyApp.somefunction = function() {};

Création d'un sous namespace :MyApp.DB = {};

CommonJS

Avantages de l'utilisation de CommonJS :● Les modules ont leur propre espace de nom

global● Pas d'accès à l'espace de nom du contexte

appelant● Retourne seulement les propriétés et

méthodes que vous avez spécifié● Le reste est "privé"

Base saine d'une application

1. Le fichier app.js doit être votre "bootstrap"

2. Définir l'espace de nom de votre application

3. Utiliser Require() pour charger vos modules

4. Créer et ouvrir votre premier composant UI

Les événements

Similaires aux événements JavaScript dans un navigateur Web.

On peut utiliser addEventListener() sur pratiquement tous les objets JavaScript.

On peut aussi programmer de déclencher des événements sur des objets avec fireEvent().

Les évènements

Les événements sont accessibles au travers de l'application, ce qui s'avère utile pour communiquer entre plusieurs contextes (modules CommonJS par exemple) via des données JSON sérialisées.

Ti.App.fireEvent('myEvent', { "id": 396 });

Ti.App.addEventListener('myEvent', function(e) { Ti.API.log('ID: ' + e.id); });

Interface utilisateur Android et iOSDifférences entre les UI d'iOS et d'Android

Présentation

Comme nous l'avons vu plus tôt, les interfaces d'iOS et d'Android ont des éléments communs mais aussi beaucoup de composants graphiques spécifiques à celles-ci.

Composants de l'interface iOS

Composants de l'interface Android

Pour un développeur Web...

Une window est l'équivalent d'une page

Une view est l'équivalent d'une div

L'espace de nom Ti.UI fournit plusieurs contrôleurs spécifiques (button, textfield, picker, scrollview)

Les objets UI sont composés de la même manière que les fragments du DOM JavaScript

Position et agencement

Position● top et left● bottom et right● center● size (rendu)

Agencement● Absolute● Vertical● Horizontal

Pour iOS, le bouton va se positionner à 170pt et pour Android à 170px, du haut de la window.

Agencement absolu

Agencement absolu

Pour iOS, le bouton va se positionner à 170pt et pour Android à 170px, du haut de la window.

Agencement vertical

L'agencement vertical permet d'empiler les éléments verticalement.

La valeur de top devient alors relative à l'élément précédent et non à celle de la window.

SDK Titanium 3.0Présentation du SDK Titanium Mobile 3.0

Introduction

La caractéristique unique de Titanium vis à vis des différentes solutions mobiles cross-plateform disponibles, est qu'il crée véritablement des applications natives.

C'est ce qui contraste avec les solutions Web qui offrent des fonctionnalités via une vue Web améliorée comme la solution PhoneGap.

Introduction

Appcelerator, ne souhaitant pas être limitée par l'affichage Web natif, ils se sont engagés dans une intégration beaucoup plus profonde avec les plateformes iOS et Android par exemple.

Cela donne aux développeurs la possibilité d'utiliser des services et composants UI natifs, avec des performances quasi-natives, caractéristiques que vous ne trouverez pas dans d'autres solutions cross-plateform mobiles.

Introduction

De plus, vous aurez accès aux fonctionnalités suivantes :● APIs spécifiques à chaque plateforme● Géolocalisation● Partage sur les réseaux sociaux● Multimédia● Données en ligne ou stockées en local● Extensibilité via des modules● et bien d'autres !

Vue d'ensemble du SDK Titanium

Performance nativePerformance native + Interface native(tableaux, animations, gestes, etc.)

GéolocalisationRéalité augmentée, géolocalisation,boussole, cartes natives

Réseaux sociauxAuthentification à Facebook, Twitter,Yahoo YQL. E-mail et carnet d'adresse natif

DonnéesBase SQLite locale, webservices, enregistrement simplifié de clef / valeur

MultimédiaAppareil photo, caméra, lecture en streaming / local, format audio / vidéo

AnalyticsStatistiques d'utilisation personnalisé, utilisation / adoption de l'app. par l'utilisateur

Titanium+PlusBase de données cryptée, ecommerce, publicité, lecteur de code barre, etc

Outils développementCréer, tester et publier votre application avec le même outil peu importe la plateforme

Développer pour plusieurs OS

L'API Titanium fournit une variable "plateforme" qui peut être utilisée avec des instructions if.

Les ressources qui peuvent être spécifiques à une plateforme :● Fichier de code● Images, texte et autres types de fichier

La configuration de chaque plateforme se trouve dans le fichier tiapp.xml

Répertoires par plateforme

Le répertoire Ressources peut contenir les répertoires android, iphone, mobileweb, blackberry afin de placer les fichiers spécifiques à chacune de ces plateformes (images, fichiers JS, etc...).

Répertoires par plateforme

Lors de la compilation, le fichier correspondant à la plateforme (s'il existe) est utilisé.

Internationalisation

Que ce soit pour distribuer votre application en plusieurs langues ou une seule, il est conseillé d'utiliser l'i18n avec les projets Titanium.

En effet, c'est un bon moyen de séparer les termes utilisés du code source et facilitera la maintenance de l'application.

Le support multilingue est très simple à implémenter avec Titanium.

Internationalisation

Dans le code, il faut utiliser :Ti.Locale.getString('welcome_message');

ou son alias plus court :L('welcome_message');

Composer l'interface utilisateur

50% ou plus, de votre travail va reposer sur la construction des composants de l'interface utilisateur.

Le reste, consiste à créer la logique de gestion des événements.

La maintenance de votre application sera plus facile si elle est découpée en "petits" composants.

Les windows

Une window est un conteneur de niveau supérieur qui peut contenir d'autres views.

Elle peut être ouverte et fermée.

A l'ouverture, la window et les views enfants sont ajoutées à la pile de rendu de l'application, au-dessus de toutes les windows précédemment ouvertes.

Les views

Les views sont la base de tous les composants de l'interface utilisateur.

Après avoir créer une view, il est important de ne pas oublier de l'ajouter à son view parent ou à une window, sinon elle ne s'affichera pas.

Les événements

La liste des événements déclenché par les objets Titanium est différente en fonction de ceux-ci, il est donc conseillé de consulter la documentation.

Les événements peuvent aussi être utilisés pour communiquer entre différente partie de l'application ou module CommonJS.

Les événements

Pour déclencher un événement personnalisé, on utilise la fonction Ti.App.fireEvent() :

var dbCount = 15;

Ti.App.fireEvent('myApp:saveDB', {

count: dbCount

});

Les événements

On intercepte ensuite l'événement avec Ti.App.addEventListener() :

Ti.App.addEventListener('App:saveDB',

function(e) {

alert(e.count + ' éléments sauvés');

}

);

L'objet XMLHTTPRequest

Dans un navigateur Web, les requêtes Ajax sont relayées à l'objet XMLHTTPRequest :

L'objet Titanium HTTPClient

Ti.Network.HTTPClient implémente la spécification XHR (XMLHTTPRequest).

C'est une interface client HTTP de bas niveau avec support de tous les "verbes" HTTP (GET, POST, PUT, DELETE, etc).

La façon d'utiliser XHR devrait être familière aux développeurs Web utilisant Ajax.

JSON en tant que format d'échange

JSON est recommandé comme format de transport de données pour Titanium Mobile.

Il est très simple de sérialiser les données de réponse :

JSON.parse()

Convertit un string vers un objet JavaScriptJSON.stringify()

Convertit un objet JavaScript vers un string

Framework AlloyPrésentation du framework MVC Alloy

Introduction

Le framework Alloy est un nouveau framework d'Appcelerator, conçu pour développer rapidement des applications Titanium de qualité.

Il est basé sur l'architecture MVC et contient un support intégré pour Backbone.js et Underscore.js

Modèle-Vue-Contrôleur

Alloy utilise une structure model-view-controller (MVC) pour séparer l'application en3 composants différents :

● Les modèles● Les vues● Les contrôleurs

Les Modèles

Les modèles fournissent la logique métier, contiennent les règles, les données et l'état de l'application.

Les modèles sont spécifiés avec des fichiers JavaScript qui fournissent un schéma de la table, la configuration de l'adaptateur et de la logique.

Les Vues

Les vues fournissent les composants de l'interface graphique pour l'utilisateur ou permet à l'utilisateur d'interagir avec les données du modèle.

Les vues sont construites à partir des composants graphiques du SDK Titanium et définies à l'aide de balises XML et de feuilles de style Titanium Style Sheets (.tss).

Les Contrôleurs

Les contrôleurs fournissent le ciment entre les composants du modèle et la vue sous la forme d'une logique d'application.

Les contrôleurs Alloy ont généralement une relation directe avec les vues.

Les contrôleurs ont accès à tous les éléments de la vue et peuvent profiter des événements de l'API Backbone.js.

Avantage du MVC

Un avantage du MVC est la possibilité de réutiliser le code en séparant la fonctionnalité.

Par exemple, vous pouvez avoir des vues spécifiques pour les différents terminaux, tout en gardant le code du contrôleur relativement le même, et les données du modèle inchangées.

Backbone.js

Backbone.js est un framework MVC léger, à l'origine créé pour les applications Web.

Alloy : MVC avec Backbone

Les modèles d'Alloy sont construits autour de Backbone.js, profitant des API Model et Collection de celui-ci.

On définit les modèles en JavaScript pour étendre les fonctionnalités des modèles et des collections Backbone.

Underscore.js

Alloy intégre aussi le support de la librairie Underscore.js, qui fournit un ensemble de

fonctions supplémentaires à JavaScript comme par exemple, la manipulation des tableaux.

Structure et conventions

Pour simplifier le développement, Alloy utilise une structure de répertoire et des conventions de nommage pour organiser l'application plutôt que d'utiliser des fichiers de configuration.

Tout dossier ou fichier qui ne respecte pas les conventions suivantes, sont ignorés par Alloy.

Structure et conventions

Par exemple, au moment de la génération, Alloy va chercher les fichiers requis app/views/index.xml et app/controllers/index.js, puis le fichier optionnel de style app/styles/index.tss.

Alloy a besoin de ses fichiers pour créer la vue-contrôleur suivante : Resources/alloy/controllers/index.js.

Structure des répertoires

app

app/config.json

Contient les modèles, vues, contrôleurs et les médias (images, pdf, sons, vidéos, etc)

Configuration du projet Alloy.

Structure des répertoires

app/assets Contient les images et autres fichiers que vous avez besoin de copier dans le répertoire Resources.

Il peut comporter d'autres répertoires comme app/fonts pour les polices.

Structure des répertoires

app/controllers Contient les contrôleurs au format fichier.js correspondant au fichier de la vue app/views/fichier.xml

Structure des répertoires

app/lib

app/migrations

Contient les librairies spécifiques à l'application, la plupart du temps au format CommonJS.

Contient le fichier de migration de la DB au format <DATETIME>_fichier.json

Structure des répertoires

app/models

app/styles

Contient les modèles dans le format fichier.js

Contient les styles des vues au format fichier.tss appliqué au fichier de la vue app/views/fichier.xml

Structure des répertoires

app/themes

app/widgets

Contient les thèmes, avec des styles et médias personnalisés en fonction du thème.

Contient des widgets permettant d'utiliser des composants d'une application Alloy à une autre.

Structure des répertoires

app/views

i18ni18n/fr (exemple)

i18n/en (exemple)

Contient les vues au format fichier.xml correspondant aux fichiersapp/controllers/fichier.js

et app/styles/fichier.tss

Contient les fichiers de langue au format strings.xml

Structure des répertoires

Ressources Contient le projet Titanium généré par Alloy à partir des fichiers présents dans le répertoire app.

Tous les fichiers sont écrasés à chaque fois qu'Alloy génère l'application Titanium.

Notes

Les répertoires lib, migrations, themes et widgets ne sont pas automatiquement créés lors de la création d'un nouveau projet.

Les répertoires migrations et widgets peuvent être créés lorsqu'un composant est généré à partir du menu contextuel.

Les répertoires lib et themes sont à créer manuellement.

Gestion des plateformes

Les controleurs, vues et styles peuvent avoir des fichiers spécifiques pour Android, iOS ou Mobile Web (HTML5).

Il suffit d'ajouter un répertoire android, ios ou mobileweb dans les répertoires controllers, views ou styles.

On peut aussi, utiliser des conditions et attributs dans le code des contrôleurs, vues et styles.

Exemple de structure

app

controllers

android

index.js

index.js

views

ios

index.xml

index.xml

Widgets

Les widgets sont des composants autonomes qui peuvent être facilement intégrés dans les projets Alloy.

Ils ont été conçus comme un moyen de réutiliser le code dans de multiples applications ou pour être utilisés plusieurs fois dans une même application.

Widgets

Les widgets ont leurs propres modèles, vues, contrôleurs, styles et médias et doivent se trouver dans le répertoire app/widgets.

Des widgets sont déjà fournis avec Alloy et il est recommandé de créer ce type de composant pour rendre le plus modulable possible son application et pouvoir réutiliser ceux-ci dans d'autres applications.

Builtins

Alloy contient aussi des utilitaires additionnels utilisés pour simplifier certaines fonctions comme les animations ou la manipulation des variables par exemple.

Ces utilitaires sont appelés des builtins et peuvent être chargés dans le contrôleur.

Utiliser les Builtins

Pour utiliser les builtins, il suffit de les déclarer dans le contrôleur avec le répertoire alloy comme répertoire racine.

Dans cette exemple, la vue courante vibre quand on clique sur le bouton shake :

var animation = require('alloy/animation');$.shake.addEventListener('click', function(e){

animation.shake($.view);});

Installation d'Alloy

Alloy est installé automatiquement à partir du SDK Titanium 3.0

Il est possible de l'installer manuellement, en ligne de commande (exemple sur un Mac OSX ou Linux Ubuntu) :$ sudo npm install -g alloy

Le fichier View

Le fichier view déclare la structure de l'interface graphique.

Cet exemple défini une window avec une image et un label.

Fichier app/views/index.xml<Alloy>

<Window>

<ImageView id="logoImage" onclick="clickImage"/>

<Label id="logoLabel">Cliquer sur le logo Apple</Label>

</Window>

</Alloy>

Le fichier Style

Le fichier style formate et style les composants du fichier view dans un format proche des feuilles de style CSS.

Par exemple, le style suivant définit la couleur de fond de la window, la position, dimensions et couleur du label et position, dimensions et chemin de l'image.

Le fichier Style

Fichier app/styles/index.tss

"Window": {

backgroundColor: "white"

},

"#logoLabel": {

bottom: 20,

width: Ti.UI.SIZE,

height: Ti.UI.SIZE,

color: '#999'

},

"#logoImage": {

image: "/images/apple_logo.jpg",

width: 24,

height: 24,

top: 100

}

Le fichier Controller

Le fichier contrôleur contient la logique de présentation, qui répond à l'entrée de l'utilisateur.

Par exemple, le code suivant crée une boîte de dialogue lorsque l'utilisateur clique sur l'image.

Le fichier ControllerFichier app/controllers/index.js

function clickImage(e) {Titanium.UI.createAlertDialog({

title:'Image View',

message:'Vous avez cliqué !'

}).show();

}

$.index.open();

Le répertoire Asset

Pour que l'image de l'exemple puisse être utilisée, il faut la copier dans le répertoire app/asset/images.

Elle sera copiée dans le répertoire Ressources/images par Alloy durant la compilation.

Compilation et exécution

Avec Titanium Studio, il suffit de cliquer sur le bouton Run et de sélectionner le type de terminal pour lancer la compilation.

Alloy va générer les fichiers Titanium à partir du projet Alloy (contenu du répertoire app) qui seront ensuite compilés par Titanium Studio.

Utilisation des contrôleurs

Tous les éléments de l'interface ayant un attribut id dans une vue sont automatiquement définies et disponibles en tant que propriété préfixé par la variable spéciale $ dans le contrôleur.

Le $ est une référence au contrôleur.

Utilisation des contrôleurs

Fichier app/controllers/index.jsfunction doClick(e) { alert($.label.text);}

$.index.open();

Fichier app/views/index.xml<Alloy>

<Window class="container">

<Label id="label" onClick="doClick">Hello!</Label>

</Window>

</Alloy>

Utilisation des contrôleurs

Dans l'exemple précédant, le préfixe $.label dans le contrôleur est utilisé pour accéder à l'instance de l'objet Ti.UI.Label dans la vue.

Cette référence est utilisée pour accéder directement aux propriétés ou aux méthodes de cet objet.

Par exemple, l'appel de $.label.hide() cache le label de la vue ou vous pouvez modifier le texte du label avec $.label.text.

Utilisation des contrôleurs

Pour accéder à des contrôleurs externes et des vues, utilisez respectivement les méthodes Alloy.createController (pour ouvrir une nouvelle window par exemple) et Controller.getView.

Si l'objet UI du plus haut niveau n'a pas d'identifiant défini (id), la référence utilisée est le nom du contrôleur préfixé par $.

Utilisation des contrôleurs

Mais si un attribut id a été défini, par exemple, <Window id='window'>, le contrôleur a besoin d'utiliser $.window pour accéder à l'objet Window.

$.index ne sera pas défini et l'application renverra une erreur lors de l'appel $.index.open().

Constantes Alloy

Constantes définies par Alloy, à utiliser dans le contrôleur :

OS_IOS

true si la cible de compilation en cours est iOS

OS_ANDROID

true si la cible de compilation en cours est Android

OS_MOBILEWEB

true si la cible de compilation en cours est Mobile Web

Constantes AlloyENV_DEV

true si la cible du compilateur actuel est de compiler pour le développement (en cours d'exécution dans le simulateur ou émulateur)

ENV_TEST

true si la cible du compilateur actuel est de compiler pour les essais sur un appareil

ENV_PRODUCTION

true si la cible du compilateur actuel est de compiler pour la production (exécuté après une installation du paquet)

Utilisation des widgets

Pour utiliser un widget, il faut d'abord l'ajouter en tant que dépendance dans le fichier config.json :

"dependencies": { "com.appcelerator.loading":"1.0"}

Utilisation des widgets

Ensuite, ajoutez-le à une vue dans le projet, en utilisant la balise Require ou Widget (Alloy 1.0) :

<Widget id="loading" src="com.appcelerator.loading"/>

Utilisation des modèles

Avec Alloy, les modèles héritent de la classe Backbone.Model.

Ils contiennent les données interactives et la logique utilisée pour les contrôler et y accéder.

Les modèles sont spécifiés avec les fichiers JavaScript qui fournissent un schéma de la table, la config. de l'adaptateur et la logique pour étendre la classe Backbone.Model

Utilisation des modèles

Les modèles sont automatiquement définis et disponibles dans le scope du contrôleur du fichier JavaScript du même nom.

Le fichier JavaScript exporte une définition de l'objet composé de trois objets différents.

Le premier objet, appelé config, définit le schéma de la table et de l'information de l'adaptateur.

Utilisation des modèles

Les deux autres objets extendModel et extendCollection définissent des fonctions pour étendre, outrepasser ou implémenter les classes Backbone.Model et Backbone.Collection.

Exemple de config. d'un modèleexports.definition = {

config : {

},

extendModel: function(Model) {

_.extend(Model.prototype, {

});

return Model;

},

extendCollection: function(Collection) {

_.extend(Collection.prototype, {

});

return Collection;

}

}

L'objet configconfig: {

"columns": {

"title": "TEXT",

"author": "TEXT"

},

"defaults": {

"title": "-",

"author": "-"

},

"adapter": {

"type": "sql",

"collection_name": "books"

}

}

Resources Alloy

Widget Drawer Menu (Facebook like) :https://github.com/ricardoalcocer/alloy-widget-drawermenu

Widget Tweets View :https://github.com/FokkeZB/nl.fokkezb.tweetsView

Widget Calendrier :https://github.com/hamasyou/titanium_alloy_calendar

Annexes

Ressources

my.appcelerator.com

Ressources

Documentation

Ressources

Github Appcelerator

Autre ressources

Compte Twitter : @timoaSite : http://timoa.com (nouvelle version en cours)

Interfaces mobile : http://pinterest.com/timoa

ProjetJUG MobileSources du projet mobile JUG Mobile

Projet JUG Mobile Titanium

Les sources de l'application JUG Mobile codé en Titanium lors de la 2ème partie se trouve sur Github.

Vous pouvez y contribuer ou le récupérer pour démarrer un projet par exemple.

https://github.com/timoa/JUGMobile_Titanium