Bon je ne vais pas faire durer le suspens plus longtemps et je vais commencer par annoncer les gagnants du concours Twitter. Ils ont été tiré au sort automatiquement par le site SoContest. Il s’agit donc de : @cthiebot et de @Tagapetio. Bravo à eux ! Je les contacterais dans la journée en message privé.

Je passe maintenant aux vainqueurs du concours via les commentaires. Comme je vous l’avais annoncée, j’ai tiré au sort les deux gagnants via le site random.org, et voici ce qu’il m’a retourné :

Ce qui signifie que les gagnants sont :

• 58 : Justine (Je consulte quotidiennement ce site pour me former à android et iphone et ça m’a beaucoup aidé ! Merci beaucoup !!!)
• 71 : Jul’ (Ces formations m’intéressent énormément, merci pour ce concours ! *croise les doigts*)

Bravo aux gagnants, je les contacterai dans la journée ! Encore merci aux autre d’avoir participé, et restez avec nous car quelques choses me dis qu’un autre concours devrait faire son apparitions dans les jours à venir…

video2brain propose deux formations Android : Devenez un développeur Android – Vol. 1 (39.95€) et Devenez un développeur Android – Vol. 2 (39.80€). Ce sont ces deux formations que nous allons faire gagner à quatre d’entre vous, soit un total de lot de 319€ !

Vous avez jusqu’au vendredi 13 mai 23h59 pour tenter votre chance. Pour cela il y a deux moyens de gagner :

• (2 gagnants) le premier sera de laisser un commentaire sur cette article (tirage au sort grace à random.org, une seule participation par personne est autorisée)
• (2 gagnants) le second, vous devrez poster sur Twitter le tweet qui suit (et part la même occasion vous pouvez nous suivre mais ce n’est pas obligatoire @TutoMobile) :

Gagner une formation de développement Android (http://goo.gl/vy2zP) grâce à @TutoMobile et @video2brainfr #concours – http://sct.me/M7U

Attention :mettez bien les http aux liens sinon votre candidature n’est pas pris en compte !

N’hésitez pas à partager ce concours sur Twitter, Facebook, mail ou autre pour nous remercier, se sera notre plus belle récompense !

BONNE CHANCE A TOUS !

Ce tutoriel vidéo vous est proposé par video2brain qui propose de nombreuses formations vidéos sur les logiciels Adobe mais pas seulement. Ils proposent notamment deux formations Android complètes (Volume 1 et Volume 2) !

D’ailleurs soyez présent lundi car nous allons vous proposer un petit jeu concours vous permettant de gagner, pas un, ni deux mais quatre accès gratuit et illimité au deux formations Android ! TENTER VOTRE CHANCE ICI

En attendant, je vous laisse regarder ce tuto vidéo, bon apprentissage :

Dans ce tutoriel, nous allons aborder une facette très importante d’Android mais beaucoup moins utilisée par les développeurs. Il s’agit du développement de Widget. Nous allons créer un petit widget.

Tout d’abord, je tiens à remercier tutomobile.fr pour m’avoir donné la chance d’écrire un article sur ce site.[Note d'Axon] Merci à Nazim Benbourahla d’avoir écrit ce tutoriel [/Note d'Axon]

Qu’est ce qu’un Widget ?

Comment créer un Widget

Mon premier Widget “Hello Word”

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
   		 android:layout_width="fill_parent"
   		 android:orientation="vertical"
   		 android:layout_gravity="center"
   		 android:layout_height="wrap_content">
 
<TextView android:id="@+id/hello_world_widget"
   		 android:text="@string/hello_world_widget"
   		 android:layout_height="wrap_content"
   		 android:layout_width="wrap_content"
   		 android:layout_gravity="center"
   		 android:layout_marginTop="5dip"
   		 android:padding="10dip"
   		 android:textColor="#FFF"/>
 
</LinearLayout>

<?xml version="1.0" encoding="utf-8"?>
<resources>
	<string name="hello">Hello World, HelloWorldWidgetActivity!</string>
	<string name="app_name">My Hello World Widget</string>
	<string name="hello_world_widget">Bienvenue dans mon Widget Hello World :) </string>
</resources>

<?xml version="1.0" encoding="utf-8"?>
<appwidget-provider xmlns:android="http://schemas.android.com/apk/res/android"
   		 android:minWidth="160dip"
   		 android:minHeight="80dip"
   		 android:updatePeriodMillis="10000"
   		 android:initialLayout="@layout/main"
/>

Petite explication sur ce code :

• android:minWidth : Largeur minimum du widget.
• android:minHeight : Hauteur minimum du Widget.
• android:updatePeriodMillis : Temps de mise à jour du Widget.
• android:initialLayout : vue qui sera appliqué au Widget.

Modifiez la classe Java (HelloWorldWidgetActivity). Ce qui donnera simplement le code suivant

package com.android.tuto.widget;
import android.appwidget.AppWidgetProvider;
 
public class HelloWorldWidgetActivity extends AppWidgetProvider {
}

Pour finir il faut modifier le manifest comme ci-dessous :

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
	package="com.android.tuto.widget" android:versionCode="1"
	android:versionName="1.0">
	<application android:icon="@drawable/icon" android:label="@string/app_name">
 
 
		<receiver android:name=".HelloWorldWidgetActivity"
			android:label="@string/app_name">
			<intent-filter>
				<action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
			</intent-filter>
			<meta-data android:name="android.appwidget.provider"
				android:resource="@xml/my_widget_provider" />
		</receiver>
 
	</application>
 
 
</manifest>

Nous allons tester tout cela. Lancez le projet. On a l’impression que rien ne se passe, tout simplement parce que l’on vient de créer un Widget qu’il faudra mettre sur votre bureau.
Pour cela il faut suivre les étapes suivantes :

1. Une fois arrivé sur l’écran d’acceuil de l’emulateur, cliquez longuement sur le bouton Home.

2. Cliquez sur Widget

3. Un autre écran apparaît, il suffit de choisir notre Widget

