Vous êtes sur la page 1sur 21

Les ressources du téléphone

Les alarmes
Une alarme est utilisée pour déclencher un Intent à intervalles réguliers. Le système qui gère
les alarmes est AlarmManager. On peut le récupérer avec
context.getSystemService(Context.ALARM_SERVICE).

Il y a deux types d'alarme : les alarmes uniques et les alarmes qui se répètent.

Les alarmes uniques


S'utilisent avec la méthode set(int type, long triggerAtMillis, PendingIntent pending)
sur l'AlarmManager.
 triggerAtMillis : définit à quel moment l'alarme se lancera.
 type : définit le comportement de l'alarme vis à vis du paramètre triggerAtMillis.
Moment de déclenchement (le 30 mars à 08:52) ou dans combien de temps elle doit se
déclencher (dans 25 minutes et 55 secondes) ?

Pour définir une date exacte on utilise comme type la constante RTC et pour un compte à rebours
on utilise ELAPSED_REALTIME.

Pour une alarme qui se lance maintenant :


AlarmManager mgr = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
mgr.set(RTC, System.currentTimeMillis(), pending);

Exemple
AlarmManager alarmeManager = (AlarmManager) getSystemService(ALARM_SERVICE);
Intent intentAlarme = new Intent(Intent.ACTION_DIAL);
PendingIntent intentAlarmeSuspend = PendingIntent.getBroadcast(this, 0, intentAlarme, 0);

// Création d’une alarme à partir d’un délai ayant pour référence le dernier démarrage de l’appareil.
alarmeManager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, 60L * 1000L * 2L,
intentAlarmeSuspend);

// Création d’une alarme utilisant une heure précise pour se lancer dans 2 heures après l’appel de cette méthode.
alarmeManager.set(AlarmManager.RTC_WAKEUP, System.currentTimeMillis() + (60 *1000 * 2),
intentAlarmeSuspend);
public class MainActivity extends AppCompatActivity {
NotificationCompat.Builder notification_builder;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
public void serv1 (View v) {
Intent intent = new Intent(this, MyReceiver.class);
PendingIntent pendingIntent =
PendingIntent.getBroadcast(this.getApplicationContext(), 234324243, intent, 0);

AlarmManager alarmManager = (AlarmManager) getSystemService(ALARM_SERVICE);


alarmManager.set(AlarmManager.RTC_WAKEUP,System.currentTimeMillis() + 1000,
pendingIntent);
Toast.makeText(this, "Alarm set in " + 1 + "seconds",Toast.LENGTH_LONG).show();
}
public class MyReceiver extends BroadcastReceiver {
MediaPlayer mp;
public void onReceive(Context context, Intent intent) {
mp= MediaPlayer.create(context, R.raw.track01);
mp.start();
Toast.makeText(context, "Alarm....", Toast.LENGTH_LONG).show();
}
}

Exemple : Alarme qui se lancera pour un anniversaire

1
Calendar calendar = Calendar.getInstance();
// N'oubliez pas que les mois commencent à 0, contrairement aux jours !
calendar.set(1987, 4, 10, 17, 35);
manager.set(RTC_WAKEUP, calendar.getTimeInMillis(), pending);

Exemple : Alarme qui se lance dans 20 minutes et 50 secondes :


calendar.set(Calendar.MINUTE, 20);
calendar.set(Calendar.SECOND, 50);
manager.set(ELAPSED_REALTIME, calendar.getTimeInMillis(), pending);

Les alarmes récurrentes


Pour définir une alarme récurrente :
setRepeating(int type, long triggerAtMillis, long intervalMillis, PendingIntent pending)

intervalMillis : l'intervalle entre deux alarmes.

On peut avoir n'importe quelle durée, mais il y a des constantes qui peuvent nous aider :
 INTERVAL_FIFTEEN_MINUTES : un quart d'heure.
 INTERVAL_HALF_HOUR : une demi-heure.
 INTERVAL_HOUR : une heure.
 INTERVAL_HALF_DAY : 12 heures.
 INTERVAL_DAY : 24 heures.
 INTERVAL_DAY * 7 : pour une semaine

Répétition chaque 20mn


manager.setRepeating(AlarmManager.RTC_WAKEUP,calendar.getTimeInMillis(),1000 * 60 * 20,
alarmIntent);
manager.setInexactRepeating(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis(),
AlarmManager.INTERVAL_DAY, alarmIntent);

Annuler une alarme


void cancel(PendingIntent operation).

Listening audio
public class MainActivity extends AppCompatActivity {
Button play, stop;
MediaPlayer mediaPlayer;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
play = findViewById(R.id.btn_play);
stop = findViewById(R.id.btn_stop);

play.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mediaPlayer = MediaPlayer.create(getApplicationContext(), R.raw.chanson);

mediaPlayer.start();
}
});
stop.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (mediaPlayer != null)

2
mediaPlayer.stop();
}
});
}}

video
public class VideoPlay extends Activity {
VideoView videoView;
Button play;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_video);
videoView = (VideoView) findViewById(R.id.videoView);
play = (Button) findViewById(R.id.playVideo);
}

