Les services

I) Présentation
Les services font partie des briques essentielles d’Android. Ils ne disposent pas d’interface
utilisateur mais fonctionnent en arrière-plan pour une période de temps indéfinie. L’exemple
le plus courant est le lecteur de musique, qui permet d’écouter sans bloquer l'activité.

Les services s’exécutent dans le Thread principal du processus parent. Ils doivent être
déclarés dans le fichier AndroidManifest.xml par :
<service android:name=".subpackagename.ServiceName"/>

Ils doivent étendre la classe Service et surcharger les méthodes suivantes :

 void onCreate(); // initialisation des ressources
 void onStart(Intent i); // pour SDK<2.0
 void onStartCommand(Intent i, int flags, int startId);
 void onDestroy(); // libération des ressources
 IBinder onBind(Intent i); // connexion client distant. Quand un autre
composant veut se lier au service, le système appelle la méthode onBind de ce dernier.
 boolean onUnbind(Intent i); // déconnexion d'un client
 void onRebind(Intent i)

Il y a deux types de services :

 les services locaux (ou LocalService) : les plus courants (started ou unbound service),
s’exécutent dans le même processus que l'application.
 Les services distants (bound service ou Remote Service) : s’exécutent dans un
processus différent de celui de l'application

Cycle de vie d’un service

Comme les activités, les services traversent plusieurs étapes pendant leur vie par des méthodes
de callback.

1
Deux possibilités pour interagir avec un service (demarrer/arrêter…) :
 La méthode startService() qui invoque la méthode onCreate() puis
onStart().
service.startService() -> onCreate() – > onStartCommand() [service running]

 La méthode bindService() qui appelle uniquement la méthode onCreate()

activity.bindService() ->onCreate() [service created]

 L’appel de la méthode stopService() invoque la méthode onDestroy().

Remarque
Il est possible de voir la liste des services exécutés du téléphone :
Menu > Settings > Applications > Running Services
Les services personnalisés sont lancés à partir d'autres composants Android, à savoir
des activités, des récepteurs de diffusion et d'autres services.

II) Les Services locaux (LocalService)

Ils sont lancés à partir d'une activité par la méthode :
ComponentName startService(Intent service). Cette méthode retourne le
package avec le nom du composant lancé.

Intent i = new Intent(Activite.this, UnService.class);

startService(i);

Un service Local n’est accessible que par les Activités de l’application.

Si le service n'existe pas, il sera créé, donc il y a appel de la méthode de callback

onCreate().

2
Ensuite la méthode onStartCommand(Intent intent, int flags, int
startId) sera lancée avec les arguments suivants :
- intent: l'intent qui a été utilisé pour lancer la requête au service (pourra être null
dans le cas d'une relance du service suite à un arrêt de celui-ci).
- Flags : permet de savoir plus sur la nature de l'intent qui a lancé le service, il vaut :
 0 s'il n'y a rien de spécial à dire.
 START_FLAG_REDELIVERY si l'intent avait déjà été délivré et qu'il l'est à nouveau
parce que le service avait été interrompu.
 START_FLAG_RETRY si le service redémarre alors qu'il s'était terminé de manière
anormale.
- startId : permet d'identifier le lancement (1 pour le premier lancement, 2
pour le deuxième lancement, etc.).
-
Remarque
flags est un paramètre qui peut avoir en même temps START_FLAG_REDELIVERY et
START_FLAG_RETRY.

Valeur de retour de OnStartCommand :

Ces valeurs permettent d'indiquer au système ce qu'il doit faire du
service lorsque le traitement est terminé:

Cette méthode retourne un entier qui détermine ce que fera le système si le service est tué :

 START_NOT_STICKY
Si le système tue le service, alors ce dernier ne sera pas recréé. Il faudra donc effectuer un
nouvel appel à startService().

 START_STICKY
Si le service est tué, alors il sera recréé mais sans avoir le dernier Intent qui l'avait lancé. Le
paramètre intent vaudra null.

 START_REDELIVER_INTENT
Le service sera recréé et dans onStartCommand() le paramètre intent sera indiqué au dernier
intent qui a été fourni au service. Le paramètre START_REDELIVER_INTENT est
indispensable pour qu'un service effectue un travail complètement.