4. Ce qui donnera

Voila notre premier Widget Hello World est fini.

Conclusion

Donc ce tutoriel s’arrête là, en espérant qu’il vous ait aidé à comprendre comment fonctionnent les Widget et le framwork AppWidget. En espérant que cette collaboration avec tutomobile se poursuive. N’hésitez pas à me contacter sur mon site ou commenter cet article.

Figure 1 - ProsgressBar/SeekBar d'origines et résultats finaux

Figure 2 - ProgressBar type "loader"

A l’assaut des styles de la ProgressBar (Horizontale !)

Une ProgressBar par défaut se constitue d’une image de type loading, qu’on pourra retrouver dans les fichiers images du SDK sous le nom de « spinner » (exemple : spinner_black_48.png). Pour obtenir une ProgressBar Horizontale (que l’on abrégera par PBH pour la suite de notre article), il suffit d’ajouter un style bien précis à la ProgressBar que l’on a déclaré dans le fichier XML de notre Activity :

<ProgressBar
        android:layout_width="fill_parent"
	android:layout_height="wrap_content"
	style="?android:attr/progressBarStyleHorizontal"
	android:progress="50"
	android:max="100"
	android:secondaryProgress="80"/>

On remarquera ici plusieurs attributs pour notre PBH :

• Max : permet de définir la valeur totale de la progression de notre barre, je mets toujours 100 pour avoir une notion de pourcentage dans nos calculs, ce qui les simplifiera.
• Progress : indique tout simplement le niveau de progression
• secondProgress : indique un deuxième niveau de progression, ce qui peut être utile dans une écoute de musique en streaming par exemple, ou le progress indique la progression de lecture, et le secondProgress indique la progression du téléchargement.
• Style : le style de notre barre, il fait appelle ici à l’attribut de style (un attribut de style est en fait une référence/un pointeur de style) de la PBH native d’Android.

Retour aux sources…

C’est ici que nous allons intervenir, nous allons étendre le style de la PBH (comme si l’on étendait une classe Java) et en l’appliquant à notre progressBar. La documentation des styles sur Android est très faible, elle ne fait qu’indiquer les styles disponibles, sans vraiment nous indiquer à quoi ils correspondent et comment ils sont construits, nous allons donc faire un tour dans les sources pour nous documenter.
Comme l’indique le fichier themes.xml des sources :

<item name="progressBarStyleHorizontal">@android:style/Widget.ProgressBar.Horizontal</item>

L’attribut de style progressBarStyleHorizontal fait référence au style Widget.ProgressBar.Horizontal, où l’on trouvera les spécifications dans le fichiers styles.xml :

 <style name="Widget.ProgressBar.Horizontal">
   <item name="android:indeterminateOnly">false</item>
   <item name="android:progressDrawable">@android:drawable/progress_horizontal</item>
   <item name="android:indeterminateDrawable">@android:drawable/progress_indeterminate_horizontal</item>
   <item name="android:minHeight">20dip</item>
   <item name="android:maxHeight">20dip</item>
 </style>

On ne va pas s’intéresser ici à “inderterminateOnly” et à “indeterminateDrawable », qui concerne les PBH qui n’indique pas l’évolution de progression de la barre (mais vous pouvez également modifier l’image si ça vous chante )

Pour modifier ce style, rien de plus simple !

On va créer un fichier styles.xml dans notre projet, et y insérer notre nouveau style en indiquant qu’il est une extension de Widget.ProgressBar.Horizontal :

<resources>
	<style name="CustomProgressBarHorizontal" parent="android:Widget.ProgressBar.Horizontal">
          <item name="android:progressDrawable">@drawable/custom_progress_bar_horizontal</item>
          <item name="android:minHeight">10dip</item>
          <item name="android:maxHeight">20dip</item>
	</style>
</resources>

Par manque d’imagination, j’ai appelé ce nouveau style CustomProgressBarHorizontal. Vous remarquerez que j’ai modifié la hauteur minimum (minHeight) pour avoir la possibilité d’avoir une barre plus fine, et que j’ai modifié l’image qui est utilisée en tant que progressDrawable (qui en fait un fichier xml, qui définit les images de fond, de progress, et de secondaryProgress de notre barre).

Et là, PAF ! Eclipse (désolé pour ceux qui utilise un autre IDE) n’est pas content et nous indique que le drawable custom_progress_bar_horizontal n’existe pas, ce qui est plutôt logique, puisqu’on ne l’a pas encore créée.

Une fois de plus, on va s’aider des sources pour comprendre comment la classe ProgressBar utilise le fichier xml, il suffit ici d’aller fouiller dans les fichiers de notre SDK : %ANDROID_SDK_PATH%/platforms/android-n/data/res/drawable/ (où n est la version de l’API)

Le fichier progress_horizontal est un fichier XML contenant des drawable, des classes bien pratiques permettant de faire des dessins plus ou moins basiques (dégradé, angle, cercle, etc…) à l’aide du XML, je vous conseille d’aller faire un tour du la documentation des drawable pour vous y familiariser.

Dans ce fichier, on y retrouve un layer-list, qui est en fait un tableau d’autres drawable. Ces drawables sont dessinés les uns au dessus des autres en suivant l’ordre dans lequel ils sont écrits dans le fichier : donc pour notre PBH, il faudra donc dessiner le background, le secondaryProgress et le progress pour finir :

<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
  <item android:id="@android:id/background">
	<shape>
	   <corners android:radius="5dip" />
	   <gradient
		android:startColor="#ff9d9e9d"
		android:centerColor="#ff5a5d5a"
		android:centerY="0.75"
		android:endColor="#ff747674"
		android:angle="270" />
	</shape>
  </item>
  <item android:id="@android:id/secondaryProgress">
	<clip>
	   <shape>
		<corners android:radius="5dip" />
		<gradient
		     android:startColor="#80ffd300"
		     android:centerColor="#80ffb600"
		     android:centerY="0.75"
		     android:endColor="#a0ffcb00"
		     android:angle="270" />
	   </shape>
	</clip>
  </item>
  <item android:id="@android:id/progress">
	<clip>
	   <shape>
		<corners android:radius="5dip" />
		<gradient
		     android:startColor="#ffffd300"
		     android:centerColor="#ffffb600"
		     android:centerY="0.75"
		     android:endColor="#ffffcb00"
		     android:angle="270" />
	   </shape>
	</clip>
  </item>