public void videoPlay(View view){


String path = "android.resource://"+getPackageName()+"/"+R.raw.vd1;
Uri uri = Uri.parse(path);
videoView.setVideoURI(uri);
videoView.start();
}

Caméra

L'appareil photo est principalement utilisé pour capturer des images et des vidéos.
Nous pouvons contrôler la caméra en utilisant des méthodes d'API caméra.

Android offre la possibilité de travailler sur l'appareil photo de 2 façons:

1. Par caméra intent


2. Par Camera API

Les classes de base de Camera Intent et de camera API


Nous allons principalement discuter quatre classes, Intent, Camera, SurfaceView,
mediaRecorder.

 Vérifier si un terminal posséde une caméra

/** Check if this device has a camera */


private boolean checkCameraHardware(Context context) {
if(context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_C
AMERA)){
// this device has a camera
return true;
} else {
// no camera on this device
return false;
}
}

3
 Camera.getNumberOfCameras

Les appareils Android peuvent avoir plusieurs appareils photo, par exemple un appareil
photo arrière pour la photographie et un appareil photo avant pour les appels vidéo.

Android 2.3 (API niveau 9) et versions ultérieures permettent de vérifier le nombre de


caméras disponibles sur un appareil à l'aide de la méthode
Camera.getNumberOfCameras ().

 Accéder aux caméras

Par la Classe Camera

Il s'agit de la classe principale de l'API de l'appareil photo, qui peut être utilisée pour
prendre des photos et des vidéos.

Si l'appareil possède une caméra, vous pouvez y accéder en obtenant une instance de la
classe Camera.

Pour accéder à la caméra principale, utilisez la méthode Camera.open () et veillez à


intercepter toutes les exceptions :

/** A safe way to get an instance of the Camera object. */


public static Camera getCameraInstance(){
    Camera c = null;
    try {
        c = Camera.open(); // attempt to get a Camera instance
    }
    catch (Exception e){
        // Camera is not available (in use or does not exist)
    }
    return c; // returns null if camera is unavailable
}

Par Intent

À l'aide de 2 constantes de la classe MediaStore , nous pouvons capturer des images et


des vidéos sans utiliser l'instance de la classe Camera.

1. ACTION_IMAGE_CAPTURE
2. ACTION_VIDEO_CAPTURE

SurfaceView

Représente un aperçu de la surface de la caméra en direct.

4
MediaRecorder

Utilisé pour enregistrer des vidéos à l'aide d'une caméra. Il peut également être utilisé
pour enregistrer des fichiers audios.

Exemple : capturer une image par intent

Avant toute chose, il faut prévoir dans le manifest la permission nécessaire i.e.
android.permission.CAMERA. Ensuite les grandes étapes sont les suivantes:

public class MainActivity extends AppCompatActivity {


Button btnTake;
ImageView imgView;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

btnTake = findViewById(R.id.btn_take);
imgView = findViewById(R.id.img_view);

btnTake.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent takePictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
//Intent takePictureIntent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);

if (takePictureIntent.resolveActivity(getPackageManager()) != null) {
startActivityForResult(takePictureIntent, 1);
}
}
});
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent
data) {
if (requestCode == 1 && resultCode == RESULT_OK) {
Bundle extras = data.getExtras();
Bitmap imageBitmap = (Bitmap) extras.get("data");
imgView.setImageBitmap(imageBitmap);
}}}

Téléphonie
Les fonctions de téléphonie permettent de récupérer l'état de la fonction de téléphonie (appel
en cours, appel entrant, ...), permettent d'être notifié lors d'un changement d'état, de passer
des appels et de gérer l'envoi et réception de SMS.

L'état de la téléphonie est géré par la classe TelephonyManager qui permet de récupérer le
nom de l'opérateur, du téléphone, et l'état du téléphone.

5
Pour lire ces informations, il est nécessaire de disposer de la permission
android.permission.CALL_PHONE.

