Gonzague

Tak suka wanita gemuk ! le blog de Gonzague.

unibox iconDans la série fais le toi même parce que t’arrives pas à trouver ce qui te plaît ou que t’as pas bien cherché je présente le DropBox fait maison !

Ayant un serveur dédié avec 500Go d’espace disque et des fichiers que j’aimerai bien retrouver partout pareil sur mes ordinateurs (musiques, photos -> 50Go) mais qui rentre pas dans les 2Go de DropBox tout en trouvant que ça fait chier de lacher 80€ / an pour 50Go alors qu’on en a 500 qui ne demandent qu’a être remplis je me suis mis au défi de me créer mon propre DropBox basé sur Unison.

Voici un petit tutoriel de comment faire, et au final c’est relativement simple.

1) Qu’est-ce qu’on va faire ?

C’est très simple, on va se servir de notre serveur comme d’un HUB et tous nos ordinateurs vont verifier les changements sur le serveur et télécharger, envoyer, effacer les fichiers nécessaires. On pourrait faire du dossier cas par cas, mais pour faire comme DropBox et rendre les choses plus simple, on va uniquement synchroniser un seul dossier histoire de savoir où sont les choses qu’on synchronise et pour être sûr qu’on oubliera pas.

2) Les pré-requis.

  • Un serveur dédié avec un accès SSH sans mot de passe
  • Unison installé sur le serveur dédié ainsi que sur chacun des clients (Attention il faut la version ligne de commande sur les clients, pas uniquement l’interface)
  • Et c’est tout…

3) Et ensuite ?

Ensuite deux solutions, la solutions de fainéant et facile, faire un script sur chacun des clients du style

/usr/bin/unison cheminLocalDuDossierASynchro ssh://loginSsh@urlserver//cheminDelaRacineDuServeur -fastcheck true -batch -ui text -perms 0 -times -rsync

Coller un cronjob la dessus et en voiture Simone… Le transfers de fichier se fera en utilisant rsync ce qui signifie s’il y a des modifications sur les fichiers, seules les modifications seront envoyées/téléchargées. Donc on gagne en temps de synchro. C’est bien mais je trouve que ça manque de classe.

Donc on va se diriger vers la deuxième méthode qui consiste à créer un petit programme en Java dans mon cas qui va écouter le dossier sur mon ordinateur pour être au courant dès qu’un changement à lieu. Si changement, on lance la synchronisation, si une synchronisation est déjà en cours, on dis a notre programme de relancer une synchronisation à la suite de la courante pour être sûr que tout est à jour sur le serveur.

On va également faire une synchronisation à intervals réguliers (toutes les 3 minutes ici) et on est bon. On colle tout ça dans la barre de menu et on a notre propre Dropbox en quelques heures. Pour la classe on rend le tout configurable au cas où le dossier à synchroniser n’est pas le même sur chacun des ordis. Une petite icône et c’est parti

Voilà j’ai exposé le concept et fait une petite application en alpha qui fait ce qu’il faut faire sans trop de bugs. Pour l’instant ça marche sur OS X et ça devrait marcher sur Linux, Je mettrais ça en téléchargement quand ça sera vraiment prêt !

unibox preferences unibox preferences

Intégrer une application Java à Mac OS X (suite)

Samedi 26 février 2011 à 12:03

J’avais promis la suite de lendemain, j’ai pris un peu de retard !

Intégrer une application Java à Mac OS X

2) Post-développement

2.1) Créer l’icône

Heureusement, Mac OS fournit quand même des outils plutôt pratique pour faire les choses assez rapidement et simplement. Pour créer une icône il y  a un logiciel qui se nomme “Icon Composer”. Les fichiers icône (.icns) sous OS X sont en fait plusieurs images de différentes tailles pour toutes les représentations possibles telles que dans le finder, dans le dock etc. Les icônes ont une taille maximum de 512*512 et on peut choisir des images différentes pour chaque palier de zoom : 256*256, 128*128, 32*32, 16*16. Un simple glisser déposer suffit.

tehhis integration java os x dossier blog wefrag

2.2) Créer l’application

Sous OS X les application sont sous un format de fichier .app qui est en fait un simple dossier contenant tout ce dont l’application à besoin pour fonctionner. Pour les applications java il y a une fois de plus un utilitaire fourni par Apple sous le nom de “Jar Bundler”. C’est également relativement simple.

tehhis integration java os x dossier blog wefrag

Ici on choisi l’icône ainsi que la Main Class qui, il suffit de choisir le .jar de notre application. notez également la possibilité d’utiliser la barre de menu Mac OS au cas où votre application ait un menu type “Fichier Edition … …”

tehhis integration java os x dossier blog wefrag

