Affichage des articles dont le libellé est android. Afficher tous les articles
Affichage des articles dont le libellé est android. Afficher tous les articles

mardi 29 novembre 2011

Tutorial Android : Lancer un service au boot d'AndroId

Il est tout à fait possible dans Android de lancer une application au démarrage du système d'exploitation, sans fenêtre graphique (sans activité), sans icône de démarrage, uniquement en tâche de fond : il s'agit d'un service.

Le tutorial suivant vous propose un petit programme uniquement constitué de deux composants Android, sans aucune interface graphique :

- 1 service (il sera notre tâche de fond)
- 1 "broadcast receiver". Celui-ci recevra un "intent" nous avertissant que le démarrage du système est terminé. Il lancera ensuite le service.

Remarque : Ici on utilise le sdk Android 2.2.

Voici les différentes étapes pour créer un tel programme :

1. Créez un projet Android sans activité graphique :

Ne pas sélectionner la création d'une activité




















2. Créez une classe service comme ci-dessous :


public class MonService extends Service {

@Override
public void onDestroy() {
Log.v( "LTM","onDestroy" );
super.onDestroy();
}

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Log.v( "LTM","onStartCommand" );
return super.onStartCommand(intent, flags, startId);
}

@Override
public IBinder onBind( Intent arg0 ) {
Log.v( "LTM","onBind" );
return null;
}
}



3. Créez une classe "receiver" comme ci-dessous :


public class MyReceiver extends BroadcastReceiver {

@Override
public void onReceive( Context ctx, Intent i ) {
Log.v( "LTM", "MyReceiver.onReceive : " + i.getAction() );
Intent intent = new Intent( ctx, MonService.class );
ctx.startService(intent);
}
}


4. Mettre à jour le fichier manifeste : il vous faut évidemment indiquer les 2 composants crées dans le fichier manifeste : le service et le receiver.
Il est nécessaire également d'intégrer la permission ci-dessous.



<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.ltm.service"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk android:minSdkVersion="8" />

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

    <application
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name" >
        <service android:label="Mon beau service à moi" 
            android:name="MonService"
android:exported="false">
        service>
        <receiver
            android:name="MyReceiver">
<intent-filter>
                    <action android:name="android.intent.action.BOOT_COMPLETED" />
            intent-filter>
         receiver>
    application>
manifest>



5. Il ne vous reste plus qu'à compiler votre application et de la tester sur un périphérique.

Explications :
Notre application va recevoir l'intent 'BOOT_COMPLETED" via le receiver. Une fois cet événement reçu ce dernier lancera le service.

Et voilà, le tour est jouer !

A vous maintenant de jouer !

mardi 22 novembre 2011

Androïd : Activités, Services, Broadcast Receivers et Intents

Le développeur Android se doit de bien connaître le langage Java avant de se lancer dans l'aventure Androïd.

Une fois la chose faite, l'architecture Android offre des grands concepts, des composants dont il convient de bien saisir la philosophie.

J'ai nommé : Les activités, les services, les "Broadcast Receivers" et les Intents.


Les Intents :
Ce sont à mes yeux les composants les plus importants de l'architecture Android (si je dois trouver une chronologie dans les importances).

Les objets de type Intent permettant de faire communiquer vos activités entre elles, mais pas seulement : une activité communique des informations également à des services de cette manière.

Plus encore les objets intents permettant la communication des composants au sein de tout l'OS Android : Il existe des intents "standards" spécifiés par Google permettant de lancer : un lecteur PDF, un Browser Web, un appel téléphonique, etc. : C'est énorme au sein d'Androïd.

C'est un des concepts de base que Google(tm) a posé en créant Android : le concept de la ré utilisation de tous les composants des applications, la communication inter applications grâce aux intents.