Exemple
TelephonyManager tel =
(TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
int etat = tel.getCallState();
if (etat == TelephonyManager.CALL_STATE_IDLE)
// RAS
if (etat == TelephonyManager.CALL_STATE_RINGING)
// Le téléphone sonne
String SIMnb = tel.getSimSerialNumber();

Exemple : Récupération de l'état du téléphone


public class MainActivity extends Activity {
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

TelephonyManager telephonyManager =
(TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);

PhoneStateListener callStateListener = new PhoneStateListener() {


public void onCallStateChanged(int state, String incomingNumber){
if(state==TelephonyManager.CALL_STATE_RINGING){
Toast.makeText(getApplicationContext(),"Phone Is Riging",Toast.LENGTH_LONG).show();
}
if(state==TelephonyManager.CALL_STATE_OFFHOOK){
Toast.makeText(getApplicationContext(),"in call",Toast.LENGTH_LONG).show();
}
if(state==TelephonyManager.CALL_STATE_IDLE){
Toast.makeText(getApplicationContext(),"phone is neither ringing nor in a
call", Toast.LENGTH_LONG).show();
}
}
};
telephonyManager.listen(callStateListener,PhoneStateListener.LISTEN_CALL_STATE);
}

Passer un appel
Pour passer un appel, on utilise un Intent.

Exemple
Uri telnumber = Uri.parse("tel:0248484000");
Intent call = new Intent(Intent.ACTION_CALL, telnumber);
startActivity(call);

public void onClick(View arg0) {


String number=edittext1.getText().toString();
Intent i = new Intent(Intent.ACTION_DIAL);
i.setData(Uri.parse("tel:"+number));
startActivity(i);
}

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

6
http://www.javatpoint.com/how-to-make-a-phone-call-in-android

Envoyer et recevoir des SMS


Si la permission android.permission.SEND_SMS est disponible, il est possible d'envoyer des SMS
au travers de SmsManager:

Envoyer un SMS
public void onClick(View view) {
SmsManager manager = SmsManager.getDeault();
manager.sendTextMessage("06664840000", null, "Coucou !", null, null);
}}
Reception d'un SMS
Inversement, il est possible de créer un filtre d'Intent pour recevoir un SMS qui sera géré par un
broadcast receiver.

En fait, il s'agit de définir l'application comme pouvant recevoir des SMS.


Tout d'abord poser une permission dans le fichier AndroidManifest.xml:
<uses-permission android:name="android.permission.RECEIVE_SMS"/>

Puis déclarer un broadcast receiver sur les SMS via le filtre d'intention:
L'action à préciser dans le filtre d'Intent est android.provider.Telephony.SMS_RECEIVED:

<receiver android:name=".SMSBroadcastReceiver">
<intent-filter>
<action android:name="android.provider.Telephony.SMS_RECEIVED"/>
</intent-filter>
</receiver>

La classe broadcast receiver :


L'information se trouvant dans le Bundle (extra) est composée du SMS, un SMS étant stocké
sous forme de PDUs (Protocol Data Units).
Pour récupérer les PDUs, il faut utiliser la clef "pdus" sur le Bundle.
Celui-ci va retourner un tableau d'Objets. Ces instances qu'il faudra convertir en SmsMessage
pour pouvoir les traiter. La conversion se fera à l'aide la méthode
SmsMessage.createFromPdu():

public final class MyBroadcastReceiver extends BroadcastReceiver {


public void onReceive(Context context, Intent intent) {
if(intent.getAction().equals(android.provider.Telephony.SMS_RECEIVED)) {
Object[] pdus = (Object[])intent.getExtras().get("pdus");
SmsMessage[] messages = new SmsMessage[pdus.length];
for (int i=0; i < pdus.length; i++)
messages[i] = SmsMessage.createFromPdu((byte[]) pdus[i]);
msg = messages[i].getDisplayMessageBody();
}

Envoyer un Email
Intent email = new Intent(Intent.ACTION_SEND);
email.putExtra(Intent.EXTRA_EMAIL, new String[]{ to});
email.putExtra(Intent.EXTRA_SUBJECT, subject);
email.putExtra(Intent.EXTRA_TEXT, message);

7
//need this to prompts email client only
email.setType("message/rfc822");

startActivity(Intent.createChooser(email, "Choose an Email client :"));

Bluetooth Android
Le Bluetooth est un moyen d'échanger des données avec d'autres appareils sans fil.
Android fournit une API Bluetooth pour effectuer plusieurs tâches telles que:

o analyser les appareils Bluetooth


o connecter et transférer des données depuis et vers d'autres appareils
o gérer plusieurs connexions, etc.

Le package android.bluetooth fournit un grand nombre de classes d'interfaces pour


fonctionner avec Bluetooth, telles que:

o BluetoothAdapter
o BluetoothDevice
o BluetoothSocket
o BluetoothServerSocket
o BluetoothClass
o BluetoothProfile
o BluetoothProfile.ServiceListener
o Oreillette Bluetooth
o BluetoothA2dp
o BluetoothHealth
o BluetoothHealthCallback
o BluetoothHealthAppConfiguration

Classe BluetoothAdapter
À l'aide de la classe BluetoothAdapter, nous pouvons effectuer des tâches fondamentales
telles que lancer la découverte de périphériques, interroger une liste de périphériques
couplés (liés), créer une instance BluetoothServerSocket pour écouter les demandes de
connexion, etc.

Constantes de la classe BluetoothAdapter

La classe BluetoothAdapter fournit de nombreuses constantes comme :

8
o Chaîne ACTION_REQUEST_ENABLE
o Chaîne ACTION_REQUEST_DISCOVERABLE
o Chaîne ACTION_DISCOVERY_STARTED
o Chaîne ACTION_DISCOVERY_FINISHED

Méthodes de la classe BluetoothAdapter

Les méthodes couramment utilisées de la classe BluetoothAdapter sont les suivantes:

o BluetoothAdapter synchronised statique getDefaultAdapter () renvoie


l'instance de BluetoothAdapter.
o boolean enable () active l'adaptateur bluetooth s'il est désactivé.
o boolean isEnabled () renvoie true si l'adaptateur Bluetooth est activé.
o boolean disable () désactive l'adaptateur bluetooth s'il est activé.
o String getName () renvoie le nom de l'adaptateur Bluetooth.
o boolean setName (String name) change le nom bluetooth.
o int getState () renvoie l'état actuel de l'adaptateur Bluetooth local.
o Set <BluetoothDevice> getBondedDevices () renvoie un ensemble d'objets
BluetoothDevice appariés (liés).
o boolean startDiscovery () démarre le processus de découverte.

Exemple : activer, désactiver et rendre le bluetooth détectable

Fournir la permission dans le fichier AndroidManifest.xml.


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

BluetoothAdapter final mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter ();


if (mBluetoothAdapter == null ) {
out.setText ( "périphérique non pris en charge" );
}
button1.setOnClickListener ( nouveau View.OnClickListener () {
public void onClick (View v) {
if (! mBluetoothAdapter.isEnabled ()) {
Intent enableBtIntent = new Intent (BluetoothAdapter.ACTION_REQUEST_ENABLE);
startActivityForResult (enableBtIntent, REQUEST_ENABLE_BT);
}
}
});

9
button2.setOnClickListener ( nouveau View.OnClickListener () {
@Passer outre
public void onClick (Voir arg0) {
if (! mBluetoothAdapter.isDiscovering ()) {
Toast.makeText (getApplicationContext (), "rendre votre appareil découvert",
Toast.LENGTH_LONG).show;

Intent enableBtIntent= new Intent (BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);


startActivityForResult (enableBtIntent, REQUEST_DISCOVERABLE_BT);
}
}
});
button3.setOnClickListener ( nouveau View.OnClickListener () {
@Passer outre
public void onClick (Voir arg0) {
mBluetoothAdapter.disable ();
Toast.makeText (getApplicationContext (), "TURNING_OFF BLUETOOTH" ,
Toast.LENGTH_LONG);

}
});
}

Le web
Afficher des pages Web
Pour afficher une page Web ou faire une interface graphique à l'aide de HTML on peut utiliser la vue WebView,
commandée par WebKit, un moteur de page Web qui fournit des méthodes pratiques pour récupérer des pages
sur internet, effectuer des recherches dans la page, etc.

Charger directement du HTML


Pour insérer des données HTML sous forme textuelle, on utilise
void loadData(String data, String mimeType, String encoding)

Avec data les données HTML, mimeType le type MIME (en général text/html) et l'encodage défini dans
encoding.

public class WebViewActivity extends Activity {


private WebView myWebView = null;

public void onCreate(Bundle savedInstanceState) {


super.onCreate(savedInstanceState);
setContentView(R.layout.activity_web_view);
myWebView = (WebView) findViewById(R.id.webview);
myWebView.loadData("<html><head><meta charset=\"utf-8\" /></head>" + "<body>Salut les jeunes !</body></html>", "text/html", "UTF-
8");
}
}
N'oubliez pas de préciser l'encodage dans l'en-tête, sinon les accents ne passeront pas.

Charger une page sur internet


La première chose à faire est de demander la permission dans le Manifest pour aller sur internet:
<uses-permission android:name="android.permission.INTERNET" />

10
Puis on charge le contenu avec void loadUrl(String url).

public void onCreate(Bundle savedInstanceState) {


super.onCreate(savedInstanceState);
setContentView(R.layout.activity_web_view);
myWebView = (WebView) findViewById(R.id.webview);
myWebView.loadUrl("http://www.google.com");
}

Effectuer des requêtes http


Préciser l'URL.
URL url = new URL("http://www.google.com")
Toutes les requêtes HTTP devront se faire dans un thread différent du thread UI, puisqu'il
s'agit de processus lents.

Ensuite ouvrir une connexion vers cette URL avec la méthode URLConnection
openConnection().

URLConnection est une classe permettant de lire et écrire depuis une URL.
URLConnection urlConnection = url.openConnection();
HttpURLConnection httpUrlConnection = (HttpURLConnection) urlConnection; //conversion vers http
Pour lire des données on utilise la méthode InputStream getInputStream().

Pour vérifier le code de réponse fourni par le serveur HTTP utiliser la méthode
getResponseCode() :
if (httpConnection.getResponseCode() == HttpURLConnection.HTTP_OK) {
InputStream stream = httpConnection.getInputStream();
stream.read();
}
Pour effectuer des requêtes sortantes vers un serveur, il faudra utiliser la méthode
setDoOutput(true) sur un objet HttpURLConnection afin d'autoriser les flux sortants.

Ensuite, si vous connaissez la taille des paquets à transmettre, utilisez void


setFixedLengthStreamingMode(int contentLength) pour optimiser la procédure, avec
contentLength la taille des paquets.
Si non utilisez setChunkedStreamingMode(0) qui va séparer votre requête en paquets d'une
taille définie par le système.

Exemple
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setDoOutput(true);
connection.setChunkedStreamingMode(0);
OutputStream stream = new BufferedOutputStream(connection.getOutputStream());
writeStream(stream );

Pour finir, comme pour n'importe quel flux, il faut se déconnecter avec void disconnect().

L'un des bugs rencontrés le plus souvent est que, vous demandez de fermer un flux, mais
Android ne le fera pas.
Pour passer ce problème désactiver une fonctionnalité du système qui permet de contourner le
problème : System.setProperty("http.keepAlive", "false");

Exemple : application qui envoie des données à une adresse et récupère ensuite la réponse
System.setProperty("http.keepAlive", "false");

11
OutputStreamWriter writer = null;
BufferedReader reader = null;
URLConnection connexion = null;
try {
// Encodage des paramètres de la requête
String donnees = URLEncoder.encode("identifiant1", "UTF-8")+ "="+URLEncoder.encode("valeur1", "UTF-
8");
donnees += "&"+URLEncoder.encode("identifiant2", "UTF-8")+ "=" + URLEncoder.encode("valeur2", "UTF-
8");
// On a envoyé les données à une adresse distante
URL url = new URL(une_adresse);
connexion = url.openConnection();
connexion.setDoOutput(true);
connexion.setChunkedStreamingMode(0);

// On envoie la requête
writer = new OutputStreamWriter(connexion.getOutputStream());
// On insère les données dans notre flux
writer.write(donnees);
// Et on s'assure que le flux est vidé
writer.flush();
// On lit la réponse
reader = new BufferedReader(new InputStreamReader(connexion.getInputStream()));

String ligne;
// Tant que « ligne » n'est pas null, c'est que le flux n'a pas terminé d'envoyer des informations
while ((ligne = reader.readLine()) != null) {
afficher(ligne);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try{writer.close();}catch(Exception e){}
try{reader.close();}catch(Exception e){}
try{connexion.disconnect();}catch(Exception e){}
}

12
Réseau et connexion
Le réseau peut être disponible ou indisponible, suivant que le téléphone utilise une connexion Wifi,
3G, bluetooth, etc. si la permission android.permission.ACCESS_NETWORK_STATE est déclarée.
Pour cela, nous avons besoin de demander la permission au système dans le Manifest :

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

Il existe deux classes qui permettent d'obtenir des informations sur l'état du réseau.
 ConnectivityManager pour avoir des informations sur sa disponibilité de manière générale.
 NetworkInfo pour avoir des informations sur l'état de l'une des interfaces réseau (réseau mobile ou le
WiFi).
 getSystemService : ConnectivityManager getSystemService(Context.CONNECTIVITY_SERVICE) :
pour récupérer le gestionnaire de connexions dans un Context.

Pour savoir quelle est l'interface active, on utilise la méthode getActiveNetworkInfo(). Si aucun réseau n'est
disponible, cette méthode renvoie null.

 Pour vérifier l'état de chaque interface on utilise la classe NetworkInfo avec les méthodes :
getNetworkInfo(ConnectivityManager.TYPE_WIFI)
getNetworkInfo(ConnectivityManager.TYPE_MOBILE) pour le réseau mobile.

Enfin, il est possible de demander à un NetworkInfo s'il est connecté à l'aide de la méthode boolean isAvailable()
:

La classe NetworkInfo permet de lire l'état de la connexion réseau parmi les constantes de
la classe State: CONNECTING, CONNECTED, DISCONNECTING, DISCONNECTED,
SUSPENDED, UNKNOWN.

ConnectivityManager cm;
NetworkInfo ni = cm.getActiveNetworkInfo();
if (ni.getState().compareTo(State.CONNECTED)
// Connecté

Il est possible de connaître le type de la connexion:


int type = ni.getType();
Le type est un entier correspondant au wifi ou mobile (GPRS, 3G, ...).

Exemple
public class MainActivity extends Activity {
public int ID_NOTIFICATION = 0;
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

TextView mAffichageCompteur = (TextView) findViewById(R.id.textView1);


ConnectivityManager cm =
(ConnectivityManager)getSystemService(CONNECTIVITY_SERVICE);
NetworkInfo ni = cm.getActiveNetworkInfo();
boolean wifi = ni.getType() ==ConnectivityManager.TYPE_WIFI;
mAffichageCompteur.setText("le wifi : " + wifi); ());
}

Gérer le réseau Wifi/Mobile


Le basculement entre les types de connexion est possible si la permission
WRITE_SECURE_SETTINGS est disponible.
On utilise alors la méthode setNetworkPreference sur l'objet ConnectivityManager pour lui donner
l'entier correspondant au type de connexion voulu.

13
manager.setNetworkPreference(ConnectivityManager.TYPE_WIFI);

public void onClick(View v){


WifiManager wifi = (WifiManager)getSystemService(Context.WIFI_SERVICE);
if (!wifi.isWifiEnabled())
wifi.setWifiEnabled(true);
}
Les caractéristiques de la connexion Wifi sont accessibles par des appels statiques à des méthodes
de WifiManager:
- force du signal sur [0,levels]: WifiManager.calculateSignalLelvel(RSSI ?, levels)
- vitesse du lien réseau: info.getLinkSpeed()
- les points d'accès disponibles: List<ScanResult> pa = manager.getScanResults()

Localisation
Comme pour le réseau, Android permet d'utiliser plusieurs moyens de localisation. Cela permet de
rendre transparent l'utilisation du GPS, des antennes GSM ou des accès au Wifi. La classe
LocationManager permet de gérer ces différents fournisseurs de position.

 LocationManager.GPS_PROVIDER: fournisseur GPS


 LocationManager.NETWORK_PROVIDER: fournisseur basé réseau

La liste de tous les fournisseurs s'obtient par la méthode getAllProviders() ou getAllProviders(true)


pour les fournisseurs activés:

Exemple
LocationManager manager = (LocationManager)getSystemService(Context.LOCATION_SERVICE);
List<String> fournisseurs = manager.getAllProviders();
for (String f : fournisseurs) {
Toast.makeText(getApplicationContext(), "" + f, Toast.LENGTH_SHORT).show();
if (f.equals.(LocationManager.GPS_PROVIDER))
...
}

Les permissions associées pour la localisation sont :


 android.permission.ACCESS_FINE_LOCATION via le GPS
 android.permission.ACCESS_COARSE_LOCATION via le réseau

Coordonnées
A partir du nom d'un fournisseur de position actif, il est possible d'obtenir la dernière position connue de
l'appareil, par la méthode Location getLastKnownLocation(String provider).

LocationManager manager = (LocationManager)getSystemService(Context.LOCATION_SERVICE);

Location loc = manager.getLastKnownLocation("gps");


Toast.makeText(getApplicationContext(), "Latitude" +loc.getLatitude(), Toast.LENGTH_SHORT).show();

Toast.makeText(getApplicationContext(), "Longitude" + loc.getLongitude(), Toast.LENGTH_SHORT).show();

La dernière position connue n'est pas forcément la position actuelle de l'appareil.

Si vous voulez que le fournisseur se mette à jour automatiquement à une certaine période ou
tous les x mètres, on peut utiliser la méthode requestLocationUpdates()

14
void requestLocationUpdates(String provider, long minTime, float minDistance, LocationListener listener)

 provider le fournisseur de position.


 minTime la période entre deux mises à jour en millisecondes. Ne mettez pas
de valeur en dessous de 60 000 ms pour préserver la batterie.
 minDistance la période entre deux mises à jour en mètres. Tout comme
pour minTime, ne pas mettre de petite valeur de minTime parce qu'il
consomme moins de batterie.
 listener est l'écouteur qui sera lancé dès que le fournisseur sera activé.

Ainsi, il faut utiliser l'interface LocationListener, dont la méthode void


onLocationChanged(Location location) sera déclenchée à chaque mise à jour.

Il faut créer un écouteur (LocationListener) qui sera appelé à intervalles réguliers et pour une
distance minimum donnée. Il faut alors implémenter les méthodes nécessaires :

manager.requestLocationUpdates("gps", 6000, 100, new LocationListener() {


public void onStatusChanged(String provider, int status, Bundle extras) {
}
public void onProviderEnabled(String provider) {
}
public void onProviderDisabled(String provider) {
}
public void onLocationChanged(Location location) {
// TODO Auto-generated method stub
}
});

Exemple geolocalisation :
http://nbenbourahla.developpez.com/tutoriels/android/services-sous-android/

Classe principale
public void onClick(View actuelView){
startService(new Intent(HomeActivity.this, locationrService.class));
}
Exemple
public class locationrService extends Service {
private LocationManager locationMgr = null;
private LocationListener onLocationChange = new LocationListener() {

@Override
public void onStatusChanged(String provider, int status, Bundle extras){ }
@Override
public void onProviderEnabled(String provider) { }
@Override
public void onProviderDisabled(String provider) { }

public void onLocationChanged(Location location) {


Double latitude = location.getLatitude();
Double longitude = location.getLongitude();
Toast.makeText(getBaseContext(), "coordonnées du téléphone : " + latitude
+ " " + longitude, Toast.LENGTH_LONG).show();
}
}
};

15
@Override
public IBinder onBind(Intent arg0){
return null;
}

@Override
public void onCreate(){
locationMgr = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
locationMgr.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 10000, 0, onLocationChange);
locationMgr.requestLocationUpdates(LocationManager.GPS_PROVIDER, 10000, 0, onLocationChange);
super.onCreate();
}

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

@Override
public void onDestroy(){
super.onDestroy();
locationMgr.removeUpdates(onLocationChange);
}
}

Les permissions
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission
android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_GPS" />
<uses-permission
android:name="android.permission.ACCESS_ASSISTED_GPS" />
<uses-permission android:name="android.permission.LOCATION" />

Ce code ne fonctionnera que si l'application est en cours de fonctionnement. Mais pour


recevoir des notifications même quand l'application ne fonctionne pas, on peut utiliser la
méthode requestLocationUpdates avec un  PendingIntent.

void requestLocationUpdates(String provider, long minTime,


float minDistance, PendingIntent intent) où
le PendingIntent contenu dans intent sera lancé à chaque mise à jour du
fournisseur.
L'emplacement sera contenu dans un extra dont la clé est KEY_LOCATION_CHANGED.

Exemple
Intent intent = new Intent(this, GPSUpdateReceiver.class);

PendingIntent pending = PendingIntent.getBroadcast(this, 0, intent,


PendingIntent.FLAG_UPDATE_CURRENT);

locationManager.requestLocationUpdates(provider, 60000, 150, pending);

public class GPSUpdateReceiver extends BroadcastReceiver {


@Override
public void onReceive(Context context, Intent intent) {
16
Location location= (Location)intent.getParcelableExtra(LocationManager.KEY_LOCATION_CHANGED);
}
}

Alerte de proximité
Il est possible de préparer un événement pour réagir à la proximité du téléphone à une zone. Pour
cela, il faut utiliser la méthode addProximityAlert de LocationManager qui permet d'enregistrer un
Intent qui sera envoyé lorsque des conditions de localisation sont réunies.

C'est le fait d'être informés quand on s'approche d'un endroit ou qu'on s'en éloigne.
Cet endroit peut être symbolisé par un cercle dont on va préciser le centre et le
rayon. Ainsi, si on entre dans ce cercle ou qu'on sort de ce cercle, l'alerte est lancée.

Le prototype de la méthode qui peut créer une alerte de proximité est void


addProximityAlert(double latitude, double longitude, float radius, long
expiration, PendingIntent intent) avec :

 La latitude et la longitude les coordonnées du centre du cercle.


 Le rayon d'effet est précisé dans radius en mètres.
 expiration permet de déclarer combien de temps cette alerte est valable.
Tout nombre en dessous de 0 signifie qu'il n'y a pas d'expiration possible.
 Le PendingIntent sera lancé quand cette alerte est déclenchée, avec intent.

Cette fois, l'intent contiendra un booléen en extra, dont la clé


est KEY_PROXIMITY_ENTERING et la valeur sera true si on entre dans la zone
et false si on en sort.
Intent intent = new Intent(this, AlertReceiver.class);
PendingIntent pending = PendingIntent.getBroadcast(this, 0, intent,
PendingIntent.FLAG_UPDATE_CURRENT);

// On ajoute une alerte de proximité si on s'approche ou s'éloigne de la zone


locationManager.addProximityAlert(48.872808, 2.33517, 150, -1, pending);

public class AlertReceiver extends BroadcastReceiver {


@Override
public void onReceive(Context context, Intent intent) {
// Vaudra true par défaut si on ne trouve pas l'extra booléen dont la clé est LocationManager.KEY_PROXIMITY_ENTERING
boolean entrer = intent.getBooleanExtra(LocationManager.KEY_PROXIMITY_ENTERING, true);

if(entrer =true )
…..
}
}

Enfin, il faut désactiver une alerte de proximité avec void


removeProximityAlert(PendingIntent intent).

17
Android Google Map
Android offre la possibilité d'intégrer Google map dans une application. La carte Google
map affiche la position actuelle, permet de naviguer dans la direction de la position, de
rechercher l'emplacement, etc. Nous pouvons également personnaliser Google map en
fonction de nos besoins.

Google fournit une librairie qui permet d'inclure une carte google map dans son application.
1) Créer une activité basée sur Google Map.
2) Copiez l'URL du fichier google_map_api.xml pour générer la clé de carte Google.
3) Collez l'URL copiée dans le navigateur.
4) Cliquez sur "creat API key" pour générer une clé API.
5) Copiez cette clé API générée dans le fichier google_map_api.xml

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