</layer-list>

Quand on regarde de plus près, on remarque que ces drawables sont de simples rectangles (shapes) comprenant des coins arrondis et un dégradé.

Pour modifier notre PBH, on va ici faire simple et modifier les dégradés (les simplifier et changer les couleurs), cela peut sembler un peu simple, mais cela suffira à modifier notre PBH pour qu’elle puisse corresponde au thème général de votre application et qu’elle soit identique sur tous les terminaux.

Ce qui nous donne les codes suivant, avec un thème bleu à notre PBH :

<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
  <item android:id="@android:id/background">
	<shape>
	   <corners android:radius="5dip" />
	   <gradient
		android:startColor="#ffffffff"
		android:centerColor="#ffdddddd"
		android:centerY="0.50"
		android:endColor="#ffffffff"
		android:angle="270" />
	</shape>
  </item>
  <item android:id="@android:id/secondaryProgress">
	<clip>
	   <shape>
		<corners android:radius="5dip" />
		<gradient
		     android:startColor="#770e75af"
		     android:endColor="#771997e1"
		     android:angle="90" />
	   </shape>
	</clip>
  </item>
  <item android:id="@android:id/progress">
	<clip>
	   <shape>
		<corners android:radius="5dip" />
		<gradient
		     android:startColor="#ff0e75af"
		     android:endColor="#ff1997e1"
		     android:angle="90" />
	   </shape>
	</clip>
  </item>
</layer-list>

On aura donc un fond blanc avec un léger dégradé vers le gris en son centre. On laisse les coins arrondis (border-radius) à 5dip, ce qui nous fera l’effet un demi cercle sur les extrémités de notre PBH si on lui fixe un layout_height à wrap_content (et oui, n’oubliez pas qu’on a mis le minHeight de notre style à 10dip ). En appliquant notre style à la PBH, on aura donc le rendu suivant :

Figure 3 - Custom ProgressBar Horizontale

Remarque : cela ne vous coûte rien de garder les mêmes ID pour vos drawables (android.R.id.progress par exemple), ils sont utilisées dans la classe ProgressBar.java des sources, cela vous évitera quelques petits soucis.

Customisation de la SeekBar

Quand on regarde le visuel d’une SeekBar, ce n’est rien d’autre qu’une progressBar Horizontale avec un petit « sélectionneur « en plus : chez Google, ils l’ont baptisé thumb (traduction anglaise de « pouce »).

Libre à chacun d’apprécier ou pas le design de ce thumb, personnellement, ce n’est toujours pas mon cas.

Je ne vais bien entendu pas m’étaler ici sur la modification de la barre de progression, il suffit de reprendre la première partie de cet article, mais je vous ferai juste remarquer que si l’on regarde une fois de plus les sources, le progressDrawable de la seekBar fait appel au même fichier que la PBH :

<style name="Widget.SeekBar">
        <item name="android:indeterminateOnly">false</item>
        <item name="android:progressDrawable">@android:drawable/progress_horizontal</item>
        <item name="android:indeterminateDrawable">@android:drawable/progress_horizontal</item>
        <item name="android:minHeight">20dip</item>
        <item name="android:maxHeight">20dip</item>
        <item name="android:thumb">@android:drawable/seek_thumb</item>
        <item name="android:thumbOffset">8dip</item>
        <item name="android:focusable">true</item>
    </style>

On va s’intéresser ici aux items « thumb » et « thumbOffset » (décalage du thumb).
La customisation du thumb va se faire de la même manière que celle de la PBH, on va étendre le style du widget SeekBar, en modifiant le drawable du thumb.

Remarque : il est également possible de changer le thumb et le thumbOffSet directement dans les attributs d’une SeekBar lors sa déclaration dans le layout de notre Activity, mais je trouve plus propre le fait de le faire dans l’extension du style, de plus, si vous avez plusieurs SeekBar, vous n’aurez pas à ses attributs à chaque fois, c’est le style que vous aurez appliqué qui s’en chargera.

Dans notre nouveau style de SeekBar, on change donc notre thumb :

<item name="android:thumb">@drawable/seek_bar_thumb</item>

Et, comme dans les sources, ce fichier sera un fichier XML comprenant un <selector> , un autre drawable (stateListDrawable) qui définit plusieurs autres drawables selon l’état du widget, des états qui dépendent la plupart du temps des actions de l’utilisateur : focus, pressed, selected, etc… :

<selector xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:state_pressed="true"
          android:drawable="@drawable/custom_thumb_state_pressed" />
    <item android:state_focused="true"
          android:drawable="@drawable/custom_thumb_state_selected" />
    <item android:state_selected="true"
          android:drawable="@drawable/custom_thumb_state_selected" />
    <item android:drawable="@drawable/custom_thumb_state_default" />
 
</selector>

Ces 4 items, dont les noms parlent d’eux même, sont dans notre cas d’autres fichiers XML, comprenant des formes (shape), comme on a pu les rencontrer dans la première partie de cette article (cf. documentation des drawable ).

Voici par exemple celui qui décrit l’état « normal » (par défaut) de notre thumb (les deux autres  sont quasiment identiques, juste les couleurs définies sont modifiées) :

<shape
	xmlns:android="http://schemas.android.com/apk/res/android"
	android:shape="oval">
	<size
		android:width="35dip"
		android:height="35dip" />
	<stroke
		android:width="1dip"
		android:color="#ffffffff" />
	<gradient
		android:startColor="#ffcdcdcd"
		android:endColor="#fff8f8f8"
		android:angle="270"
		android:type="linear" />
</shape>

Un simple disque, de rayon 35dip, avec une bordure et un dégradé :