Arrêter un service
Pour arrêter un service, il faudra appeler la méthode stopSelf() si le
service veut s'arrêter lui-même ou stopService(Intent serv)depuis
une activité. serv est l'intent fournie lors de l’appel startService()
correspondant.

Passage d'informations
Généralement un service a besoin de communiquer pour effectuer un
traitement, le principe de passage d'informations sera le même que
pour les activités. On utilisera les extras ou les datas avec les intents.

Exemple
Déclarer le service
3
Au début, il faut déclarer le service dans le Manifest. Il faut préciser certains attributs
android:name : identifiant,
android:icon : un drawable qui jouera le rôle d'icône,
android:permission : pour créer une permission nécessaire à l'exécution du service
android:process pour préciser dans quel processus se lancera ce service.

android:name est le seul attribut indispensable.

Il suffit d'ajouter entre les balises applications:

<service android:name=".MonService" /> où MonService est la classe service développé.

Exemple
<service
android:name="MusicService"
android:process=":player" >
…
</service>

En Java
Démarrer un service explicitement : startService().
Il existe deux classes mères principales qui permettent de créer un service, Service et
IntentService.

Avec la classe Service (La plus générique)

La classe Service permet de créer un service de base dont le code est exécuté dans le thread
principal. Il faut alors créer un nouveau thread pour ne pas alourdir le UI thread.

Exemple: créer une application contenant deux boutons, le premier lance le service et l'autre
l'arrête.

Le service
public class IntentServiceExample extends Service {
MediaPlayer myPlayer;

@Override
public void onCreate() {
Toast.makeText(this, "Service was Created", Toast.LENGTH_LONG).show();
myPlayer = MediaPlayer.create(this, R.raw.sun);
myPlayer.setLooping(false); // Set looping
}
public IBinder onBind(Intent intent) {
return null;
}

public int onStartCommand(Intent intent, int flags, int startId) {

// Let it continue running until it is stopped.
Toast.makeText(this, "Service Started", Toast.LENGTH_LONG).show();
myPlayer.start();
return START_STICKY;

4
}

@Override
public void onDestroy() {
super.onDestroy();
Toast.makeText(this, "Service Destroyed", Toast.LENGTH_LONG).show();
myPlayer.stop();
}}

L'activité principale
public class MainActivity extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
public void onClick(View view) {
startService(new Intent(getBaseContext(), IntentServiceExample.class));
//intent.putExtra("KEY1", "Value to be used by the service");
}
public void onClick (View view) {
stopService(new Intent(getBaseContext(), IntentServiceExample.class));
}}

 Avec la classe IntentService (La plus pratique )

La classe IntentService crée elle-même un thread et gère les requêtes.
À chaque utilisation de startService(), la requête sera ajoutée à une file et tous les
éléments de la file seront traités par ordre d'arrivée. Une fois la file devient vide, le service
s'arrête.

Cette classe est facile à gérer puisque il suffit d'implémenter la méthode void
onHandleIntent(Intent intent) qui recevra toutes les requêtes dans l'ordre sous la
forme d'intent, ainsi qu'un constructeur qui fait appel au constructeur
d'IntentService.

Syntaxe :
public class ExampleService extends IntentService {
public ExampleService() {
super("Nom_du_service"); }
protected void onHandleIntent(Intent intent) {
// Gérer la requête
}}
On peut aussi implémenter les autres méthodes de callback, mais on doit toujours appeler leur
super implémentation, sinon le service échouera :
public int onStartCommand(Intent intent, int flags, int startId) {
// Du code
return super.onStartCommand(intent, flags, startId);
}

Exemple1

5
Une activité envoie un chiffre à un IntentService qui va l'afficher dans la console.
De plus, l'IntentService fera un long traitement pour que chaque fois que l'activité
envoie un chiffre les intents s'accumulent, ce qui fera que les messages seront retardés dans la
console.

public class MainActivity extends Activity {

private Button mBouton = null;
private TextView mAffichageCompteur = null;
private int mCompteur = 0;

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);
setContentView(R.layout.main);

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