Vous utiliserez donc un intent pour :
- Une activité de votre application lance une seconde activité de votre programme (ou d'un autre programme Android).
- Une activité de votre application lance un service de votre programme (ou d'un autre programme).
- Un broadcast receiver reçoit un intent de l'OS lui-même ou d'une autre application (type l'utilisateur vient de changer la langue ou le time zone).

Un intent est un objet qui est utilisé pour passer des paramètres (quelconques) d'un composant Android à un autre et ce, sans se pré occuper des processus et de leur gestion mémoire.


Les activités :
En fait une application Android de base est une suite d'activités, d'écrans. Les activités (classe : Activity) sont des écrans Android.

Pour changer d'écran dans votre programme, il s'agit généralement d'une activité qui en lance une autre. 
Exemple : L'activité 1 lance l'activité 2 suite au click (ou touche) sur un bouton.

Il vous faut voir l'activité comme un écran contenant des vues (View). Ces dernières sont en faits des contrôles tels que des boutons, champs, vue image, etc.

Une application Android est en fait une pile d'activités : ce qui explique que quand vous utilisez le bouton 'back' du périphérique, et s'il existe une activité précédente, vous revenez sur celle-ci.

Les activités une fois instanciées reste en mémoire la plupart du temps, ce qui a permet à l'utilisateur qui redemande le lancement d'une application de revenir en contexte.

Attention néanmoins : Android peut tuer vos activités en 'background'.

Les activités sont des composants graphique.


Les services :
Ce sont des tâches de fond, des objets qui une fois instanciés (via des intents), reste en 'background'. Ils peuvent survivre au composant (exemple : l'activité) qui les a lancé.

On peut démarrer un service ou l'arrêter, se lier à un service ou se séparer du service.

Il est aussi possible en l'associant à un broadcast receiver, de lancer un service au boot d'Android.

Attention au code qui tourne en tâche de fond = consommation électrique potentielle.

Les services ne sont pas des composants graphiques.


Les Broadcast receivers :
Ce sont des composants qui sont spécialisés pour recevoir des communications "broadcast" sous forme d'intents.

Les "receivers" vont donc écouter certains intents (grâce à <intent-filter>).

<receiver
    android:name="MyReceiver">
<intent-filter>
             <action android:name="android.intent.action.BOOT_COMPLETED" />
        intent-filter>
receiver>


Vous pouvez donc utiliser les receivers pour écouter des canaux de communication spécifiques comme l'OS lui-même : changement de langues, de paramètres, réception de sms, etc.

Les receivers ne sont pas des composants graphiques.



J'espère que ces explications vous aideront dans le développement de vos applications Android.

vendredi 11 novembre 2011

Transparency color with Android

How to get a transparency color in your Android Layout (or View) ?

<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="#FFFFFF"
    android:padding="5dp"
    android:fitsSystemWindows="true"
    android:id="@+id/scrollview1">

In the sample just above the background color is white and not transparent.

To transform this color like a transparent color, do like that :

<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="#80FFFFFF"
    android:padding="5dp"
    android:fitsSystemWindows="true"
    android:id="@+id/scrollview1">

Put the value 80 before the color !

Simple is Androïd.

mardi 8 novembre 2011

Générateurs d'icônes Android

Le développeur Android a souvent à créer des icônes (ou images) de différents formats :
Low dpi, Medium dpi, High dpi, X Hdpi.

Les formats les plus courants pour les icônes sont : 36x36 pixels, 48x48 pixels, 72x72 pixels.

Il convient donc d'avoir à disposition un logiciel permettant de recalculer des tailles d'images. On peut citer "gimp" (logiciel libre) ou Photoshop(tm).

Il existe chez Google(tm) un générateur d'icônes en ligne permettant de régler ce problème : Androïd Asset Studio.

Voir le site : Générateurs d'icônes pour développeur Android

mercredi 2 novembre 2011

Tutorial Android : Lire un fichier PDF de son application Androïd

Comment lire un fichier PDF de son application Android ?

Précaution : Une chose doit être claire et précisée : Dans notre application aucun code de lecture d'un fichier pdf est embarqué, nous utiliserons classiquement le travail entre application Androïd grâce aux intents.

Rappel : Un intent est un objet java qui permet de communiquer entre activités (ou services, broadcast receivers, ...). Dans le cas présent notre application appellera une activité lecteur pdf via un intent (Acrobat reader(tm) par exemple).

Il vous faut donc installer le lecteur PDF dans votre mobile en préalable. Je vous conseille 'acrobat reader' : le lecteur officiel.

Au cas où dans votre mobile plusieurs activités répondent à cet intent, au moment de l'ouverture Androïd vous demandera de choisir l'application.

1. Créez une application Android avec une seule activité.

2. Modifiez le fichier AndroidManifest.xml de manière à obtenir l'équivalent ci-dessous.
Remarque : Nous avons besoin de la permission internet pour lire via http. Si notre application ne lit pas de fichier sur le réseau, cette permission est inutile.

xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="ltm.test"
      android:versionCode="1"
      android:versionName="1.0">
    <uses-sdk android:minSdkVersion="8" />

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

    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <activity android:name=".ReadPDFActivity"
                  android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            intent-filter>
        activity>
    application>
manifest>


3. Le code ci-dessous décrit une activité, possédant un simple bouton. Sur l'événement click nous appellerons l'activité 'lecteur de fichier pdf'.

public class ReadPDFActivity extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        //
        Button b1 = (Button)findViewById( R.id.button1 );
        b1.setOnClickListener( new OnClickListener() {
@Override
public void onClick(View arg0) {
String surl = "http://dsn/rep/fichier.pdf";
String apptype = "application/pdf";
if( openURLWithType( surl, apptype ) == false)
        Toast.makeText( ReadPDFActivity.this, 
     "Echec de Open URL", Toast.LENGTH_LONG ).show();
}});
    }
    
    public boolean openURLWithType( String url, String type ) { 
        Uri uri = Uri.parse(url);
        Intent intent = new Intent( Intent.ACTION_VIEW, uri );
        intent.setDataAndType( uri, type );
        intent.setFlags( Intent.FLAG_ACTIVITY_CLEAR_TOP );
        try {
                ReadPDFActivity.this.startActivity(intent);
                return true;
        } catch (ActivityNotFoundException e) {
                Log.e( "LTM" ,"Activity not found: " + url, e);
        }
        return false;
    }
}


Quelques explications :
Tout se passe en fait dans la méthode openURLWithType(...) :

On crée un Intent avec une action Intent.ACTION_VIEW (spécifié dans le sdk Android).

On précise que notre Intent gère un type de donnée : application/pdf.

On utilise la classe Uri pour contenir notre url type : http://dsn/rep/fichier.pdf.

L'instruction startActivity(intent) cherche à lancer l'activité lecteur pdf. Si celle-ci est installée dans le device alors Androïd créera une instance de l'activité en question en lui passant l'Uri à afficher.

Vous devez donc gérer l'exception ActivityNotFoundException au cas où le lecteur n'est pas installé.

mardi 1 novembre 2011

Tutorial Android : Programmation du copier coller, du clipboard

Programmation Android du copier coller, copy paste :

Précautions : On utilise ici les APIs Android 3.0 ou plus. Nous copierons dans ce tutorial du format texte, il est également possible de copier des URIs, des Intents.








Notre petite application constituée de 2 champs et de 2 boutons permet dans le champ supérieur de saisir un texte, grâce au bouton "copy" de copier le texte dans le "clipboard". Ensuite grâce au bouton "Paste" on extrait le texte du "clipboard" et on le copiera dans le champ en bas du formulaire.


1. Le ClipboardManager

ClipboardManager clipboard;
clipboard = (ClipboardManager)getSystemService( this.CLIPBOARD_SERVICE );

Celui-ci va nous donner accès au "clipboard".


2. On copie le texte du premier champ pour le mettre dans le "clipboard"

ClipData clip = ClipData.newPlainText( "texte_copied",    
          edit_source.getText().toString() );
clipboard.setPrimaryClip( clip );


3. On extrait le texte du "clipboard" pour le copier dans le champ inférieur

if (clipboard.hasPrimaryClip()) {
    ClipData.Item item = clipboard.getPrimaryClip().getItemAt(0);
    CharSequence pasteData = item.getText();
    if( pasteData != null )
edit_target.setText( pasteData );
}


4. Rien de spécifique à prévoir dans le fichier AndroidManifest.xml


Voici le source de l'activité en entier :

public class CopyPaste_ltmActivity extends Activity {
    Button btn_copy;
    Button btn_paste;
    EditText edit_source;
    EditText edit_target;
    ClipboardManager clipboard;
    ClipData clip;
   @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        btn_copy = (Button)findViewById( R.id.btn_copy );
        btn_paste = (Button)findViewById( R.id.btn_paste );
        edit_source = (EditText)findViewById( R.id.editSource );
        edit_target = (EditText)findViewById( R.id.editTarget );
        
        clipboard = (ClipboardManager)getSystemService( this.CLIPBOARD_SERVICE );
        
        // copy button
        btn_copy.setOnClickListener( new OnClickListener() {
@Override
public void onClick(View v) {
    ClipData clip = ClipData.newPlainText( "texte_copied",                          
                  edit_source.getText().toString() );           
            clipboard.setPrimaryClip( clip );
}
});
        
        // paste button
        btn_paste.setOnClickListener( new OnClickListener() {
@Override
public void onClick(View v) {
            if (clipboard.hasPrimaryClip()) {
ClipData.Item item = clipboard.getPrimaryClip().getItemAt(0);
CharSequence pasteData = item.getText();
if( pasteData != null )
edit_target.setText( pasteData );
    }
}});
    }
}

Tutorial Android : Appeler le navigateur internet à partir d'une activité

Aujourd'hui notre objectif est d'expliquer comment d'une application Android, d'une activité, il est possible d'appeler le navigateur internet à partir d'une URL.

Nous utiliserons pour ce faire un Intent avec deux paramètres spécifiques : une action et une URL.

Sous Android il est très simple d'invoquer les activités d'autres applications sous réserve que celles-ci aient prévues de répondre aux actions de nos intents.

Les lignes de code ont les suivantes :

String url = "http://bertrandleclercq.blogspot.com/search/label/android";
Intent intent = new Intent( Intent.ACTION_VIEW, Uri.parse( url ) );
startActivity(intent);

Explications : 
Nous créons ci-dessus un objet intent avec une action spécifique définie dans le SDK Android Intent.ACTION_VIEW et le paramètre http://www.xxxx : cela suffit à android pour appeler l'activité navigateur internet.
Magique non ?


Attention : Ne pas oublier de donner la permission internet, nécessaire dans le fichier AndroidManifest.xml :

xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.ltm.browser"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk android:minSdkVersion="8" />
    <uses-permission android:name="android.permission.INTERNET"/>

    <application
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name" >
        <activity
            android:label="@string/app_name"
            android:name=".CallInternetBrowserActivity" >
            <intent-filter >
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            intent-filter>
        activity>
    application>
manifest>


Voici le lien SDK que propose Android pour lancer les applications standards du système : les intents lançant les applications Androïd.

Tutorial Android : Développer une application passant un appel téléphonique

Voici un petit tutorial permettant de développer une application Android qui passe un appel téléphonique.

Pour ce faire, nous allons utiliser un Intent standard dans Androïd : Intent.ACTION_CALL, 
et utiliser un écouteur : PhoneStateListener, pour recevoir les événements permettant de suivre l'état de l'appel.

Pour passer un appel :

String n = "tel:5556";
Intent intent = new Intent( Intent.ACTION_CALL, Uri.parse( n ) );
startActivity( intent );

Ci-dessus on utilise l'intent avec en paramètre le numéro à appeler précédé de "tel:".

Pour suivre l'état de la communication on utilise un listener comme ci-dessous :





class TelListener extends PhoneStateListener {
    @Override
    public void onCallStateChanged(int state, String numero ) {
if(TelephonyManager.CALL_STATE_RINGING == state) 
           Log.i("LTM", "RINGING, numéro: " + numero);
            
        if(TelephonyManager.CALL_STATE_OFFHOOK == state) 
           Log.i("LTM", "OFFHOOK");
            
        if(TelephonyManager.CALL_STATE_IDLE == state) 
           Log.i("LTM", "IDLE");
            
super.onCallStateChanged(state, numero);
    }
}

Pour enregistrer l'écouteur décrit ci-avant on utilise le code suivant :

TelephonyManager manager = (TelephonyManager)this.getSystemService( 
  this.TELEPHONY_SERVICE );
manager.listen( new TelListener(), PhoneStateListener.LISTEN_CALL_STATE );


Exemple d'application Android passant un appel téléphonique :











Voici le source de l'activité (la vue) en entier :

















vendredi 28 octobre 2011

Tutorial Android : Installer le SDK et Eclipse ADP

Installer le SDK Android est une opération assez longue, prévoyez quelques heures pour ce faire.


Au menu : Eclipse l'IDE et Java.

1. Installez le JDK Java (par exemple la version 6), le jre ne sufft pas.

2. Installez ECLIPSE : http://www.eclipse.org/downloads/

3. Installez sur le disque dur le SDK Android : http://developer.android.com/sdk/index.html

4. Lancer Eclipse. Dans les préférences d'Eclipse indiquer où se trouve le SDK Androïd.

5. Installez le plug in Eclipse : ADT: Plug in ADT pour Eclipse

6. Dans Eclipse cliquez sur l'icône AVD Manager et mettez à jour les composants du SDK Androïd (procédure longue et un peu laborieuse). 

En fait une fois le plug in installé, vous mettrez à jour périodiquement les bibliothèques et les outils Google(tm) en cliquant sur cette icône. A noter que Google(tm) se proposera de charger tous les niveaux de SDK (de la version 2 jusqu'à la dernière version 4).

A noter : En ce qui concerne la dernière version 4.0 d'Android (Ice scream sandwitch), 2 icônes sont ajoutés dans la barre d'outils d'Eclipse, l'une pour mettre à jour le SDK, l'autre pour lancer les émulateurs de mobiles.

7. De manière à tester votre installation, essayez de lancer un émulateur : cliquez sur l'icône dans Eclipse, créez un nouveau "device" et après cliquez le bouton "start".
ici l'AVD Manager avant le sdk 4













8. Tester une activité de base dans Android pour vérifier si l'installation est correcte : Créez un projet Android avec un écran de base (appelé Activity).

vendredi 1 juillet 2011

PhoneGap ou développer Multiplateforme sur Mobile

Un des plus gros soucis rencontré actuellement concernant le développement mobile est l'aspect multiplateforme.

C'est un vrai casse tête pour le développeur : pas de Java sur iOS, pas de Flash. L'environnement de développement XCode pour iOS nécessite un MAC et de connaître le langage Objective-C : bref que du bonheur !

PhoneGap est un projet permettant de développement simplement des applications pour mobile avec un seul code.

C'est ici : http://www.phonegap.com

Un wiki pour les développeurs c'est ici : http://wiki.phonegap.com

Un bon tutorial montrant comment développer son IHM c'est ici : http://www.sencha.com/learn/Tutorial:Sencha_Touch_PhoneGap

Au rendez-vous technique : HTML5, JavaScript, extensions PhoneGap, etc.

Bref que du bonheur !

vendredi 29 avril 2011

Déboguer avec un device réel en développant sous Androïd


Sous Windows :

1. Télécharger le driver USB du site du constructeur du device.

2. Obtenir le code vendor du constructeur. Exemple : Archos = 0xE79

3. Vous trouverez sur le disque (en général c:/users/nom_de_user/.android), un fichier adb_usb.ini
Editez ce fichier et ajoutez sur la dernière ligne le code vendeur : "0xE79"

4. Prenez une console, mettez-vous sous le répertoire du SDK Android :
Tapez : adb kill-server, adb start-server, adb devices
Dans la liste qui apparaît vous devez voir votre device réel.

samedi 19 mars 2011

Le serveur HTTP réponds-t-il ?

Concernant le protocole HTTP et si vous programmez des applications avec les APIs Apache(tm), par exemple en développant des applications Androïd, une recette simple et souvent à utiliser est :
Comment faire pour savoir si le serveur HTTP retourne un code réponse 200 (OK) , ou au contraire une réponse KO (exemple : erreur bien connue 404).

Voici un exemple de code qui permet de constater la réponse du serveur HTTP :


Exemple issu d'un code java Androïd














Le code ci-dessus utilise les APIs Apache(tm) : org.apache.http.HttpEntity;

dimanche 20 février 2011

Développement Androïd - le réseau est-il actif ?

Sur un mobile ou une tablette Androïd il est courant d’accéder à des services en réseau.

La plupart du temps votre mobile est connecté soit au 3G, soit au WIFI. Il arrive néanmoins que votre mobile perde le réseau : dans ce cas il est utile de tester la présence de votre réseau, sous peine d'erreur.

Voici un petit code utile qui vous permet de tester l'état de votre mobile en terme de connexion à un réseau.


public class NetworkTest1 extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
      
        // Accèder au service de connectivité
        String service = this.CONNECTIVITY_SERVICE;
        Log.v( "LTM", service );
        ConnectivityManager connectivity = (ConnectivityManager)getSystemService( service );
        //boolean b = connectivity.getBackgroundDataSetting();
      
        NetworkInfo activeNetwork = connectivity.getActiveNetworkInfo();
        if( activeNetwork == null ){
         Toast.makeText( this, "Le réseau n'est pas actif", Toast.LENGTH_LONG ).show();
        }else {
         int type = activeNetwork.getType();
         Toast.makeText( this, "type = " + type, Toast.LENGTH_LONG ).show();
        }
      
        // Spécifier que le réseau en question est de type WIFI
        int network = ConnectivityManager.TYPE_WIFI;
        NetworkInfo mobileNetwork = connectivity.getNetworkInfo(network);
      
        // Ici on obtient l'état : CONNECTED, DISCONNECTED, etc.
        NetworkInfo.State state = mobileNetwork.getState();
        NetworkInfo.DetailedState d_state = mobileNetwork.getDetailedState();
      
        // On affiche l'état du réseau dans un Toast !
        Toast.makeText( this, state.name(), Toast.LENGTH_LONG ).show();
    }
}

mercredi 5 janvier 2011

Androïd OS et SDK Androïd

Androïd est le système d'exploitation pour mobiles de Google.

Les smart phones tel que certains Samsung (Galaxy) ou les tablettes telles que : Archos ou la Galaxy Tab de Samsung fonctionnent à base de ce système.

Le modèle de l'OS proposé par Google est particulièrement judicieux et novateur.















Le modèle de l'OS est basé sur un noyau Linux sur lequel fonctionne une machine virtuelle assez novatrice appelée Dalvik.

Le développeur d'applications Androïd est isolé des processus Linux et manipule des composants de plus haut niveau appelés : Activity, services, application, broadcast receivers, intents, ContentProvider, etc. (voir le slide ci-avant).

Le modèle de programmation est disponible en Java (SDK Androïd) et en C (NDK).

Eclipse ADP est disponibles en bundle avec tout ce qu'il faut pour développer en java.

Le portail pour les développeurs c'est ici.

Le modèle de programmation et les concepts de l'architecture sont particulièrement bien expliqués ici.

J'anime désormais un cours sur le développement Androïd, le programme de ce cours c'est ici.