Ici on ajoute toutes les ressources supplémentaires nécessaires pour l’application, les librairies par exemple.

tehhis integration java os x dossier blog wefrag

Ici sont les informations diverses de l’application, quelques options de la VM Java.

On a plus qu’à cliquer sur “Create Application” et sauvegarder là où on veut et nous avons notre application .app fonctionnelle.

2.3) Créer un nouveau type de fichier (bundle)

Mon application pour fonctionner à besoin de plusieurs fichiers pour une sauvegarde. Donc je vais avoir besoin de créer ce qu’on appelle un bundle. Tout comme les fichiers .app des applications il s’agit simplement d’un dossier contenant x documents mais qui apparaîtra en tant qu’un seul et unique fichier au yeux de l’utilisateur.

Pour cela, il faut faire un clic droit sur l’application fraîchement créée et “Show Package Contents” et ouvrir le fichier info.plist

tehhis integration java os x dossier blog wefrag

Il suffit d’ajouter les lignes nécessaires pour obtenir quelque chose comme ceci.

tehhis integration java os x dossier blog wefrag

On peut également spécifier une icône particulière pour notre nouveau type de bundle. (tehhisFile ici) et le placer dans le dossier ressources qui se trouve dans notre application.

Et voilà on est bon, tous les dossiers qui auront un nom finissant par .tehhis (dans mon cas) apparaîtrons comme un seul et unique fichier.

tehhis integration java os x dossier blog wefrag

Et donc lorsque l’on lancera ce type de fichier, cela ouvrira notre application et lancera l’evenement handleOpenFile de notre Mac Handler (voir partie 1 du dossier) une fois celui-ci initialisé.

Nous avons donc une application qui apparaît et se comporte comme une application native, juste les fouineurs pourront s’en rendre compte en fouillant dans le bundle .app de notre application.

Intégrer une application Java à Mac OS X

Vendredi 18 février 2011 à 16:44

Ces jours-ci je bosse sur une application qui qui doit être développée rapidement (donc pas le temps d’apprendre cocoa/obj-c) et qui ne sera utilisée que sur Mac OS  pour la boite que je suis en train de monter d’ailleurs, je reparlerais de la boite plus tard, je pense que ça intéressera certains d’entre vous.

Histoire de me faire un peu plaisir pour satisfaire mon amour dévoué à Mac OS X je me suis dis que j’allais essayer de bien intégrer l’application à Mac OS. Le problème c’est qu’il faut chercher un peu partout sur le net et c’est pas tout le temps super clair. Donc je vais regrouper tout ça ici ou au moins ce que j’ai utilisé. Car mine de rien, il y a tout un tas de petites choses qui font qu’on aime une application Mac OS.

Je vais divisé cet article en deux parties, ce qu’on peut faire pendant le développement et ensuite ce qu’on peut faire une fois le développement fini.

1) Développement

Ok, alors les habitués de Mac OS auront sûrement remarqué que par exemple les raccourcis de base sont en général tous les même quelque soit les applications tel que cmd + , pour les préférences ou le fameux cmd + q.

Également le fait de pouvoir dropper un fichier sur l’icône du Dock ou encore les notifications Growl. Tout ça c’est possible avec Java !

1.1) Le MacHandler

Bon, j’appelle ça le MacHandler, c’est pas le nom officiel. Il s’agit  d’une classe avec laquelle on va utiliser tous les événements spécifiques à Mac OS , ce qui se passe lorsqu’un fichier est lâché sur le Dock (j’y reviendrais dans la seconde partie  du dossier car il y a d’autres petits trucs à faire), lorsque les préférences sont ouvertes, lorsqu’on clique sur l’icône du dock alors que l’application est déjà lancée etc…

Je me permets un vieux copié collé de ce que j’ai déjà fait car le nom des méthodes est relativement explicite:

public class MacHandler {

public MacHandler() {
// create an instance of the mac osx Application class
Application theApplication = new Application();

// create an instance of our DockBarAdapter class (see source code below)
DockBarAdapter dockBarAdapter = new DockBarAdapter(this);
theApplication.setEnabledPreferencesMenu(true);

// add our adapter as a listener on the application object
theApplication.addApplicationListener(dockBarAdapter);

}

// our "callback" method. this method is called by the DockBarAdapter
// when a "handleOpenFile" event is received.
public void handleOpenFileEvent(ApplicationEvent e) {

}

public void handleQuit(ApplicationEvent e) {
System.exit(0);
}

public void handleReOpenApplication(ApplicationEvent e) {

}

public void handlePreferences(ApplicationEvent e){

}
}