Figure 5 - SeekBar avec thumb par défaut

Figure 4 - seekBar etat focused

Figure 7 - seekBar état pressed

Figure 6 - seekbar état normal

Lorsque l’on glisse le sélecteur au fond à droite, on remarque que l’image est coupée, chose qui se reproduira du côté gauche, et c’est là qu’intervient le thumbOffSet.

Quel ThumbOffSet choisir ?

Le style de la SeekBar android, qu’on a pu voir plus haut dans cet article, définit un thumbOffSet par défaut à 8dip, pourquoi 8dip ? Il n’y a qu’à regarder les fichiers images utilisées pour le thumb de base !

Pour cela, sur votre poste, regardez de plus près

%ANDROID_SDK_PATH%/platforms/android-7/data/res/drawable-mdpi/seek_thumb_normal.jpg

(pour un terminal avec une densité moyenne, un dip est égal à un pixel, c’est pour cela que j’ai choisis le dossier drawable-mdpi : plus de renseignements sur les densité d’écran ici).

On s’aperçoit que l’image à une largeur de 32 pixel, et qu’elle possède deux zones de vide de 8 pixels de chaque côté du thumb qui y est dessiné, ce qui explique le 8 pour le thumbOffset dans le style par défaut des seekBar.

Remarque : rien ne vous empêche effectivement de créer vos thumb avec des fichiers image, à l’aide notamment de Photoshop ou Gimp, j’ai choisis ici de les créer à l’aide des drawable android et de leur xml.

Comme nos thumb sont des drawable en xml, ils n’auront pas de marges vides, nous allons donc mettre notre thumbOffset à 0dip dans notre style :

<style name="CustomSeekBar" parent="android:Widget.SeekBar">
   <item name="android:progressDrawable">@drawable/custom_seek_bar</item>
   <item name="android:thumb">@drawable/seek_bar_thumb</item>
   <item name="android:thumbOffset">0dip</item>
</style>

Et on l’insère dans le layout de notre Activity :

<SeekBar
	android:layout_width="fill_parent"
	android:layout_height="wrap_content"
	android:progress="50"
	android:max="100"
	style="@style/CustomSeekBar"
	android:secondaryProgress="80"
	android:layout_margin="5dip" />

Il n’y a plus qu’à admirer le résultat final de notre article  !

Vous pouvez trouver les sources du projet ici.

Je tenais à remercier Alex (dit Sakaroz) qui a écrit ce tutorial Android très intéressant. Je vous invite à aller faire un tour sur son blog : http://blog.sakaroz.com/ et son site pro : http://www.sakaroz.com/

Les mobiles Android, sont comme la plupart des smartphones d’aujourd’hui composés généralement d’au moins 2 cœurs, 1 pour l’Application (Linux et Android) et 1 pour le Modem (ou Baseband ou encore Radio).

Petit rappel sur les Telecoms :
Le Modem (2G/3G/LTE) est composé de plusieurs couches protocolaires définies par les standards 3GPP (3rd Generation Partnership Project).
C’est lui qui s’attache au réseau, gère les appels (entrants/sortants), les SMS, la connexion de données du mobile (PDP), la carte SIM etc…

Généralement, un Modem est composé comme suit :

Les différentes couches sont:

1. AT (ou MMI) : c’est la couche en contact avec le monde extérieur, c’est par ici qu’arrivent les actions utilisateurs (passer un appel, lire un contact, etc.)
2. Abstraction Layer : elle est en charge de transcrire les commandes AT ou les actions utilisateurs gérées par la MMI en commandes NAS
3. NAS : Pour Non-Access Stratum, elle est constituée des modules CM (connection management), MM (mobility management), CC (call control), SS, SMS, SM etc.
4. AS : Pour Access Stratum, elle est la tour de contrôle du Modem, elle gère la cellule courante, les mesures des cellules voisines, le passage d’une technologie à l’autre (2G-3G et inversement) durant un appel (handover) ou non (cell change), etc. Elle est composée de modules tels que RR, RLC, MAC
5. L1 : Pour Layer 1, c’est la couche basse qui gère les canaux physiques et pilote la radio.

Généralement, les Modems seuls (la plupart des téléphones mobiles) sont pilotés par la MMI (Man Machine Interface), ou IHM, c’est en gros ce que voit l’utilisateur (icônes, menus, boutons…)

Vous l’aurez compris, avec les smartphones, c’est à ce niveau qu’Android intervient, c’est la MMI. Bien entendu, Android ne se cantonne pas qu’à ca. Il gère au travers du système Linux, le multimédia, les périphériques (Wifi, Bluetooth, Camera…), la batterie, le filesystem (SDCARD, …) , etc.

Pour piloter le Modem, et dans le but d’offrir l’interface la plus étendue possible (applicable au plus grands nombre de Modems existants), Google a décidé d’utiliser les commandes AT.

Les commandes AT sont des commandes ASCII définies par les standards 3GPP (27.007 et 27.005 pour les SMS) permettant de piloter un modem.

Voici le principe général d’une commande AT (site) :

Sur les smartphones Android, l’Application (Linux Android) envoie les commandes AT pour piloter le Modem. Les fournisseurs ont donc mis en place des moyens d’envoyer ces commandes d’un OS à l’autre. D’autres fournisseurs, se sont passés des commandes AT et envoient directement des commandes de la couche « Abstraction Layer » depuis l’Application (on perd alors toute portabilité sur d’autres Modems). Bref, je ne rentrerai pas dans le détail, car la discussion pourrait être longue…

En résumé, nous avons d’une part, un Modem piloté par commandes AT et d’autre part, Android qui doit piloter ce Modem. C’est a ce moment qu’intervient le RIL (Radio interface Layer).

Le principe du RIL n’est pas nouveau, il existait déjà avec Windows Mobile. Et son utilité reste assez simple, transformer les requêtes Android (appelées RIL_REQUEST) en commandes AT.