<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="com.google.android.providers.gsf.permission.
READ_GSERVICES" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

<!--Google MAP API key-->


<meta-data
android:name="com.google.android.maps.v2.API_KEY"
android:value="AIzaSyDKymeBXNeiFWY5jRUejv6zItpmr2MVyQ0" />

La clef d'API est une clef à générer sur le serveur de google gérant le service des cartes à partir de
votre clef de signature d'application.

<meta-data
android:name="com.google.android.gms.version"
android:value="@integer/google_play_services_version" />

<uses-library android:name="org.apache.http.legacy" android:required="false"/>

 Ajouter des permissions et une clef d'accès à l'API Google Map API (créer une activité
basée sur Google Map).

 Ajouter un map fragment au layout xml.


<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:map="http://schemas.android.com/apk/res-auto"
android:id="@+id/map"
android:name="com.google.android.gms.maps.MapFragment"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:visibility="visible" />
</FrameLayout>

Pour obtenir l'objet GoogleMap dans l'activité MapsActivity.java, nous devons implémenter l'interface
OnMapReadyCallback et redéfinir la méthode onMapReady ().

public class MapsActivity extends FragmentActivity implements OnMapReadyCallback{  
      private GoogleMap mMap;  
      @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_maps);  

18
        // Obtain the SupportMapFragment and get notified when the map is ready to be used.  
        SupportMapFragment mapFragment = (SupportMapFragment) getSupportFragmentManager(.find
FragmentById(R.id.map);  
        mapFragment.getMapAsync(this);  
    }  
   @Override  
    public void onMapReady(GoogleMap googleMap) {  
        mMap = googleMap;  
          // Add a marker in Sydney and move the camera  
        LatLng sydney = new LatLng(-34, 151);  
        mMap.addMarker(new MarkerOptions().position(sydney).title("Marker in Sydney"));  
        mMap.moveCamera(CameraUpdateFactory.newLatLng(sydney));  
      }  
}  