mBouton = (Button) findViewById(R.id.button1);

mBouton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent i = new Intent(MainActivity.this, IntentServiceExample.class);
i.putExtra("code", mCompteur);
mCompteur ++;
mAffichageCompteur.setText("le compteur vaut " + mCompteur);
startService(i);
}});
}}
Le bouton fait incrémenter le compteur et envoie un intent qui lance un service qui s'appelle
IntentServiceExample. L'intent est ensuite reçu et traité.

Le service
public class IntentServiceExample extends IntentService {
private final static String TAG = "IntentServiceExample";
public IntentServiceExample() {
super(TAG);
}
protected void onHandleIntent(Intent intent) {
Log.d(TAG, "Le compteur valait:" + intent.getIntExtra("code",-1));
long i = 0;
//Cette boucle permet de rajouter artificiellement du temps de traitement
while(i < 1000L)
i++;
}}

Utilisation des BroadcastReceivers

Les BroadcastReceivers sont utilisés pour transférer des messages entre
des applications ou entre un service et une activité.

6
 Pour transférer des données entre un service et une activité, nous devons
utiliser un LocalBroadcastManager.

La classe LocalBroadcastManager est fournie avec la bibliothèque de support et

est utilisée pour transférer des données uniquement localement.

Dans cet exemple, nous allons créer une application qui passe une chaîne à un
IntentService qui la renvoie à l'activité après un délai. Grâce à IntentService, cela se
produit de manière séquentielle.

Exemple 2
public class MainActivity extends AppCompatActivity {
TextView textView;
Button button;
EditText editText;
MyReceiver myReceiver;

public static final String FILTER_ACTION_KEY = "any_key";

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
textView = findViewById(R.id.textView);
button = findViewById(R.id.button);
editText = findViewById(R.id.inputText);

button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
String message = editText.getText().toString();
Intent intent = new Intent(MainActivity.this, MyService.class);
intent.putExtra("message", message);
startService(intent);
}
});
}

 Nous devons définir un IntentFilter pour enregistrer le BroadcastReceiver.

 Dans l'action IntentFilter, nous spécifions une chaîne.
 La même chaîne serait également utilisée dans notre IntentService.

@Override
protected void onStart() {
myReceiver = new MyReceiver();
IntentFilter intentFilter = new IntentFilter();
intentFilter.addAction(FILTER_ACTION_KEY);
LocalBroadcastManager.getInstance(this).registerReceiver(myReceiver, intentFilter);
super.onStart();
}
@Override
protected void onStop() {
unregisterReceiver(myReceiver);

7
 super.onStop();
}

private class MyReceiver extends BroadcastReceiver {

@Override
public void onReceive(Context context, Intent intent) {
String message = intent.getStringExtra("broadcastMessage");
textView.setText(textView.getText() + "\n" + message);
}
}
}

public class MyService extends IntentService {

public MyService() {
super("MyService");
}

@Override
protected void onHandleIntent(Intent intent) {
String message = intent.getStringExtra("message");
intent.setAction(MainActivity.FILTER_ACTION_KEY);
SystemClock.sleep(3000);
String echoMessage = "IntentService after a pause of 3 seconds" + message;
LocalBroadcastManager.getInstance(getApplicationContext()).
sendBroadcast(intent.putExtra("broadcastMessage", echoMessage));
}
}

Les services distants

Pour permettre à une activité de s’associer à un service, la méthode onBind doit être implémentée au
niveau du service. Cette méthode retourne un objet de type IBinder qui sera utilisé plus tard par
l’activité pour récupérer la référence (le pointeur ) vers le service

Pour assurer une connexion avec le service on utilise la méthode boolean bindService(Intent service,
ServiceConnection conn, int flags).