Le RIL est un démon écrit en C, Android s’y connecte par le biais du RILJ (pour RIL java) au travers d’une socket où les objets sont (dé)sérialisés pour y être transportés.

Le RIL écrit ensuite les commandes AT sur une socket ou tout autre port (tty, …) et elles sont alors convoyées jusqu’au Modem, ce dernier renvoie alors le retour des commandes sur le port ouvert.

Voici un schéma permettant de mieux comprendre le principe général :

Prenons un exemple concret, l’appel sortant (ou MO Call).

Lorsque l’utilisateur presse le « bouton vert », la requête passe au travers du Framework pour arriver jusqu’au RILJ par la méthode dial qui va alors préparer une RIL_REQUEST_DIAL et fournir les paramètres nécessaires pour passer l’appel (numéro et présentation du numéro appelant).

Voici le code de la méthode dial RIL.java

public void
dial (String address, int clirMode, Message result) {
 RILRequest rr = RILRequest.obtain(RIL_REQUEST_DIAL, result);
 
 rr.mp.writeString(address);
 rr.mp.writeInt(clirMode);
 
 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
 
 send(rr);
}

Cette requête est ensuite reçue par le RIL (Google a fourni le reference-ril.c pour exemple), qui transforme cette requête en commande ATD :

static void requestDial(void *data, size_t datalen, RIL_Token t)
{
RIL_Dial *p_dial;
char *cmd;
const char *clir;
int ret;
 
p_dial = (RIL_Dial *)data;
 
switch (p_dial->clir) {
  case 1: clir = "I"; break;  /*invocation*/
  case 2: clir = "i"; break;  /*suppression*/
        default:
  case 0: clir = ""; break;   /*subscription default*/
}
 
asprintf(&cmd, "ATD%s%s;", p_dial->address, clir);
 
ret = at_send_command(cmd, NULL);
 
free(cmd);
 
/* success or failure is ignored by the upper layer here.
       it will call GET_CURRENT_CALLS and determine success that way */
RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
}

Pour un appel au 0612345678, le Modem va recevoir ATD0612345678;

Le RIL passe ensuite en mode lecture, en attente de réception de la réponse finale qui peut être OK, NO CARRIER si l’appel n’a pas été établie ou +CME ERROR: xx lorsqu’une erreur est survenue (xx code de l’erreur).

Une fois la réponse traitée, il (le RIL) envoie au Framework (RILJ) la RIL_RESPONSE avec les paramètres (si besoin).

Le RIL dépile ensuite les autres requêtes (envoie de SMS, activation des données, mesure du signal, etc.) et les exécute une à une. L’information de l’appel remonte quant à elle jusqu’au Dialer par le biais des interfaces.

Note: le seul bémol de cette architecture, c’est que, par défaut, le RIL empile les requêtes à destination du Modem. Alors qu’avec quelques modifications, on pourrait ouvrir plusieurs canaux AT (car les Modems le supportent) et exécuter des requêtes en parallèle pour gagner en efficacité. Mais tout cela reste du ressort des constructeurs.

Nous allons utiliser une interface graphique très simple, qui se compose d’un EditText et d’un bouton pour déclencher le partage. Voici donc le contenu du main.xml :

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >
<EditText  
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
    android:id="@+id/edittext"
    />
 
<Button
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
	android:id="@+id/share"
    android:text="Partager"
    />
</LinearLayout>

On déclare notre EditText et notre Button (pour une meilleur lisibilité dans le code) :

private EditText text;
private Button share;

On les relie avec l’interface graphique

text = (EditText)findViewById(R.id.edittext);
share = (Button)findViewById(R.id.share);

On créer un OnClickListener pour lancer l’action de partage lorsque le Button est appuyer.

share.setOnClickListener(
        new OnClickListener() {
		@Override
		public void onClick(View v) {
			final Intent MessIntent = new Intent(Intent.ACTION_SEND);
	        	MessIntent.setType("text/plain");
	        	MessIntent.putExtra(Intent.EXTRA_TEXT, text.getText().toString());
	        	VotreActivity.this.startActivity(Intent.createChooser(MessIntent, "Partager avec..."));
		}
        }
);

Examinons ce code:

>>> Création de l’Intent, MessIntent est le nom donner, à vous de choisir le votre =D

final Intent MessIntent = new Intent(Intent.ACTION_SEND);

>>> Définition du type d’Intent. J’en ai essayer d’autre mais lui seul permet d’utiliser toutes les applications disponibles.

MessIntent.setType("text/plain");

>>> Définition du texte (on récupère le texte de l’EditText) à publier sur Twitter, Facebook ou autres.

MessIntent.putExtra(Intent.EXTRA_TEXT, text.getText().toString());

>>> Lancement de l’Intent créer précédemment. MessIntent est l’Intent créer, et « Partager avec…. » correspond au titre de la boite de dialogue qui s’ouvrira pour vous proposer l’application à utiliser pour partager votre texte.
VotreActivity.this est le nom de votre activité en cours, qui est donc à remplacer par la votre).

VotreActivity.this.startActivity(Intent.createChooser(MessIntent, "Partager avec..."));

Vous savez désormais comment envoyer un message sur les réseaux sociaux ou autres. Je vous met deux petites screens pour que vous voyez ce que vous devriez obtenir :

Je partage en « bonus » une modification simple du code qui vous permettra d’ouvrir Gmail avec une adresse et un sujet pré-rempli.

final Intent emailIntent = new Intent(android.content.Intent.ACTION_SEND);
emailIntent.setType("plain/text");
emailIntent.putExtra(Intent.EXTRA_SUBJECT, "SujetDuMessage");
emailIntent.putExtra(android.content.Intent.EXTRA_EMAIL, new String[]{"VotreEmail@gmail.com"});
VotreActivity.this.startActivity(Intent.createChooser(emailIntent, "Email Envoyer..."));

Je pense qu’il n’est pas nécessaire d’expliquer ce code qui ressemble beaucoup au précédent néanmoins si vous avez des questions, n’hésitez pas. En tout cas pré-remplir un mail peut être utile pour avoir des retour sur vos application par les utilisateurs.