Avec intent
Pour lancer Google Maps avec un intent, vous devez d'abord créer un intent, en spécifiant
son action, son URI et son package.

 Action : toutes les intentions de Google Maps sont appelées en tant


qu'action ACTION_VIEW.

 URI : les intentions de Google Maps utilisent des chaînes codées URI qui spécifient
une action souhaitée, ainsi que certaines données avec lesquelles effectuer l'action.
 package : les appels setPackage("com.google.android.apps.maps")garantiront
que l'application Google Maps pour Android gère l'intent. 
Si le package n'est pas défini, le système déterminera quelles applications peuvent gérer
le Intent. Si plusieurs applications sont disponibles, il peut être demandé à l'utilisateur
quelle application il souhaite utiliser.
// Create Uri from intent string. Use the result to create an Intent.
Uri gmmIntentUri = Uri.parse("https://maps.google.com/")

// Create an Intent from gmmIntentUri. Set the action to ACTION_VIEW


Intent mapIntent = new Intent(Intent.ACTION_VIEW, gmmIntentUri);

// Make the Intent explicit by setting the Google Maps package


mapIntent.setPackage("com.google.android.apps.maps");

// Attempt to start an activity that can handle the Intent


startActivity(mapIntent);

L'intent geo: permet d'afficher une carte à un emplacement et à un niveau de zoom spécifiés.
geo:latitude,longitude?z=zoom

 latitude et longitude: le point central de la carte.