conn : permet de recevoir le service quand celui-ci démarrera et permet de savoir s'il meurt ou s'il
redémarre (ServiceConnection est une interface qui surveille l'exécution du service distant). Il existe deux
méthodes de callback à redéfinir :
1. void onServiceConnected(ComponentName name, IBinder service) appelée quand la connexion au
service est établie, avec un IBinder qui correspond à un canal de connexion avec le service.

2. void onServiceDisconnected(ComponentName name) appelée quand la connexion au service est

perdue.

Quand un autre composant veut se lier au service, le système appelle la

méthode onBind de ce dernier. Cette méthode doit retourner une instance de
l’interface IBinder.

IBinder : est un pont entre votre service et l'activité mais se trouve au niveau du service.
Les IBinder permettent au client de faire des demandes au service.

IBinder : sera donné à onServiceConnected(ComponentName, IBinder) puis envoyé par la méthode

de callback IBinder onBind(Intent intent) dans Service.

8
La méthode onBind doit renvoyer un type de IBinder propre à votre service, ce qui signifie que vous
devez créer votre propre implémentation de l’interface IBinder.

public class MonService extends Service {

private final IBinder mBinder = new MonBinder();

// Le Binder est représenté par une classe interne

public class MonBinder extends Binder {
// Le Binder possède une méthode pour renvoyer le Service
MonService getService() {
return MonService.this;
}}

public IBinder onBind(Intent intent) {

return mBinder;
}}

Le service sera créé s'il n'était pas déjà lancé (appel à onCreate()), mais ne passera pas par
onStartCommand().

Pour qu'on puisse se détacher d'un service, on utilise la méthode unbindService(ServiceConnection conn) .

Pour l’Interface de connexion au service

private ServiceConnection mConnexion = new ServiceConnection() {

// Se déclenche quand l'activité se connecte au service
public void onServiceConnected(ComponentName className, IBinder service) {
mService = ((MonService.MonBinder)service).getService();
}

// Se déclenche dès que le service est déconnecté

public void onServiceDisconnected(ComponentName className) {
mService = null;
}
};

Exemple
public class MainActivity extends AppCompatActivity {
private MyService MonService;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

Intent intentAssociation = new Intent(this, MyService.class);

if (bindService(intentAssociation, mConnexion, Context.BIND_AUTO_CREATE)){

Button btnService = (Button) findViewById(R.id.button);
btnService.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
MonService.AfficheStatut();
}});
}}

@Override
protected void onDestroy() {
super.onDestroy();
unbindService(mConnexion);
}

9
 private ServiceConnection mConnexion = new ServiceConnection() {
// Méthode appelée lorsque la connexion est établie. Récupère la référence vers le service associé.
public void onServiceConnected(ComponentName className, IBinder service) {
MonService = ((MyService.MonServiceBinder) service).getService();
}
// Méthode appelée lorsque la connexion est rompue.
public void onServiceDisconnected(ComponentName className) {
mMonService = null;
}};
}

public class MyService extends Service {

private final IBinder mBinder = new MonServiceBinder();

public MyService() {
}

@Override
public IBinder onBind(Intent intent) {
return mBinder;
}

public void AfficheStatut() {

Toast.makeText(MyService.this, "Voici le statut de mon service !", Toast.LENGTH_SHORT).show();
}
public class MonServiceBinder extends Binder {
MyService getService() {
return MyService.this;
}
}}

Distribuer des autorisations : PendingIntents

Un PendingIntent spécifie une action à effectuer dans le futur. Il permet de passer une future
intention à une autre application et de permettre à cette application d'exécuter cet Intention
comme si elle avait les mêmes autorisations que votre application.

C'est un jeton que vous donnez à une application étrangère qui permet à cette application
étrangère d'utiliser les permissions de votre application pour exécuter un morceau de code
prédéfini.

L'application recevant un PendingIntent, aura les droits d'effectuer une opération comme s'il
s'agissait de l'application émettrice (avec les mêmes permissions et la même identité).

Pour des raisons de sécurité, l'intention de base fournie à PendingIntent doit avoir le
nom du composant explicitement défini pour garantir qu'il est finalement envoyé à
cette application et nulle part ailleurs.

On aura deux applications : celle de départ et celle d'arrivée. L'application d'arrivée peut alors
effectuer des opérations dans l'application source (avec les mêmes permissions et la même
identité). Il faut alors donner à l'application d'arrivée tous les renseignements et toutes les
autorisations nécessaires pour qu'elle puisse demander à l'application de départ d'exécuter une
action à sa place.
Pour le faire, on insère dans le PendingIntent un autre Intent, qui décrit l'action. Le seul but
du PendingIntent est d'être véhiculé entre les deux applications.

