Christian KAKESA, Le Blog

GO lang

GO est un langage de programmation propulsé par Google. L’objectif premier de GO est de proposer un langage rapide à l’exécution et à la compilation, qui soit safe (multi-threading, multi-processus, gestion de la mémoire), facile à programmer et en même temps bas niveau. Est-ce possible ? Allez GO…

Préparer son environnement de développement

sudo aptitude install bison gcc libc6-dev ed gawk make
sudo aptitude install python-setuptools python-dev
sudo easy_install mercurial
mkdir $HOME/bin
mkdir $HOME/go

Ajouter les lignes suivantes dans le fichier « ~/.bashrc »

export GOBIN=${HOME}/bin # Obligatoire si le choix de l'emplacement est différent de ${HOME}/bin (pensez à ajouter ce chemin dans $PATH)
export GOROOT=${HOME}/go
export GOARCH=386 # Ou amd64, arm
export GOOS=linux
export PATH=${GOBIN}:${HOME}/bin:${PATH}

Récupérer et compiler GO

. ~/.bashrc
hg clone -r release https://go.googlecode.com/hg/ $GOROOT
cd $GOROOT/src
LANG=en_US ./all.bash

Écrire le fameux « Bonjour le monde »

cat > bonjour.go <<EOF
package main
import "fmt"
func main() {
	fmt.Printf("Bonjour le monde !!!\n")
}
EOF
8g bonjour.go
8l -o bonjour bonjour.8
./bonjour

Liens :

1. Tutoriel GO
2. En savoir plus sur les librairies du langage GO

Android developers

Signer une application Android n’est pas bien compliqué. Ces quelques vont vous guider dans la préparation du certificat. Il faut bien entendu avoir une plate forme Android fonctionelle.

mkdir -p ~/.local/share/keystore
cd ~/.local/share/keystore
keytool -genkey -v -keystore android-release-key.keystore -alias mon_alias -keyalg RSA -validity 10000

Il ne vous reste plus qu’à répondre aux questions…

Pour signer une application, le plus simple est d’utiliser ant. Il suffit de renseigner les deux lignes ci-dessous dans le fichier build.properties à la racine de votre projet :

# fichier : build.properties
key.store=/home/christian/.local/share/keystore/android-release-key.keystore
key.alias=mon_alias

Lorsque vous compiler votre projet avec la commande ant, il faut renseigner le ou les mots de passe de votre certificat, puis à la racine du projet tapez :

ant release

Il est aussi possible de réaliser la signature de vos applications à la main, je vous conseille dans ce cas le tutoriel android traitant directement du sujet. il ne reste plus qu’à déployer l’application.

Pour installer votre application sur l’émulateur ou votre device, il faut utiliser l’outil ADB ou passer par Eclipse/ADT.

Logo Android

Pour les développeurs qui n’ont pas encore de mobile Android, il est impossible de tester l’Android Market et ce, même depuis les images pour l’émulateur livré avec le SDK. Avec un peu de ruse il est possible, de jouer avec les applications disponibles depuis le market. Pour ce faire nous allons utiliser les images fournit par HTC sur leur portail dédié aux développeurs.

Je vous conseille de suivre mon article sur la mise en place d’une plate-forme de développement Android sous linux : http://www.kakesa.net/os-design/installer-le-sdk-android-et-eclipse-adt-ubuntu-9-10/139 si vous n’en avez pas encore.

Créer un répertoire temporaire pour stocker l’image du firmware du HTC Dream, par exemple /tmp/android :

<br />mkdir -p /tmp/android<br />unzip signed-dream_devphone_userdebug-img-14721.zip<br />chmod a+r *.img<br />

L’image récupéré depuis le site de HTC étant celui d’une version 1.6, créons un avd de la même version et copions-y l’image HTC :

<br />android list target<br />android create avd -t 3 -n avd1.6<br />cp /tmp/android/system.img ~/.android/avd/avd1.6.avd/<br />

Lançons l’émulateur :

<br />emulator -avd avd1.6<br />

1. Cliquez sur le logo Android à l’écran
2. Suivez le tutoriel ou passez-le
3. Utilisez votre compte google ou choisissez de le créer
4. Sélectionnez une application du Market et installez-là