Cette article a été rédigé par TecKnologikS (merci à lui ). Pour le remercier, vous pouvez télécharger ses applications et surtout faire vos retours pour qu’il puisse les améliorer : Verbes Irréguliers Anglais, Des Coquins, Hasard.

Si vous avez besoin d’un retour sur vos applications n’hésitez pas à lui envoyer un mail pour lui demander : tecknologiksdev [at] gmail [point] com (remplacer [at] par @ et [point] par .)

Cependant, qui dit longue opération dit souvent Thread. Or Android est connu pour bien différencier l’affichage du traitement (Modèle MVC) et seul le Thread propriétaire des objets graphiques (View) ne peut les modifier. En gros, lorsque votre Activity charge le layout, elle est la seule à pouvoir agir dessus.

C’est ce que je vais m’efforcer d’illustrer avec l’exemple ci-dessous.

Prenons l’exemple d’une application ayant a effectuer 2 opérations assez longues (doLongOperation1 et doLongOperation2). Ces opérations sont consécutives ; doLongOperation2 a besoin que doLongOperation1 soit terminée pour démarrer. Elles sont exécutées dans un second Thread qui sera lui, démarré depuis l’Activity.

Au moment où le second Thread est démarré, on obtient quelque chose du genre :

Soit en gros le code suivant:

private void compute() {
  mProgressDialog = ProgressDialog.show(this, "Please wait",
          "Long operation starts...", true);
 
  new Thread((new Runnable() {
      @Override
      public void run() {
          doLongOperation1();
          doLongOperation2();
      }
  })).start();
  // ...
}

Mais durant l’exécution des opérations, on peut imaginer que l’on ait besoin d’informer l’utilisateur sur le type d’opération en cours et donc mettre à jour le message de la ProgressDialog. Pour ce faire on pourrait utiliser la méthode setMessage de ProgressDialog.

Donc grosso-modo quelque chose comme ca :

private void compute() {
  mProgressDialog = ProgressDialog.show(this, "Please wait",
          "Long operation starts...", true);
 
  new Thread((new Runnable() {
      @Override
      public void run() {
          mProgressDialog.setMessage("Doing long operation 1...");
          doLongOperation1();
          mProgressDialog.setMessage("Doing long operation 2...");
          doLongOperation2();
      }
  })).start();
  // ...
}

Mais, on l’a vu plus tôt, seul le Thread propriétaire des objets graphiques ne peut les modifier. L’objet mProgressDialog, créé dans le Thread de l’Activity, ne peut être modifier par un Thread annexe, au risque de lancer une CalledFromWrongThreadException avec le message au combien explicite :

Only the original thread that created a view hierarchy can touch its views.

Pour réaliser notre opération, il faut donc que le second Thread soit capable d’informer le Thread de l’Activity. C’est ce que propose la classe Handler avec le principe des objets Message qu’elle véhicule. En gros un Handler, possède une queue (une file) de messages qu’il dépile un à un. Ces messages sont constitués d’un identifiant (int what) et peuvent contenir des données.
Il suffit de créer un objet de type Handler, et de l’utiliser pour préparer (appel à obtainMessage), envoyer (appel à sendMessage) et recevoir (override de handleMessage) les objet de type Message

Pour notre exemple, on définira 3 types de messages avec les 3 identifiants suivants :

1. MSG_ERR: une erreur s’est produite, la ProgressDialog disparait et on informe l’utilisateur
2. MSG_IND: une indication en cours de traitement à besoin d’être donnée à l’utilisateur (via la ProgressDialog)
3. MSG_CNF: le traitement est terminé, on confirme à l’utilisateur que tout s’est bien passé (la ProgressDialog disparait).

Bref, dans le cas nominal, on obtient donc ce qui suit:

Soit le code suivant:

package com.jde.tutorial;
 
import android.app.Activity;
import android.app.ProgressDialog;
import android.content.Context;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.Toast;
 
public class ProgressBarActivity extends Activity {
 
protected ProgressDialog mProgressDialog;
private Context mContext;
private ErrorStatus status;
 
public static final int MSG_ERR = 0;
public static final int MSG_CNF = 1;
public static final int MSG_IND = 2;
 
public static final String TAG = "ProgressBarActivity";
 
enum ErrorStatus {
    NO_ERROR, ERROR_1, ERROR_2
};
 
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
    mContext = this;
 
    // registers the OnClickListener to our button
    ((Button) findViewById(R.id.btn))
            .setOnClickListener(new OnClickListener() {
                @Override
                public void onClick(View v) {
                    compute();
                }
            });
}
 
private void compute() {
    mProgressDialog = ProgressDialog.show(this, "Please wait",
            "Long operation starts...", true);
 
    // useful code, variables declarations...
    new Thread((new Runnable() {
        @Override
        public void run() {
            Message msg = null;
            String progressBarData = "Doing long operation 1...";
 
            // populates the message
            msg = mHandler.obtainMessage(MSG_IND, (Object) progressBarData);
 
            // sends the message to our handler
            mHandler.sendMessage(msg);
 
            // starts the first long operation
            status = doLongOperation1();
 
            if (ErrorStatus.NO_ERROR != status) {
                Log.e(TAG, "error while parsing the file status:" + status);
 
                // error management, creates an error message
                msg = mHandler.obtainMessage(MSG_ERR,
                        "error while parsing the file status:" + status);
                // sends the message to our handler
                mHandler.sendMessage(msg);
            } else {
                progressBarData = "Doing long operation 2...";
                mProgressDialog.setMessage(progressBarData);
 
                // populates the message
                msg = mHandler.obtainMessage(MSG_IND,
                        (Object) progressBarData);
 
                // sends the message to our handler
                mHandler.sendMessage(msg);
 
                // starts the second long operation
                status = doLongOperation2();
 
                if (ErrorStatus.NO_ERROR != status) {
                    Log.e(TAG, "error while computing the path status:"
                            + status);
                    // error management,creates an error message
                    msg = mHandler.obtainMessage(MSG_ERR,
                            "error while computing the path status:"
                                    + status);
                    // sends the message to our handler
                    mHandler.sendMessage(msg);
                } else {
                    msg = mHandler.obtainMessage(MSG_CNF,
                            "Parsing and computing ended successfully !");
                    // sends the message to our handler
                    mHandler.sendMessage(msg);
                }
            }
        }
    })).start();
    // ...
}
 