Il existe trois manières d'appeler un PendingIntent :

- PendingIntent.getActivity(Context context, int requestCode, Intent
intent, int flags) : Récupère un PendingIntent pour démarrer une activité.

10
 - PendingIntent.getBroadcast(Context context, int requestCode, Intent
intent, int flags) : Récupère un PendingIntent pour effectuer une diffusion.

- PendingIntent.getService(Context context, int requestCode, Intent

intent, int flags) : Récupère un PendingIntent pour démarrer un service.

Exemple : PendingIntent utilisé pour revenir vers l'activité principale

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

Intent intent = new Intent(this, SomeActivity.class);

// Creating a pending intent and wrapping our intent

PendingIntent pendingIntent = PendingIntent.getActivity(this, 1, intent,
PendingIntent.FLAG_UPDATE_CURRENT);
try {
// Perform the operation associated with our pendingIntent
pendingIntent.send();
} catch (PendingIntent.CanceledException e) {
e.printStackTrace();
}

Exemple : // Intent explicite qui sera utilisé pour lancer à nouveau MainActivity

public class MainActivity extends Activity {

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

Intent intent = new Intent();

// On pointe vers l'activité courante en précisant le package, puis l'activité
intent.setComponent(new ComponentName("com.example.myapplication.exemple1",
"com.example.myapplication.MainActivity"));
PendingIntent mPending = PendingIntent.getService(this, 0, intent, 0);
}
}

Notification
Toast
Par défaut, Android affiche le message en bas de l’écran de l’utilisateur. Ce comportement peut être
redéfini pour en changer la position. Vous pouvez spécifier la disposition d’un toast en spécifiant son
ancrage sur l’écran ainsi qu’un décalage sur l’axe horizontal et vertical.

Exemple
Toast toast = Toast.makeText(this, "Vous prendrez bien un toast ou deux ;",
Toast.LENGTH_LONG);
toast.setGravity(Gravity.TOP, 0, 40); // Spécifie la dispostion du Toast sur l’écran
toast.show();// Affichage du Toast

Les notifications
La plate-forme Android fournit et exécute des services système prédéfinis et toutes les
applications Android peuvent les utiliser, avec les autorisations appropriées.

11
Ces services système sont généralement exposés via une classe de gestionnaire
spécifique. Leur accès peut être obtenu via la méthode getSystemService().
La classe Context définit plusieurs constantes pour accéder à ces services.

Un service nous avertit de l'arrivée des évènements avec des notifications dans la barre de statut
(ou avec des Toasts).

Une notification passe par trois étapes :

1. à son arrivée, elle affiche une icône ainsi qu'un texte court.
2. Ensuite, seule l'icône est lisible dans la barre de statut après quelques secondes.
3. Puis il est possible d'avoir plus de détails sur la notification en ouvrant la liste des
notifications (icône, titre, texte et un horaire de réception).

Si on appuie sur une notification, Android actionnera un PendingIntent contenu dans la

notification et qui sera utilisé pour lancer un composant (souvent une activité). Vous pouvez aussi
configurer la notification pour qu'elle s'accompagne d'un son, d'une vibration ou d'un
clignotement de la LED…

Le gestionnaire de notifications
Pour pouvoir utiliser le gestionnaire de notifications dans votre application, vous devez
récupérer l’instance du service des notifications du système Android par la méthode
getSystemService avec le paramètre Context.NOTIFICATION_SERVICE.

NotificationManager nm = (NotificationManager)getSystemService(Context.NOTIFICATION_SERVICE);

Une fois l’instance du gestionnaire de notifications récupérée, on peut gérer les notifications
en termes d’ajout, de suppression et de modification.

Etapes de création d'une notification

1) Builder
La première étape consiste à créer un générateur de notification à l'aide de
NotificationCompat.Builder.build (). On utilise le Builder pour définir
diverses propriétés de notification comme ses petites et grandes icônes, son
titre, sa priorité, etc.

NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(this)