19
 Zoom : définit le niveau de zoom initial de la carte. Les valeurs acceptées
vont de 0 (le monde entier) à 21 (bâtiments individuels). 

Exemples

// Creates an Intent that will load a map of San Francisco


Uri gmmIntentUri = Uri.parse("geo:37.7749,-122.4194");
Intent mapIntent = new Intent(Intent.ACTION_VIEW, gmmIntentUri);
mapIntent.setPackage("com.google.android.apps.maps");
startActivity(mapIntent);

Recherche de zones
// Search for restaurants nearby
Uri gmmIntentUri = Uri.parse("geo:0,0?q=restaurants");

// Search for restaurants in San Francisco


Uri gmmIntentUri = Uri.parse("geo:37.7749,-122.4194?q=restaurants");

Personnaliser la carte
Vous pouvez personnaliser google map à partir de la vue par défaut, et le modifier en fonction de
votre demande.
AIzaSyDJ4Wl682AVLEKEEBkVOumUIKx_SPj1zOM

Ajouter un Marker
Ob peut ajouter un marker avec un text dessus avec la méthode addMarker().
final LatLng LL = new LatLng(21 , 57);
Marker TP = googleMap.addMarker(new MarkerOptions().position(LL).title("texte"));

Changement du type de la carte


googleMap.setMapType(GoogleMap.MAP_TYPE_NORMAL);
googleMap.setMapType(GoogleMap.MAP_TYPE_HYBRID);
googleMap.setMapType(GoogleMap.MAP_TYPE_SATELLITE);
googleMap.setMapType(GoogleMap.MAP_TYPE_TERRAIN);