/**
* Extend the Mac OS X ApplicationAdapter class, and just implement the
* handleOpenFile() method so we can handle drag and drop events.
*/
class DockBarAdapter extends ApplicationAdapter {

private MacHandler handler;
// the main class passes a reference to itself to us when we are constructed

public DockBarAdapter(MacHandler handler) {
this.handler = handler;
}

// this is the method that is called when a drag and drop event is received
// by the Application, and passed to us. In turn, we call back to the main
// class to let it know this event was received so it can deal with the
// event.
@Override
public void handleOpenFile(ApplicationEvent e) {
handler.handleOpenFileEvent(e);
}

@Override
public void handleQuit(ApplicationEvent e) {
handler.handleQuit(e);
}

@Override
public void handleReOpenApplication(ApplicationEvent e) {
handler.handleReOpenApplication(e);
}

@Override
public void handlePreferences(ApplicationEvent e) {

handler.handlePreferences(e);
}
}

1.2) Growl

Tout utilisateur de Mac trouvera les notifications fort pratique et en général est content lorsqu’une application les utilise. Ici c’est du 100% fait maison avec une méthode un peu bourrine… Mais qui marche.

Le fonctionnement est relativement simple, on a un fichier AppleScript (.scpt) inclus dans le .jar et une classe qui lors de sa construction extrairera ce script dans un dossier temporaire e l’éxecutera  au besoin

La classe ressemble à ça:

public class GrowlNotification extends Growl {

File file;

public GrowlNotification(){
//lorsque on initialise les notifications, on extrait un fichier applescript du .jar et on l'execute quand on en a besoin.
try {
URL script = getClass().getResource("/applescript/notification.scpt");
script.openStream();

//model.Model.tmpDir est un dossier de fichier temporaires lors de l'execution de mon appli à définir vous même
File f = new File(model.Model.tmpDir+"/notification.scpt");
f.createNewFile();
Tools.copyCompletely(script.openStream(), new FileOutputStream(f)); //ici est une methode pour extraire un fichier du package
file = f;
file.deleteOnExit(); //on supprime le fichier quand on ferme l'appli
} catch (IOException ex) {
Logger.getLogger(GrowlNotification.class.getName()).log(Level.SEVERE, null, ex);
}
}

public void showNotification(String message, String title) {
try {
String[] cmd = new String[4];

cmd[0] = “osascript”;
cmd[1] = file.getPath();
cmd[2] = title;
cmd[3] = message;

Process proc = Runtime.getRuntime().exec(cmd);
} catch (IOException ex) {
Logger.getLogger(GrowlNotification.class.getName()).log(Level.SEVERE, null, ex);
}
}
}

1.3) L’interface

Je trouve que c’est ce qui manque le plus à java sur Mac, c’est très (trop) basique, heureusement qu’il y a un petit génie qui a créé tout ce dont on a besoin ! Ce mec nous a donc pondue une librairie qui regroupe presque tout ce dont on peut avoir besoin !

C’est disponible ici : Mac Widgets for Java et ça permet de faire des choses dans ce genre:

mac widgets blog wefrag mac widgets blog wefrag mac widgets blog wefrag mac widgets blog wefrag mac widgets blog wefrag mac widgets blog wefrag mac widgets blog wefrag mac widgets blog wefrag

Mais ce petit gars ne s’est pas arrêté là sinon ça aurait été trop simple, en fouillant sur son blog super intéressant on tombe sur d’autres trucs pour pousser encore plus l’intégration tels que:

faire des barre de header à la iTunes , faire des listes au look Apple bref que du bon.

D’ailleurs pour la petite histoire ce mec à été engagé par Apple.

En parlant d’Apple ils fournissent quand même un peu d’aide à cette adresse (où il y a un exemple pour les applescripts beaucoup moins bourrin que moi)

1.4) Les system properties

il existe tout un tas de system properties qui permettent de créer des éléments d’interface qui permettent d’éviter quelques sueurs sur des trucs cons. Ca se trouve ici.

En bref, des boutons (plein), des champs de recherches, la décoration des fenêtres, des dropdown etc etc y en a pour tout le monde. C’est très facile à mettre en place et c’est du plus bel effet.

Bon, je comptais pas faire ce dossier en deux parties, mais là il est un peu tard et je me lève tôt demain donc tout ce qui se passe une fois qu’on a fini l’application arrive demain  presque sans fautes !

Intégrer une application Java à Mac OS X (suite)

[FTPix] Version 2.4

Dimanche 16 janvier 2011 à 11:50

Après presque 6 mois sans nouvelles de la version desktop, j’en sors enfin une nouvelle. Pas énormément de changements apparents, surtout de l’optimisation:

  • Nouveau système de sauvegarde (encore une fois oui) beaucoup + rapide et sécurisé. La conversion de la sauvegarde se fera au lancement de l’application
  • J’ai supprimé quelques effets inutiles qui ne faisait que bouffer de la ressource CPU pour pas grand chose.
  • Optimisations diverses