Logo Android

Voici un petit tutoriel pour installer le SDK Android ainsi que l’IDE Eclipse et son plugin ADT permettant de réaliser ses premières lignes de code sous l’OS de Google. Je vous conseille de tester l’émulateur afin de vous familiariser avec Android. D’autres articles suivront sur la manière de réaliser ses premières applications.

Première étape installer java-6 et Ant

sudo aptitude install sun-java6-bin ant

Installer Eclipse et son plugin ADT

sudo aptitude install eclipse

Installer le plugin ADT pour eclipse

Ici l’installation d’Eclipse permet de faciliter vos futurs développements, je vous conseil, dans un premier temps, de privilégier les commandes shell pour mieux maîtriser le développement sous Android.

• Lancer eclipse
• Help > Install New Softare

• Cliquer sur « Add » ajouter les « Software sites » suivants :
• Selon le schéma [Name] – [Location]
  1. ADT – https://dl-ssl.google.com/android/eclipse/
  2. Eclipse GEF – http://download.eclipse.org/tools/gef/updates/releases/
  3. Eclipse EMF – http://download.eclipse.org/modeling/emf/updates/releases/
  4. Eclipse GMF – http://download.eclipse.org/modeling/gmf/updates/releases
  5. Eclipse Webtools – http://download.eclipse.org/webtools/updates/
  6. Google eclipse Plugin – http://dl.google.com/eclipse/plugin/3.5

• Sélectionner « Developer Tools » et assurez-vous que « Contact all update sites during install… » soit coché, puis suivez le guide…

Installer le SDK

mkdir -p ~/.local/opt
cd ~/.local/opt

Télécharger le SDK Android dans ~/.local/opt/

tar -zxvf android-sdk_r3-linux.tgz
cd android-sdk-linux/tools/
echo "export PATH=$(pwd):\${PATH}" >> ~/.bashrc
. ~/.bashrc

Mettre à jour le SDK

android update sdk

Faites connaissance avec l’émulateur Android

Lister les firmware disponible et identifier l’ID d’une version qui vous intéresse

android list targets

Créer un avd et lancer l’émulateur (-t : Id précédemment identifié)

mksdcard -l sdcard-avd2.0_API5 4096M ~/.android/sdcard-avd2.0_API5
android create avd -n avd2.0_API5 -t 7
emulator -avd avd2.0_API5 -sdcard ~/.android/sdcard-avd2.0_API5

Émulateur Android

StAX pour Streaming Api for Xml est une méthode performante pour parser un document XML. Voici un petit article qui montre les bien faits de cette méthode permettant de parcourir un fichier XML. On connaît bien les méthodes DOM (Document Object Model) et SAX (Simple Api for Xml), mais un peu moins sur le StAX méthode dite de pull parsing.

Logo XML 1.1

Pour rappel, la méthode DOM a pour fonctionnement le chargement en mémoire de l’ensemble d’un fichier XML sous forme d’arbre ou tableau etc… Cette méthode convient pour des fichiers de petite taille mais pour des fichiers de plusieurs centaines de mégaoctets voir quelques gigaoctets, ce mode est très lent. DOM a la particularité de pouvoir parcourir un fichier dans un sens comme dans l’autre et de permettre l’écriture et la modification de nœuds XML. Le mode de parcours SAX est un mode dit de push parsing (évènement implémenté/déclenché du côté de l’API) qui permet le parcours d’un fichier uniquement vers l’avant. SAX consomme très peu de mémoire, et reste très rapide mais ne permet pas la modification de nœuds XML.

La notion de pull parsing pour le StAX vient du fait que l’évènement est demandée du côté du code client (comprendre le code client en dehors de l’API XML). Le parseur est ce qu’on appelle « stream based », le code client soumet la portion de code a analyser par le parseur et récupère entre autre un évènement au quel on choisira de réaliser une action.
Le pull parsing oblige une analyse vers l’avant uniquement et permet l’écriture mais pas la modification de nœuds XML. Les performance sont très élevées pour le parcours de fichiers volumineux.

Parseur de type StAX :

• Expat (C)
• SPXML (C++)
• Plusieurs implémentations en JAVA basées sur la JSR-173 (JAVA)