Enable/Disable zoom
googleMap.getUiSettings().setZoomGesturesEnabled(true);

20
Les Capteurs
Android introduit la gestion de multiples capteurs. Il peut s'agir de l'accéléromètre, du gyroscope
(position angulaire), de la luminosité ambiante, des champs magnétiques, de la pression ou
température, etc.
En fonction, des capteurs présents, la classe SensorManager permet d'accéder aux capteurs
disponibles. Par exemple, pour l'accéléromètre:

SensorManager manager = (SensorManager)getSystemService(SENSOR_SERVICE);


manager.registerListener(new SensorEventListener() {
public void onSensorChanged(SensorEvent event) {
}
public void onAccuracyChanged(Sensor sensor, int accuracy) {
}},manager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER),SensorManager.SENSOR_DELAY_UI );
}

Quand l'acceléromètre n'est plus utilisé, il doit être désenregistré à l'aide de:
manager.unregisterListener( pointeur ecouteur ,
manager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER) );

<uses-feature android:name="android.hardware.sensor.accelerometer"></uses-feature>

La directive n'est pas utilisée lors de l'installation, ce qui signifie qu'il est possible d'installer une
application utilisant le bluetooth sans posséder de hardware bluetooth. Evidemment, il risque d'y avoir
une exception ou des dysfonctionnements.

Un booléen supplémentaire permet alors d'indiquer si ce hardware est indispensable au


fonctionnement de l'application:
<uses-feature android:name="xxx" android:required="true"></uses-feature>

L'outil aapt permet d'apprécier la façon dont Google Play va filtrer l'application, en donnant un dump
des informations collectées:
./aapt dump badging ~/workspace/AndroSensors2/bin/AndroSensors2.apk
package: name='jf.andro.as' versionCode='1' versionName='1.0' sdkVersion:'8' targetSdkVersion:'14'
uses-feature:'android.hardware.sensor.acceleromedter'

Lecture des données


Les valeurs sont récupérées au travers de la classe SensorEvent. Toutes les données sont dans un tableau, dont la taille
dépend du type de capteur utilisé. Par exemple pour l'acceléromètre:
if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
float x,y,z;
x = event.values[0];
y = event.values[1];
z = event.values[2];
}
Le code est similaire pour le capteur d'orientation:

float azimuth, pitch, roll;


azimuth = event.values[0];
pitch = event.values[1];
roll = event.values[2];
}
Pour le capteur de lumière, on se limite à une seule valeur:
float lumiere;
lumiere = event.values[0];

21

Vous aimerez peut-être aussi