Les vrais nouveautés parce qu’il y en a quand même:

  • La possibilité d’associer des tags d’images aux galeries. en associant un ou plusieurs tags à une galerie toutes les images déjà existantes contenant un des tags indiqués seront automatiquement ajouté à cette galerie mais aussi dès qu’on modifie les tags d’une image si une galerie est liée a un de ces tags, cette image y sera ajouté (ça n’uploadera pas la galerie pour autant).

  • Autre nouveauté qui sera encore en beta pour le moment et l’ajout d’un mode console à l’application qui permet d’utiliser FTPix en ligne de commande. Le détail des commandes est dans le fichier readme. Quand j’aurais le temps je montrerais quelques exemples de ce qu’on peut faire avec ça.

Je devrais également publier bientôt une mise à jour de la version Android de FTPix.

Bisous.

[FTPix, check that later] HALP ~

Mardi 19 octobre 2010 à 16:58

<maxkarting>

Bonjour bonjour,

Pour ceux qui me suivent depuis quelques temps, je parle beaucoup de mes projets personnels avec des échecs/abandons (smart task, colorful reader, xywriter et un de + dont j’ai même pas pris la peine de parler ici) et des trucs plus réussis (FTPix, check that later) et s’ils sont plus réussi c’est qu’ils me tiennent pas mal à coeur et c’est aussi grâce à wefrag car pas mal de commentaires m’ont poussés à continuer

Voir des commentaires du genre:

Bravo pour ton logiciel, et ton travail fourni. Je vais probablement me lancer dans la même aventure plus tard, en tout cas j’admire la performance. Tu contribues à rendre Internet meilleur, et ça c’est bien[…]

ça fait vraiment plaisir et ca donne du boost pour avancer !

Cependant j’ai l’impression d’être arrivé au bout de ce que je peux faire seul j’ai vraiment l’impression de stagner, d’avoir un paquet de choses à faire et du coup de ne pas savoir par où commencer pour au final ne rien faire. Ceci combiné à mon nouveau taff bien chargé c’est loin d’être évident et j’ai l’impression de ne pas pouvoir surmonter ce cap.

Ce cap où on a plein d’idée mais on arrive pas à les mettre en place pour les raisons pré-citées, c’est réellement frustrant.

C’est pourquoi j’en appelle aux personnes qui lisent ce blog. Pour pousser ces deux projets, j’aimerais monter une petite équipe de 2-3 personne par projet (moi inclus)  pour m’aider à finir ce qui est à finir et a pousser les concepts un peu plus loin.

Je n’ai pas uniquement besoin de personne sachant coder, des personnes pouvant aider à faire connaître ces projets une fois plus mature ou encore des personnes désireuses d’apprendre (comme pour le développement Android par exemple car je sais qu’il y a des intéressés par le sujet).

Voici en gros (j’ai aussi une liste détaillé) ce que j’ai en tête pour le moment et ce sur quoi je recherche éventuellement du monde

FTPix:

  • Faire une version web de FTPix, beaucoup plus simple pour consulter les images sur son FTP (voir uploader plus tard) en PHP
  • Améliorer la version Android
  • Faire connaître le logiciel
  • Améliorer la version desktop pour les suicidaires (Le code est véritablement bordélique, c’est pour ça que je préfère m’en occuper moi même)

Check That later:

  • Finir le site autant sur le contenu (page d’accueil et autre) que sur le code du site (PHP)
  • Finir l’extensions Firefox en priorité.
  • Améliorer les extensions existantes
  • Finir l’application android.
  • Faire une version mobile du site (CSS / PHP / HTML) la structure du site existant déjà, il s’agit en gros de créer un thème sur ce que j’ai déjà fait
  • Idem que FTPix, faire connaître le site.

Evidemment cela ne représente pas une liste fermée de ce qu’il reste à faire. Je suis ouvert à la critique et suggestion d’idées.

Toute personne vraiment motivée et intéressée par ces projets est évidemment le bienvenue.

Malheureusement je n’ai rien à offrir pour les bonnes âmes qui décideront de m’aider à part un nom sur le(s).  Ca peut toujours ajouter une ligne sur un CV de jeune diplômé pour un petit coup de pouce lors de la recherche du premier emploi et peut être la gloire avec des putes et des bols de coke pour plus tard.

Je pense et j’espère que je n’ai rien oublié.

Ca fait un peu post de désespéré mais tant pis, j’assume.

help

</maxkarting>

1) Menus

Aujourd’hui on va commencer par les menus, ceux très pratiques qui apparaissent quand on appuie sur la touche menu du téléphone. Ca évite d’encombrer l’UI avec des choses pas forcément utile 100% du temps.