Ci-dessous un exemple d’utilisation du parseur SPXML en mode StAX (supporte aussi DOM). On peut voir que le code utilisateur implémente les actions de traitement et non une redéfinition de méthodes de l’API comme en SAX. Notons que j’ai choisit de parcourir le fichier donné en paramètre, ligne à ligne, mais StAX étant stream based (basé sur des flots de données), il possible de parcourir selon un nombre d’octet définit.

int main( int argc, const char * argv[] )
{
	std::string filename;
	if( argc != 2 )
	{
		std::cout << "Usage:" << argv[0] << " <xml_file>" << std::endl;
		return (-1);
	}
	else
		filename = argv[1];

	SP_XmlPullParser parser;
	std::string line;
	std::ifstream myfile(filename.c_str());
	if (myfile.is_open())
	{
		while (!myfile.eof())
		{
			std::getline(myfile, line);
			parser.append( line.c_str(), line.length() );
			for( SP_XmlPullEvent * event = parser.getNext(); NULL != event; event = parser.getNext() )
			{
				switch( event->getEventType() )
				{
					case SP_XmlPullEvent::eStartDocument:
						std::cout << "start document" << std::endl;
						break;
					case SP_XmlPullEvent::eEndDocument:
						std::cout << "\nend document" << std::endl;
						break;
					case SP_XmlPullEvent::eDocDecl:
					{
						SP_XmlDocDeclEvent * declEvent = (SP_XmlDocDeclEvent*)event;
						std::cout << "<?xml";
						if( '\0' != *declEvent->getVersion() )
							std::cout << " version=\"" << declEvent->getVersion() << "\"";

						if( '\0' != *declEvent->getEncoding() )
							std::cout << " encoding=\"" << declEvent->getEncoding() << "\"";

						if( -1 != declEvent->getStandalone() )
							std::cout << " standalone=\""<< (declEvent->getStandalone() ? "yes" : "no") << "\"";

						std::cout << "?>" << std::endl;
						break;
					}
					case SP_XmlPullEvent::eDocType:
					{
						SP_XmlDocTypeEvent * typeEvent = (SP_XmlDocTypeEvent*)event;
						std::cout << "<!DOCTYPE " << typeEvent->getName() << " PUBLIC \"" << typeEvent->getPublicID() << "\" SYSTEM \"" << typeEvent->getSystemID() << "\" \"" << typeEvent->getDTD() << "\">" << std::endl;
						break;
					}
					case SP_XmlPullEvent::eStartTag:
					{
						SP_XmlStartTagEvent * stagEvent = (SP_XmlStartTagEvent*)event;
						std::cout << "<" << stagEvent->getName();
						for( int i = 0; i < stagEvent->getAttrCount(); i++ )
						{
							const char * name = NULL, * value = NULL;
							name = stagEvent->getAttr( i, &value );
							std::cout << " " << name << "=\"" << value << "\"";
						}
						std::cout << ">" << std::endl;
						break;
					}
					case SP_XmlPullEvent::eEndTag:
						std::cout << "</" << ((SP_XmlTextEvent*)event)->getText() << ">" << std::endl;
						break;
					case SP_XmlPullEvent::eCData:
					{
						SP_XmlStringBuffer buffer;
						SP_XmlStringCodec::encode( parser.getEncoding(),
						((SP_XmlTextEvent*)event)->getText(), &buffer );
						std::cout << buffer.getBuffer() << std::endl;
						break;
					}
					case SP_XmlPullEvent::eComment:
						std::cout << "<!--" << ((SP_XmlTextEvent*)event)->getText() << "-->" << std::endl;
						break;
					case SP_XmlPIEvent::ePI:
						std::cout << "<?" << ((SP_XmlPIEvent*)event)->getTarget() << " " << ((SP_XmlPIEvent*)event)->getData() << "?>" << std::endl;
						break;
				};
				delete event;
			}
		}
		myfile.close();
		if( NULL != parser.getError() )
			std::cerr << "\nerror: " << std::string(parser.getError()) << std::endl;
	}
	else
		std::cerr << "\nCan't open " << filename << " !!!" << std::endl;

	return 0;
}