/** fake operation for testing purpose */
protected ErrorStatus doLongOperation2() {
    try {
        Thread.sleep(5000);
    } catch (InterruptedException e) {
    }
    return ErrorStatus.NO_ERROR;
}
 
/** fake operation for testing purpose */
protected ErrorStatus doLongOperation1() {
    try {
        Thread.sleep(3000);
    } catch (InterruptedException e) {
    }
    return ErrorStatus.NO_ERROR;
}
 
final Handler mHandler = new Handler() {
    public void handleMessage(Message msg) {
        String text2display = null;
        switch (msg.what) {
        case MSG_IND:
            if (mProgressDialog.isShowing()) {
                mProgressDialog.setMessage(((String) msg.obj));
            }
            break;
        case MSG_ERR:
            text2display = (String) msg.obj;
            Toast.makeText(mContext, "Error: " + text2display,
                    Toast.LENGTH_LONG).show();
            if (mProgressDialog.isShowing()) {
                mProgressDialog.dismiss();
            }
            break;
        case MSG_CNF:
            text2display = (String) msg.obj;
            Toast.makeText(mContext, "Info: " + text2display,
                    Toast.LENGTH_LONG).show();
            if (mProgressDialog.isShowing()) {
                mProgressDialog.dismiss();
            }
            break;
        default: // should never happen
            break;
        }
    }
};
 
}

C’est à travers la méthode surchargée handleMessage que le message est dépilé. On teste ensuite le type de message (what) et on applique le traitement désiré.
Note: dans la méthode handleMessage, on se trouve à nouveau dans le Thread de l’Activity, c’est donc pour ça que l’opération est possible.

Voila ce que vous devriez avoir :

En espérant que ceci vous aura aidé.

Les sources du projet, c’est ici

Commençons par créer un projet avec la version 1.6 d’Android pour être conforme à tous les autres tutoriels Android du site. Pour ma part il s’appelle EnvoieSms avec une activité qui porte le même nom (vous pouvez l’appelé comme vous voulez).

Code XML

Avant de vous donner le code XML que nous allons utiliser pour faire l’interface graphique, je vais vous montrer le rendu que l’on souhaite à la fin :

Donc pour obtenir cette petite interface très simple voici le code XML correspondant :

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
	android:orientation="vertical" android:layout_width="fill_parent"
	android:layout_height="fill_parent">
	<LinearLayout android:orientation="horizontal"
		android:layout_width="fill_parent" android:layout_height="wrap_content">
		<TextView android:layout_width="wrap_content"
			android:layout_height="wrap_content" android:text="@string/numero" />
		<EditText android:id="@+id/numero" android:layout_width="fill_parent"
			android:layout_height="wrap_content" />
	</LinearLayout>
	<TextView android:layout_width="wrap_content"
		android:layout_height="wrap_content" android:text="@string/message" />
	<EditText android:id="@+id/message" android:layout_width="fill_parent"
		android:layout_height="200sp" />
	<Button android:id="@+id/envoyer" android:layout_width="fill_parent"
		android:layout_height="wrap_content" android:text="@string/envoyer" />
</LinearLayout>

Pas de panique si vous avez des erreurs c’est parce que vous n’avez pas créé les ressources String. Créez les ressources qu’il faut dans le fichier String.xml comme ceci :

<?xml version="1.0" encoding="utf-8"?>
<resources>
	<string name="numero">Numero</string>
	<string name="app_name">Envoie Sms</string>
	<string name="message">Message</string>
	<string name="envoyer">Envoyer</string>
</resources>

Code JAVA

Nous allons maintenant mettre en place le mécanisme d’envoi de SMS. Pour cela nous avons juste besoin d’utiliser un objet de type SmsManager.

Sans plus tarder éditons notre activité de départ EnvoieSms et insérer le code Java (commenté) suivant:

package com.sdiawara.envoiesms;
 
import android.app.Activity;
import android.os.Bundle;
import android.telephony.gsm.SmsManager;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;
 
public class EnvoieSms extends Activity {
 
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        //On récupère le bouton créer en XML grâce à son id
        Button btnEnvoie = (Button)findViewById(R.id.envoyer);
        //On récupère les deux EditText correspondant aux champs pour entrer le numéro et le message
        final EditText numero =(EditText)findViewById(R.id.numero);
        final EditText message = (EditText)findViewById(R.id.message);
        //On affecte un écouteur d'évènement au bouton
        btnEnvoie.setOnClickListener(new OnClickListener() {
 
			@SuppressWarnings("deprecation")
			public void onClick(View v) {
				//On récupère ce qui a été entré dans les EditText
				String num = numero.getText().toString();
				String msg = message.getText().toString();
				//Si le numéro est supérieur à 4 charactère et que le message n'est pas vide on lance la procédure d'envoi
				if(num.length()>= 4 && msg.length() > 0){
					//Grâce à l'objet de gestion de SMS (SmsManager) que l'on récupère grâce à la méthode static getDefault()
					//On envoit le SMS à l'aide de la méthode sendTextMessage
					SmsManager.getDefault().sendTextMessage(num, null, msg, null, null);
					//On efface les deux EditText
					numero.setText("");
					message.setText("");
				}else{
					//On affiche un petit message d'erreur dans un Toast
					Toast.makeText(EnvoieSms.this, "Enter le numero et/ou le message", Toast.LENGTH_SHORT).show();
				}
 
			}
		});
    }
}

AndroidManifest.xml

Voilà nous avons presque fini il nous reste juste à demander la permission d’envoyer des messages. Pour cela ouvrez le fichier AndroidManifest.xml et ajoutez cette ligne :