Avec android c’est vraiment très simple à mettre en place. File > new > other > Android xml file et choisir menu dans la liste des boutons radios.

Cliquer sur Add pour ajouter une nouvelle entrée et  remplir les champs comme demandé, ils ne sont pas tous obligatoire.

Une fois ce menu créé, il faut assigner à notre Activity ce menu lorsqu’on appuie sur la touche:

      public boolean onCreateOptionsMenu(Menu menu) {
		MenuInflater inflater = getMenuInflater();
		inflater.inflate(R.menu.site_list_menu, menu); //avec l'id de notre menu
		return true;
	}

Ensuite il faut lier des événement à chacun de ces items:

@Override
	public boolean onOptionsItemSelected(MenuItem item) {
		switch (item.getItemId()) {
		// We have only one menu option
		case R.id.menu_add: //id qu'on a spécifé dans l'éditeur de menu.
			addLink();
			break;
		case R.id.menu_refresh:
			refresh();
			break;
		case R.id.menu_logout:
			finish();
			break;
		}
		return true;
	}

Et voilà ! on a un beau menu

2) Preferences

Pour créer des préférences c’est très simple: File > new > other > Android xml file  (oui encore) et choisir preferences dans la liste des boutons radios.

Ensuite on devrait arriver sur une fenêtre de ce style :

Ca va relativement droit au but, on clic sur add pour ajouter des catégories, des fenêtres etc…  On peut choisir le type de préférence souhaité (checkbox, text…).

Ensuite il faut créer une classe Preferences quelque part dans votre projet et la déclarer dans l’androidManifest.xml (voir plus bas). Cette classe est très simple:

public class Preferences extends PreferenceActivity {

	/** Called when the activity is first created. */
	@Override
	public void onCreate(Bundle savedInstanceState) {
	    super.onCreate(savedInstanceState);
	    addPreferencesFromResource(R.xml.preferences);
	}
}

et on y ajoutera rien de plus.

Ensuite il faut lancer la fenêtre des préférences depuis notre Activity principale (exemple prit sur FTPix car je n’ai pas de préférences dans checkthatlater):

//code à placer dans le listener du bouton qui doit lancer les préférences.
Intent i = new Intent(FTPix.this, Preferences.class);
a.startActivity(i); //on considèrera que "a" est de classe Activity

3) Lancer un nouvel écran

De même ici, pas de réel problème c’est relativement simple. On considèrera que “a” est de classe Activity le deuxieme paramètre est la classe de la fenêtre cible

Intent intent = new Intent(a.getApplicationContext(), SiteList.class);
intent.putExtra("apiSession", result); //on transmet le paramètre de nom "apiSession"
a.startActivity(intent);

Ensuite il dans le onCreate(Bundle savedInstanceState) nouvelle Activity, pour récupérer les paramètres:

Bundle extras = getIntent().getExtras();
if (extras != null) {
	apiSession = extras.getString("apiSession");
}else{ //uniquement si les paramètres son indispensable, si on à pas le paramètre on ferme l'écran et retour au précédent.
	finish();
}

4) androidManifest.xml

L’android manifest est la fichier qui regroupe toutes les caractéristiques de notre application. Il faut absolument y ajouter toutes les Activity qu’on utilisera (dans l’onglet application puis dans application nodes), on peut également définir toutes sortes de propriétés comme les résolutions d’écran supportées (onlget manifest > manifest extras) ainsi que les permissions dans l’onglet permission.

Petit truc pour éviter de perdre du temps bêtement, déclarer bien la permission INTERNET si votre application en à besoin, sinon rien ne marchera. J’ai perdu quelques heures la dessus sur FTPix, ça fait bien rager.

Avec les 3 premiers articles on peut déjà faire quelque chose de sympa. Voici ce à quoi ressemble Check that later après quelques heures de taff sans trop de prises de têtes:

Bon, ça tourne sur émulateur d’où l’impression de lenteur, sinon c’est plutôt rapide.

YouTube Preview Image

[FTPix] Enfin sur l’android market

Samedi 18 septembre 2010 à 19:02

Longtemps après avoir commencé le développement, FTPix est enfin sur l’android market ! Il doit rester quelques bugs certes, mais ça marche plutôt bien.

Il suffit de rechercher FTPix sur le market pour le trouver. Bien évidemment, c’est gratuit ! Mais les donations sont toujours le bienvenues :)

qrcode

ou : market://search?q=com.android.ftpix

Demain j’attaque le nouvel article sur le dev android.

Android dev #2: Premier écran, première action.

Jeudi 16 septembre 2010 à 8:57

Dossier Android dev:

Maintenant que notre projet est structuré on va pouvoir vraiment commencer.