2) Propriétés de la notification
Une fois on a un objet Builder, on peut définir ses propriétés de notification à l'aide de l'objet Builder selon les
besoins. Mais ceci est obligatoire pour définir au moins :
 Une petite icone : setSmallIcon()
 Un titre : setContentTitle()
 Le Détail : setContentText()

mBuilder.setSmallIcon(R.drawable.notification_icon);
mBuilder.setContentTitle("Notification Alert, Click Me!");
mBuilder.setContentText("Hi, This is Android Notification Detail!");

3) Attacher une action à la notification

Cette partie est facultative mais obligatoire si vous souhaitez joindre une action à la notification. Une action
permet aux utilisateurs de passer directement de la notification à une activité dans votre application, où ils
peuvent regarder un ou plusieurs événements ou effectuer un travail supplémentaire.

L'action est définie par un PendingIntent contenant un Intent qui démarre une activité dans votre application.

12
Pour associer un PendingIntent à un geste, appelez la méthode appropriée de NotificationCompat.Builder. Par
exemple, si vous voulez démarrer Activité lorsque l'utilisateur clique sur le texte de notification dans le tiroir de
notification, vous ajoutez l'élément PendingIntent en appelant setContentIntent().

Un objet PendingIntent vous aide à effectuer une action au nom de vos applications, souvent plus tard, sans se
soucier de savoir si votre application est en cours d'exécution ou non.
Nous prenons l'aide de l'objet générateur de pile stack Builder qui contiendra une pile arrière pour l'activité
démarrée. Cela garantit que la navigation en arrière de l'activité mène hors de votre application vers l'écran
d'accueil.

Intent notificationIntent = new Intent(this, NotificationView.class);

PendingIntent contentIntent = PendingIntent.getActivity(this, 0,
notificationIntent,PendingIntent.FLAG_UPDATE_CURRENT);
builder.setContentIntent(contentIntent);

4) Envoyer la notification
On peut passer l'objet Notification au système en appelant la méthode
NotificationManager.notify() pour envoyer la notification. Assurez-vous que vous
appelez la méthode NotificationCompat.Builder.build() sur l'objet Builder avant de
le notifier. Cette méthode combine toutes les options qui ont été définies et
renvoie un nouvel objet Notification.

NotificationManager mNotificationManager = (NotificationManager)

getSystemService(Context.NOTIFICATION_SERVICE);
// notificationID allows you to update the notification later on.
mNotificationManager.notify(notificationID, mBuilder.build());

Exemple
public class SettingsActivity extends AppCompatActivity {
NotificationCompat.Builder notification_builder;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.layout1);

Button btnService = (Button) findViewById(R.id.button1);

Button b1 = (Button) findViewById(R.id.button2);

b1.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
addNotification();
}
});
}
private void addNotification() {
Intent notificationIntent = new Intent(this, Main2Activity.class);
notificationIntent.putExtra("message", "This is a notification message");
PendingIntent contentIntent = PendingIntent.getActivity(this, 0,
notificationIntent,PendingIntent.FLAG_UPDATE_CURRENT);

NotificationManager notification_manager = (NotificationManager)

this.getSystemService(Context.NOTIFICATION_SERVICE);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
String chanel_id = "3000";
CharSequence name = "Channel Name";
String description = "Chanel Description";
int importance = NotificationManager.IMPORTANCE_LOW;
NotificationChannel mChannel = new NotificationChannel(chanel_id, name, importance);
mChannel.setDescription(description);
mChannel.enableLights(true);
mChannel.setLightColor(Color.BLUE);
notification_manager.createNotificationChannel(mChannel);
notification_builder = new NotificationCompat.Builder(this, chanel_id)

13
 } else {
notification_builder = new NotificationCompat.Builder(this);
}
notification_builder.setSmallIcon(R.mipmap.ic_launcher)
.setContentTitle("Notification Title")
.setContentText("Notification Body")
.setAutoCancel(true)
.setContentIntent(contentIntent)
.build();

notificationManager.notify(0, notification_builder);
} }

public class Main2Activity extends AppCompatActivity {

TextView textView;
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_notification_view);
textView = findViewById(R.id.textView);
String message=getIntent().getStringExtra("message");
textView.setText(message);
}
}

14