<uses-permission android:name="android.permission.SEND_SMS"></uses-permission>

Vous pouvez maintenant tester. Pour bien voir que ça marche nous allons utiliser deux émulateurs. Je suppose que vous en disposer déjà d’un , nous allons donc en créer un deuxième. Cliquez sur le menu Windows >>> Android SDK and AVD Manager. Ensuite cliquez sur New pour créer un nouvel émulateur, donnez lui le nom que vous voulez, cliquez sur Create AVD et sélectionnez ce nouvel émulateur puis cliquez sur Start. Il ne reste plus qu’a lancer votre projet avec l’un des émulateurs et à rentrer le numéro qui apparaît sur l’autre émulateur comme numéro du destinataire. Voilà tout devrait marcher normalement !

A bientôt pour un prochain tutoriel.

]]> http://www.tutomobile.fr/envoyer-un-sms-tutoriel-android-n%c2%b021/16/12/2010/feed/ 24 http://www.tutomobile.fr/envoyer-un-sms-tutoriel-android-n%c2%b021/16/12/2010/ http://feedproxy.google.com/~r/TutoMobileTutorielsAndroid/~3/cHCW51-JV1I/ http://www.tutomobile.fr/personnaliser-un-alertdialog-tutoriel-android-n%c2%b020/04/11/2010/#comments Thu, 04 Nov 2010 15:44:08 +0000 Axon http://www.tutomobile.fr/?p=1249 Voici un tuto qui va surement en aider plus d’un. Parfois lorsque vous développez vos applications Android je suis sûr que vous aimeriez créer une boite de dialogue (AlertDialog) un peu personnalisé en y ajoutant par exemple un EditText ou n’importe quoi d’autre. Pas facile de trouver un tuto clair sur ce sujet sur le net. Je vais donc tenter de vous expliquer comment personnaliser un AlertDialog facilement.

Créez votre projet Android (moi je suis encore et toujours sous Android 1.6) et attaquons notre tutorial. Nous allons faire un AlertDialog personnalisé avec un TextView et un EditText. Il n’y a rien de transcendant la dedans mais si vous comprenez cet exemple vous saurez faire tout ce que vous voudrez. Voici donc à quoi ressemblera notre AlertDialog :

Code XML

Pour commencer, créez un nouveau layout que vous allez appeler alertdialogperso.xml. C’est dans ce fichier que nous allons mettre tout ce qu’on souhaite voir dans notre AlertDialog personnalisé. Nous nous y mettons un TextView et un EditText l’un en dessous de l’autre. On obtient donc le code suivant :

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
  xmlns:android="http://schemas.android.com/apk/res/android"
  android:layout_width="fill_parent"
  android:layout_height="fill_parent"
  android:padding="15dip">
 
  <TextView
    android:id="@+id/TextView1"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Entrer quelque chose ci-dessous :"
    android:paddingBottom="10dip" />
 
  <EditText 
    android:id="@+id/EditText1"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:layout_below="@id/TextView1"  />
 
</RelativeLayout>

Code Java

Maintenant il suffit d’affecter ce layout à un AlertDialog grâce au code Java. Pour cela, nous allons utiliser la classe LayoutInflater qui va nous permettre de faire de notre layout un objet View qui sera alors affecté à l’AlertDialog grâce à la méthode setView(). Voici le code commenté :

package com.tutomobile.android.alertdialogperso;
 
import android.app.Activity;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.EditText;
import android.widget.Toast;
 
public class Tutoriel18_Android extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
 
        //On instancie notre layout en tant que View
        LayoutInflater factory = LayoutInflater.from(this);
        final View alertDialogView = factory.inflate(R.layout.alertdialogperso, null);
 
        //Création de l'AlertDialog
        AlertDialog.Builder adb = new AlertDialog.Builder(this);
 
        //On affecte la vue personnalisé que l'on a crée à notre AlertDialog
        adb.setView(alertDialogView);
 
        //On donne un titre à l'AlertDialog
        adb.setTitle("Titre de notre boite de dialogue");
 
        //On modifie l'icône de l'AlertDialog pour le fun ;)
        adb.setIcon(android.R.drawable.ic_dialog_alert);
 
        //On affecte un bouton "OK" à notre AlertDialog et on lui affecte un évènement
        adb.setPositiveButton("OK", new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int which) {
 
            	//Lorsque l'on cliquera sur le bouton "OK", on récupère l'EditText correspondant à notre vue personnalisée (cad à alertDialogView)
            	EditText et = (EditText)alertDialogView.findViewById(R.id.EditText1);
 
            	//On affiche dans un Toast le texte contenu dans l'EditText de notre AlertDialog
            	Toast.makeText(Tutoriel18_Android.this, et.getText(), Toast.LENGTH_SHORT).show();
          } });
 
        //On crée un bouton "Annuler" à notre AlertDialog et on lui affecte un évènement
        adb.setNegativeButton("Annuler", new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int which) {
            	//Lorsque l'on cliquera sur annuler on quittera l'application
            	finish();
          } });
        adb.show();
    }
}

Maintenant si vous lancez votre application vous devriez voir apparaître une boîte de dialogue similaire à celle présenté au début du tutoriel. Entrez quelque chose dans l’EditText puis cliquez sur « OK ». La boite de dialogue devrait se fermer et le texte que vous avez entré devrait apparaître dans un Toast, comme sur la capture d’écran ci-dessous. Si vous cliquez sur « Annuler », l’application doit se fermer normalement.

Vous êtes désormais capable de personnaliser comme vous le souhaitez un AlertDialog. Vous pouvez donc créez toutes les boîtes de dialogue que vous voulez. J’espère que ce petit tutoriel vous aura plus et surtout qu’il vous servira. Merci d’avance à tout ceux qui partegeront ce tuto sur Twitter et Facebook. Et n’oubliez pas de voter pour cet article si vous l’avez aimé, grâce au petit « + » en haut à gauche du tuto (à côté du coeur).