1)  Premier écran

Pour faire noter premier écran on va utiliser l’éditeur WYSIWYG fourni avec le plug-in pour éclipse. pourquoi se faire chier à faire du xml quand les outils sont dispos.
La fenêtre de construction des écran ressemble à ça:

De quoi est composé un écran, d’un Layout principal et des éléments enfants (qui peuvent être d’autres layouts). Je déconseille fortement l’utilisation de l’AbsoluteLayout même Google le déconseille. Ici, je vais utiliser le RelativeLayout que j’aime bien.

Pour ajouter un élément, on le glisse de la palette vers l’aperçu ensuite on le sélectionne pour éditer ses propriété. Petit conseil donnez des ID qui veulent dire quelque chose ça sera utile pour la suite.

On construit peu à peu notre écran pour arriver à ça (relativement simple pour l’instant j’ai pas fait un truc de ouf pour pouvoir sortir le dossier plus tôt):

Ensuite on va ouvrir le fichier com.checkthatlater.android.SignIn.java qui devrait ressembler à ça:

 public class SignIn extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //on change le main en login parce qu'on est des rebels
        setContentView(R.layout.login); // ici on défini quel écran on va utiliser pour notre Activity
    }
}

Les Activity sont des classes très importantes pour une application android. Dans Check that later on va en définir une par écran.

Il faut donc ajouter une action à ce joli bouton “Sign In“. Pour ajouter une action, il suffit de lui attribuer un listener, ce qu’on va faire de ce pas:

public class SignIn extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.login);

        addListeners(); //on va créer une méthode dédiée aux listeners histoire de centraliser ça pour cette activité.
    }

    public void logIn(){
    };

    public void addListeners(){
    	Button signIn = (Button) findViewById(R.id.LoginButton);
    	signIn.setOnClickListener(new OnClickListener() {
			@Override
			public void onClick(View v) {
				logIn();
			}
		});
    }
}

Hop, des que notre bouton sera “touché” ça lancera la methode logIn() qui ne fait rien pour le moment.

Notez la portion de code:

Button signIn = (Button) findViewById(R.id.LoginButton);

Je vous avez dit plus tôt d’attribuer des ID significatif à vos éléments d’UI car avec la méthode findViewById() on peut les retrouver très facilement et faire ce qu’on veut avec.

Et notre methode logIn() on en fait quoi ? On va la laisser de coté pour l’instant.

2) Première action

Dans Android il y a un Thread dédié pour l’interface (comme avec Swing en java) il est donc relativement déconseillé d’y faire des traitements longs qui feront freezer l’UI. On pourrait utiliser le classique

new Thread(new Runnable() {
	@Override
	public void run() {
		//faire quelque chose
	}
	}).start();

de fainéant mais non. Google nous fourni une classe géniale qui s’appelle AsyncTask. On va donc ouvrir notre fichier LogIn.java dans note package d’actions et lui faire extend la classe AsyncTask

public class LogIn extends AsyncTask< Object, Object, Object >
{
	private Activity a; // rajouté par moi même ça va être utile.

	public LogIn(Activity a){
		this.a = a;
	}

	@Override
	protected Object doInBackground(Object... params) {

	}
}

On peut y voir 3 type Object qui viennent de l’AsyncTask, Le premier est le type du paramètre que l’on passera lors de l’exécution notre tache de fond, le second est le type du paramètre que l’on passera lorsqu’on mettra à jour l’UI dans notre tache de fond et le dernier le type que retournera notre doInBackground.
Dans mon cas ce sera String, Object (car je ne m’en sers pas) et Integer

Cette classe dispose de 3 autres méthodes très intéressantes onPreExecute(), onPostExecute() et onProgressUpdate() leurs nom sont assez explicites et chose importante ces trois méthodes se déroulent dans le Thread UI non dans le Thread dédié à notre tâche. Pour mon cas cela donne ceci.

public class LogIn extends AsyncTask{
	private Activity a;
	private final int ERROR = -1, SUCCESS = 1, FAIL = 0;
	private ProgressDialog dialog;

	public LogIn(Activity a){
		this.a = a;
	}

	@Override
	protected Integer doInBackground(String... params) {
		String data = "paramètres pour ma requête";
		try {
			String result = URLTools.post("http://urlversmonsite", data);
			return Integer.parseInt(result);
		} catch (IOException e) {
			e.printStackTrace();
			return ERROR;
		}
	}

	@Override
	protected void onPreExecute() {
		super.onPreExecute();
		dialog = ProgressDialog.show(a, "Please wait...", "Signing in...", true);
	}

	@Override
	protected void onPostExecute(Integer result) {
		dialog.dismiss();
		super.onPostExecute(result);
		switch(result){
			case ERROR:
				DialogTools.ok("Can't connect to server", a);
				break;
			case SUCCESS:
				DialogTools.ok("Log in success", a);
				//TODO Launch link list activity
				break;
			case FAIL:
				DialogTools.ok("Wrong login/password", a);
				break;
		}
	}

}

Ici, je n’ai pas besoin de la methode onProgressUpdate:

  • onPreExecute(): j’initialise un indeterminate dialog que j’affiche. Il faut savoir qu’un dialog faisant parti de l’UI ne peut être qu’appelé depuis le thread UI.
  • onPostExecute(): je récupère le résultat de ma tâche de fond avec le dialog correspondant.
  • doInBackground(): Tache de fond, je me connecte à mon serveur, lis le résultat (avec une méthode de mes URLTools) et le retourne

Petite note sur la méthode onProgressUpdate(): Cette méthode est appelée quand on appelle la méthode publishProgress() et là où cette c’est génial ce que cette méthode ( publishProgress() ) ne peux être qu’appelée dans le thread de fond donc dans doInBackground. On à donc une façon ultra simple et intuitive de faire une tâche de fond tout en mettant à jour  l’UI !

Il ne nous donc reste plus qu’a implémenter la methode logIn() de notre Activity (nous ne somme plus dans la l’AsyncTask maintenant) :

public void logIn(){
    	EditText user = (EditText) findViewById(R.id.LoginField); // récuperer les text fields
    	EditText password = (EditText) findViewById(R.id.PasswordField); 

    	new LogIn(this).execute(user.getEditableText().toString(), password.getEditableText().toString());
    };

Lancer une AsyncTask est simple, on construit en construit une nouvelle instance et on appelle la méthode execute() avec les paramètres nécessaires.

On lance notre appli et on regarde si tout marche bien.

android dev

Et voila, ça fonctionne, pas de prises de têtes de fou, tout est super simple !

Vous avec donc tout ce qu’il faut ou presque pour faire une application !

Prochaine étape je parlerais des préférences ainsi que comment lancer une nouvelle activité (écran) et lui passer des paramètres puis du manifest pour les permissions accordées à l’application (Ce dernier point si vous voulez commencer le dev de votre app maintenant est très facilement trouvable sur le net).

Android dev #1: Définir son application

Mardi 14 septembre 2010 à 14:56

Comme dit dans les commentaires du précédant, je vais faire un petit dossier en même temps que je développerais l’application android pour checkthatlater pour ceux qui sont intéressé par le dev android mais qui ne savent pas trop par où commencer. Petite préface: Tout ce dossier n’est pas ce qu’il faut  absolument faire, mais plutôt la façon dont je vois les choses et ce que j’ai retenu en développant FTPix pour cette plateforme et ce que je vais appliquer pour le dev de check that later qui sera une application relativement simple.  On verra à la fin si c’était une si bonne idée. En écrivant ceci je considère que vous savez développer un minimum en java, avez installé le SDK/Eclipse et les plug-ins android pour Eclipse qui permettent de gagner un temps fou.

1) Définir son application

Une des phases les plus importantes évidemment. Se poser un tas de question, savoir si l’application vaut la peine d’être développée et surtout de se rendre compte si elle est réalisable parce qu’on a bien l’air con une fois qu’on a passé xxx heures à faire son bazar et qu’au final on se dit qu’on va jamais y arriver… Pour cela il faut s’imaginer les actions importantes que fera l’application ainsi que les écran devant lesquels l’utilisateur sera confronté. Dans le cas de check that later il y aura 5 actions principales:

  • Se connecter avec son compte
  • S’enregistrer
  • rappatrier les liens lu/non lu/ favoris à partir du serveur où le site check that later se trouve
  • modifier un lien en lu/ajouter favoris/enlever favoris
  • Ajouter un nouveau lien

Donc relativement simple. J’ai groupé plusieurs choses dans les deux dernières actions car c’est vraiment très similaire. Juste quelques variables changeront… Pour les écran, l’idéal est de les dessiner ou représenter avec un logiciel quelconque. Nous avons donc ceci (la dernière a un peu merdee mais c’est un écran comme les autres):

android devclick

Donc 4 écrans:

  • Le login
  • Les listes
  • Une web view pour visiter un des liens avec un bouton pour le mettre vu ou en favori
  • Le dernier est un peu particulier. L’application va apparaître dans le menu de partage lorsqu’on fait un long clic sur un lien (je parlerais plus tard de comment avoir son application dans ces menus) donc très simple.

Une fois cette étape faite On peut lancer Eclipse plus sereinement…

2) L’organisation des fichiers

Pour commencer il faut créer un nouveau projet android (File>new>other>android>android project):

Pour l’Activity mettez le nom de la première fenêtre qui apparaîtra dans votre app, on reparlera des Activities plus tard. Une application android a une organisation des fichiers propre a elle même. En créant un nouveau projet vous devrez tomber face à un truc de ce genre (sans le dossier Extras):

android dev

Nous avons donc:

  • src: qui contiendra vos fichiers source (java)
  • gen: Ce sont les fichiers généré par le plug-in android pour Eclipse. On ne touchera pas au contenu de celui-la
  • Android 2.1: L’api utilisée par notre application: On n’y touchera pas également
  • assets: Je sais pas trop ce que c’est mais il n’y a pas besoin d’y mettre le nez
  • res: Dossier très important, il contient toutes les ressources hors java qui seront utilisées par l’application: Drawable: les images, layout: les écrans, menu: les menus lorsqu’on presse la touche menu du téléphone, values est un fourre tout à constantes et  xml: les autres fichiers xml comme la hierarchie des préférences dans FTPix par exemple
  • AndroidManifest.xml C’est ici qu’on définira la version de l’appli le nom affiché, les activités (on y viendra plus tard), les authorisation de l’appli (la liste de chose qu’on peut voir lorsqu’on installe une application comme acces internet, acces vibreur etc…)
  • default.properties porte assez bien son nom, on y touchera pas.

3) Organiser SES propres fichiers

Ici c’est chacun fait comme il le souhaite mais voici comment je compte faire pour check that later. Je pense qu’il est nécessaire de définir des modèles (voir structure MVC d’un application). Les plus attentifs auront remarqué que “liens” et “compte” était en gras dans la liste des actions. On va donc définir deux modèles pour l’instant (d’autres pourront s’ajouter plus tard lors de la conception de l’application, mais je pense qu’il vaut mieux tout définir dès que possible). Donc dans mon package src, je vais créer un nouveau package models ainsi que deux sous-packages link et user (je mets en anglais parce que c’est plus cool) Ensuite j’ai parlé d’actions plus tôt. on va mettre ça la dedans également. donc sous src, un nouveau package actions et des fichiers java pour chacune des actions: Register.java, Login.java, FetchLinks.java, ModifiyLink.java et AddLink.java Un dernier qu’on va appeller tools, sous src également. Là dedans on va regrouper toutes les fonctions récurrentes qu’on a pas envie de copier/coller recoder à chaque fois, j’ai pas d’idée encore précise mais dans mon cas ce sera des choses du genre lire le contenu d’une url, afficher des dialogues etc… Ensuite on va mettre nos écrans dans le dossier res/layout/ avec les noms montrés plus tôt sur la capture d’écran. File> New > other > android>android XML file:

La magie du plugin android intervient dans ce genre de situation, en choisissant le type de ressource il va mettre le fichier là où il le faut On a donc quelque chose dans le genre: ( j’ai rajouté register.xml dans les layouts, j’expliquerais la prochaine fois)

Plus tard viendra l’explication sur les dossiers drawable-hdpi/mdpi/ldpi, un des bonnes idée d’android. Mais si vous voule absolument commencer à dev, mettez vos fichiers dans drawable-mdpi Donc voilà on est prêt à se lancer dans le développement ! Avec une bonne base il y a moyen de gagner énormément de temps, on verra ça dans la suite sur quoi on a gagné du temps. La suite dès que j’ai commencé à travailler réellement sur la chose !

[FTPix android] Jour 3.

Dimanche 12 septembre 2010 à 17:11

La fin de mon week-end de trois jours, où je m’étais dis que j’avancerais sur FTPix pour android, est tombé. Les derniers ajouts avant la sortie de cette semaine:

On peut partager l’url d’une image de la liste très simplement grâce aux outils fournis par android:
ftpix androidftpix android

On peut également effacer une image. Et j’ai aussi ajouté un menu sur la “page” d’une image pour effacer / partager.

Petit truc utile, j’ai ajouté une fenêtre d’aide qui explique les termes et comment les remplir. Ca permettra d’éviter les confusion à propos de la synchronisation par exemple

ftpix android

Doit surement y rester des fautes… et je vais m’atteler à la version française également.

Bon tout ça pour dire que développer sur android est vraiment plaisant, les outils mis à la disposition des développeurs permettent de faire des choses vraiment sympa rapidement, simplement et efficacement. Il manque juste un peu de doc et surtout des exemples, il faut donc arpenter un peu plus le web car certaines explications ne sont pas super claires…

Utiliser Eclipse est également un gros gain de temps avec les plug-in créés par Google, moi qui ne suis pas fan d’Eclipse, je n’ai pas trop le choix du coup… mais ça vaut vraiment la peine de se faire du mal.

FTPix pour android, bientôt sur le market !