Activitate de Laborator
1. Vom porni de la urmatorul schelet
2. Astazi vom lucra cu doua proiecte in paralel,
StartedService și StartedServiceActivity, din modulele
kotlinSkelStartedService, respectiv kotlinSkelStartedServiceActivity.
- Proiectul StartedService conține codul sursă pentru un serviciu de
tip started care transmite mai multe valori, de diferite tipuri (șir
de caractere, întreg, vector), temporizate la un anumit interval
(dată de valoarea
SLEEP_TIMEdin interfațaConstants). Aceste valori sunt transmise prin intermediul unor broadcast intents, la nivelul întregului sistem de operare Android.
Aplicația StartedService nu are o activitate atașată. Astfel, aplicația pornită nu va avea o interfață grafică. Când o pornim, nu vom observa nimic pe partea de GUI.
- Proiectul StartedServiceActivity conține codul sursă pentru o aplicație Android care utilizează un ascultător pentru intenții cu difuzare (eng. BroadcastReceiver), pentru tipurile de mesaje propagate la nivelul sistemului de operare de către serviciu, pe care le afișează în interfața grafică, prin intermediul unui câmp text.

3. În proiectul StartedService, în clasa StartedService din
pachetul ro.pub.cs.systems.eim.lab05.startedservice.service (în Kotlin:
ro.pub.cs.systems.eim.lab05.startedservice), să se
completeze metoda onStartCommand() astfel încât aceasta să pornească
un thread în cadrul căruia să fie trimise 3 broadcast intents la nivelul sistemului de operare Android.
Pentru fiecare broadcast intent, se vor specifica:
- acțiunea, care va avea valorile definite în interfața
Constants(Constants.ACTION_STRING,Constants.ACTION_INTEGER,Constants.ACTION_ARRAY_LIST); se va utiliza metoda setAction(); - informațiile transmise, plasate în câmpul
extra(având cheiaConstants.DATAși valoarea dată deConstants.STRING_DATA,Constants.INTEGER_DATA,Constants.ARRAY_LIST_DATA); se va utiliza metoda putExtra() care primește ca argumente cheia și valoarea.
Transmiterea propriu-zisă a intenției se face prin intermediul metodei sendBroadcast().
Intent intent = new Intent();
intent.setAction("com.example.broadcast.MY_NOTIFICATION");
intent.putExtra("data", "Nothing to see here, move along.");
sendBroadcast(intent);
val intent = Intent().apply {
action = "com.example.broadcast.MY_NOTIFICATION"
putExtra("data", "Nothing to see here, move along.")
}
sendBroadcast(intent)
adb shell 'am broadcast -a "ro.pub.cs.systems.eim.lab05.startedservice.string" --es "ro.pub.cs.systems.eim.lab05.startedservice.data" "******** hello world!"'
Cele trei mesaje vor fi temporizate la intervalul indicat de valoarea
Constants.SLEEP_TIME (propagarea mesajelor va fi intercalată de
apeluri
Thread.sleep().
a) De ce este necesar ca serviciul să realizeze operațiile pe un fir de execuție dedicat?
b) Ce alternativă s-ar fi putut folosi pentru a se evita o astfel de abordare? Ce avantaj și ce dezavantaj prezintă această alternativă?
Se implementează o clasă derivată din
Thread
pentru care se va suprascrie metoda
run().
Pe firul de execuție dedicat, se vor propaga intențiile cu difuzare la
nivelul sistemului de operare Android, după care acesta își va încheia
activitatea. Pentru că ascultătorul se află în altă aplicație
(StartedServiceActivity), intenția indică și pachetul acesteia, prin
setPackage().
package ro.pub.cs.systems.eim.lab05.startedservice.service;
import android.content.Context;
import android.content.Intent;
import ro.pub.cs.systems.eim.lab05.startedservice.general.Constants;
public class ProcessingThread extends Thread {
private Context context;
public ProcessingThread(Context context) {
this.context = context;
}
@Override
public void run() {
while(true){
sendMessage(Constants.MESSAGE_STRING);
sleep();
//...
}
}
private void sleep() {
try {
Thread.sleep(Constants.SLEEP_TIME);
//...
} catch (InterruptedException interruptedException) {
interruptedException.printStackTrace();
}
}
private void sendMessage(int messageType) {
Intent intent = new Intent();
switch(messageType) {
case Constants.MESSAGE_STRING:
intent.setAction(Constants.ACTION_STRING);
intent.putExtra(Constants.DATA, Constants.STRING_DATA);
break;
//...
}
// Set the target package for cross-app broadcasts
intent.setPackage("ro.pub.cs.systems.eim.lab05.startedserviceactivity");
context.sendBroadcast(intent);
}
}
package ro.pub.cs.systems.eim.lab05.startedservice
import android.content.Context
import android.content.Intent
class ProcessingThread(private val context: Context) : Thread() {
override fun run() {
while (true) {
sendMessage(Constants.MESSAGE_STRING)
sleepThread()
//...
}
}
private fun sleepThread() {
try {
sleep(Constants.SLEEP_TIME)
//...
} catch (e: InterruptedException) {
e.printStackTrace()
}
}
private fun sendMessage(messageType: Int) {
val intent = Intent()
when (messageType) {
Constants.MESSAGE_STRING -> {
intent.action = Constants.ACTION_STRING
intent.putExtra(Constants.DATA, Constants.STRING_DATA)
}
//...
}
// Set the target package for cross-app broadcasts
intent.setPackage("ro.pub.cs.systems.eim.lab05.startedserviceactivity")
context.sendBroadcast(intent)
}
}
Monitorizați ciclurile din Thread.run() in logcat:
Log.d(Constants.TAG, "Thread.run() was invoked, PID: " + android.os.Process.myPid() + " TID: " + android.os.Process.myTid());
Log.d(Constants.TAG, "Thread.run() was invoked, PID: ${android.os.Process.myPid()} TID: ${android.os.Process.myTid()}")
4. În proiectul StartedServiceActivity, să se pornească serviciul,
printr-un apel al metodei
startService() sau startForegroundService dupa versiunea Oreo;
intenția care va fi transmisă ca argument metodei startService()
trebuie să refere explicit serviciul care urmează a fi pornit, din
motive de securitate (se folosește metoda
setComponent(),
care indică atât pachetul corespunzător aplicației Android care conține
serviciul, cât și clasa corespunzătoare acestuia - calificată complet).
În Kotlin, clasa serviciului este direct în pachetul
ro.pub.cs.systems.eim.lab05.startedservice, fără .service.
Intent intent = new Intent();
intent.setComponent(new ComponentName("ro.pub.cs.systems.eim.lab05.startedservice", "ro.pub.cs.systems.eim.lab05.startedservice.service.StartedService"));
// De la Android Oreo (Android 8) in sus se foloseste startForegroundService
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
startForegroundService(intent);
}
else {
startService(intent);
}
val intent = Intent().apply {
component = ComponentName(
"ro.pub.cs.systems.eim.lab05.startedservice",
"ro.pub.cs.systems.eim.lab05.startedservice.StartedService"
)
}
// De la Android Oreo (Android 8) in sus se foloseste startForegroundService
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
startForegroundService(intent)
} else {
startService(intent)
}
In serviciu, vom face urmatoarea actualizare pentru ca serviciul sa anunte pornirea catre activitate:
private static final String TAG = "ForegroundService";
private static final String CHANNEL_ID = "11";
private static final String CHANNEL_NAME = "ForegroundServiceChannel";
private void dummyNotification() {
NotificationChannel channel = null;
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
channel = new NotificationChannel(CHANNEL_ID,CHANNEL_NAME,
NotificationManager.IMPORTANCE_HIGH);
}
NotificationManager manager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
manager.createNotificationChannel(channel);
}
Notification notification = null;
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
notification = new Notification.Builder(getApplicationContext(),CHANNEL_ID).build();
}
startForeground(1, notification);
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
/* ... */
// Am adaugat aceasta linie
dummyNotification();
/* ... */
}
private val TAG = "ForegroundService"
private val CHANNEL_ID = "11"
private val CHANNEL_NAME = "ForegroundServiceChannel"
private lateinit var processingThread: ProcessingThread
private fun dummyNotification() {
val manager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
val channel = NotificationChannel(
CHANNEL_ID,
CHANNEL_NAME,
NotificationManager.IMPORTANCE_DEFAULT
)
manager.createNotificationChannel(channel)
}
val notification = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
Notification.Builder(applicationContext, CHANNEL_ID)
.setContentTitle("Foreground Service")
.setContentText("Service is running...")
.setSmallIcon(android.R.drawable.ic_media_play)
.build()
} else {
Notification.Builder(applicationContext)
.setContentTitle("Foreground Service")
.setContentText("Service is running...")
.setSmallIcon(android.R.drawable.ic_media_play)
.build()
}
startForeground(1, notification)
}
override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
/* ... */
// Am adaugat aceasta linie
dummyNotification()
/* ... */
}
a) Să se ruleze aplicațiile. Se va rula aplicația StartedService care instalează serviciul pe dispozitivul mobil. Ulterior se va rula aplicația StartedServiceActivity. Verificați faptul că serviciul a fost pornit și oprit corespunzător prin mesajele afișate în consolă.
5. În proiectul StartedServiceActivity, să se implementeze un
ascultător pentru intenții cu difuzare, în clasa
StartedServiceBroadcastReceiver din pachetul
ro.pub.cs.systems.eim.lab05.startedserviceactivity.view (în Kotlin:
ro.pub.cs.systems.eim.lab05.startedserviceactivity). Acesta
extinde clasa
BroadcastReceiver
și implementează metoda
onReceive(),
având ca argumente contextul din care a fost invocată și
intenția prin intermediul căreia a fost transmis mesajul respectiv.
Astfel, datele extrase din intenție (având cheia indicată de
Constants.DATA) vor fi afișate într-un câmp text (messageTextView)
din cadrul interfeței grafice.
onReceive(Context, Intent) din clasa
StartedServiceBroadcastReceiver, se verifică:
- acțiunea corespunzătoare intenției, folosind metoda getAction();
- informațiile transmise conținute în câmpul
extra, folosind metodele corespunzătoare tipului de date identificat pe baza intenției (getStringExtra(), getIntExtra(), getStringArrayListExtra()).
Puteți testa recepția mesajelor de broadcast folosind comanda shell:
adb shell am broadcast -a "ro.pub.cs.systems.eim.lab05.startedservice.string" --es "ro.pub.cs.systems.eim.lab05.startedservice.data" "'******** hello world!'"
Acestea vor fi afișate în cadrul câmpului text din cadrul interfeței
grafice (messageTextView), transmis ca argument la instanțierea
ascultătorului pentru intenții cu difuzare.
package ro.pub.cs.systems.eim.lab05.startedserviceactivity.view;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.widget.TextView;
import ro.pub.cs.systems.eim.lab05.startedserviceactivity.general.Constants;
public class StartedServiceBroadcastReceiver extends BroadcastReceiver {
private TextView messageTextView;
public StartedServiceBroadcastReceiver(TextView messageTextView) {
this.messageTextView = messageTextView;
}
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
String data = null;
if (Constants.ACTION_STRING.equals(action)) {
data = intent.getStringExtra(Constants.DATA);
}
// ...
if (messageTextView != null) {
messageTextView.setText(messageTextView.getText().toString() + "\n" + data);
}
}
}
package ro.pub.cs.systems.eim.lab05.startedserviceactivity
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.widget.TextView
class StartedServiceBroadcastReceiver(private val messageTextView: TextView?) : BroadcastReceiver() {
override fun onReceive(context: Context, intent: Intent) {
val action = intent.action
var data: String? = null
if (Constants.ACTION_STRING == action) {
data = intent.getStringExtra(Constants.DATA)
}
// ...
messageTextView?.let {
val currentText = it.text.toString()
it.text = "$currentText\n$data"
}
}
}
6. În proiectul StartedServiceActivity, în cadrul metodei
onCreate() a activității StartedServiceActivity (din pachetul
ro.pub.cs.systems.eim.lab05.startedserviceactivity), să se realizeze
următoarele operații:
a) să se creeze o instanță a ascultătorului pentru intenții cu difuzare;
startedServiceBroadcastReceiver = new StartedServiceBroadcastReceiver(messageTextView);
startedServiceBroadcastReceiver = StartedServiceBroadcastReceiver(messageTextView)
b) să se creeze o instanță a unui obiect de tipul IntentFilter, la care să se adauge toate acțiunile corespunzătoare intențiilor cu difuzare propagate de serviciu; se va folosi metoda addAction();
startedServiceIntentFilter = new IntentFilter();
startedServiceIntentFilter.addAction(Constants.ACTION_STRING);
startedServiceIntentFilter = IntentFilter().apply {
addAction(Constants.ACTION_STRING)
}
c) să se atașeze, respectiv să se detașeze ascultătorul de intenții
cu difuzare, astfel încât acesta să proceseze mesajele primite de la
serviciu doar în situația în care activitatea este vizibilă pe suprafața
de afișare; în acest sens, vor fi utilizate metodele
registerReceiver(),
respectiv
unregisterReceiver(),
apelate pe metodele de callback ale activității corespunzătoare stării
în care aceasta este vizibilă pe suprafața de afișare (onResume(),
respectiv onPause()).
Este necesar ca activarea
ascultătorului să se realizeze pe metoda de callback onResume(), iar
dezactivarea sa să fie realizată pe metoda de callback onPause().
De la Android 14 (targetSdk 34), registerReceiver() trebuie să precizeze
dacă ascultătorul primește intenții și de la alte aplicații
(RECEIVER_EXPORTED) sau doar din aplicația proprie
(RECEIVER_NOT_EXPORTED); altfel, activitatea se oprește cu
SecurityException. Serviciul se află în altă aplicație, deci se
folosește RECEIVER_EXPORTED.
@Override
protected void onResume() {
super.onResume();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
registerReceiver(startedServiceBroadcastReceiver, startedServiceIntentFilter, Context.RECEIVER_EXPORTED);
} else {
registerReceiver(startedServiceBroadcastReceiver, startedServiceIntentFilter);
}
}
@Override
protected void onPause() {
unregisterReceiver(startedServiceBroadcastReceiver);
super.onPause();
}
override fun onResume() {
super.onResume()
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
registerReceiver(startedServiceBroadcastReceiver, startedServiceIntentFilter, Context.RECEIVER_EXPORTED)
} else {
registerReceiver(startedServiceBroadcastReceiver, startedServiceIntentFilter)
}
}
override fun onPause() {
unregisterReceiver(startedServiceBroadcastReceiver)
super.onPause()
}
d) Să se oprească serviciul printr-un apel al metodei stopService(). Unde ar putea fi plasată aceasta? Care sunt avantajele și dezavantajele unei astfel de abordări?
7. Rulați din nou aplicația, întrerupând temporar activitatea (printr-o apăsare a tastei Home) în timp ce sunt procesate intențiile cu difuzare transmise de serviciu. Ce observați la revenirea în activitate?
Modificați aplicația astfel încât, atunci când activitatea nu este vizibilă, mesajele primite de la serviciu să fie semnalate printr-o notificare. La apăsarea pe notificare, activitatea revine în prim-plan și afișează mesajul.
Notă: de la Android 10, o aplicație aflată în background nu poate porni direct o activitate (Restrictions on starting activities from the background). Pornirea este permisă atunci când utilizatorul apasă pe o notificare, prin intermediul unui
PendingIntent.
a) pentru ca ascultătorul de intenții cu difuzare să poată procesa
mesaje chiar și în situația în care activitatea nu este vizibilă, el
trebuie declarat, împreună cu filtrul de intenții, în fișierul
AndroidManifest.xml al aplicației StartedServiceActivity. Tot aici se
declară permisiunea de a afișa notificări. În Java, clasa se află în
pachetul .view: android:name=".view.StartedServiceBroadcastReceiver".
<manifest ...>
<uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
<application ...>
<receiver
android:name=".StartedServiceBroadcastReceiver"
android:exported="true">
<intent-filter>
<action android:name="ro.pub.cs.systems.eim.lab05.startedservice.string" />
<action android:name="ro.pub.cs.systems.eim.lab05.startedservice.integer" />
<action android:name="ro.pub.cs.systems.eim.lab05.startedservice.arraylist" />
</intent-filter>
</receiver>
</application>
</manifest>
b) ascultătorul declarat în manifest este instanțiat de sistem printr-un constructor fără parametri, deci nu are acces la câmpul text:
public StartedServiceBroadcastReceiver() {
this.messageTextView = null;
}
constructor() : this(null)
c) în activitate, se cere permisiunea de a afișa notificări (Android
13+) și se reține dacă activitatea este vizibilă. Constantele
CHANNEL_ID, NOTIFICATION_ID și PERMISSION_REQUEST_POST_NOTIFICATIONS
se definesc în Constants.
public static boolean isVisible = false;
@Override
protected void onCreate(Bundle savedInstanceState) {
// ...
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU &&
ContextCompat.checkSelfPermission(this, Manifest.permission.POST_NOTIFICATIONS) != PackageManager.PERMISSION_GRANTED) {
ActivityCompat.requestPermissions(
this,
new String[]{Manifest.permission.POST_NOTIFICATIONS},
Constants.PERMISSION_REQUEST_POST_NOTIFICATIONS);
}
}
@Override
protected void onResume() {
super.onResume();
isVisible = true;
// ...
}
@Override
protected void onPause() {
// ...
isVisible = false;
super.onPause();
}
companion object {
var isVisible = false
}
override fun onCreate(savedInstanceState: Bundle?) {
// ...
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU &&
ContextCompat.checkSelfPermission(this, Manifest.permission.POST_NOTIFICATIONS) != PackageManager.PERMISSION_GRANTED
) {
ActivityCompat.requestPermissions(
this,
arrayOf(Manifest.permission.POST_NOTIFICATIONS),
Constants.PERMISSION_REQUEST_POST_NOTIFICATIONS
)
}
}
override fun onResume() {
super.onResume()
isVisible = true
// ...
}
override fun onPause() {
// ...
isVisible = false
super.onPause()
}
d) în onReceive(), dacă activitatea nu este vizibilă, ascultătorul
afișează o notificare. La apăsarea pe notificare, PendingIntent-ul
pornește activitatea, cu mesajul în câmpul extra:
@Override
public void onReceive(Context context, Intent intent) {
// ...
if (messageTextView == null && data != null && !StartedServiceActivity.isVisible) {
showNotification(context, data);
}
}
private void showNotification(Context context, String message) {
NotificationManager notificationManager = context.getSystemService(NotificationManager.class);
notificationManager.createNotificationChannel(
new NotificationChannel(Constants.CHANNEL_ID, "Started Service", NotificationManager.IMPORTANCE_DEFAULT));
Intent startedServiceActivityIntent = new Intent(context, StartedServiceActivity.class);
startedServiceActivityIntent.putExtra(Constants.MESSAGE, message);
startedServiceActivityIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_SINGLE_TOP);
PendingIntent pendingIntent = PendingIntent.getActivity(
context,
0,
startedServiceActivityIntent,
PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE);
Notification notification = new Notification.Builder(context, Constants.CHANNEL_ID)
.setSmallIcon(android.R.drawable.ic_dialog_info)
.setContentTitle("Started Service")
.setContentText(message)
.setContentIntent(pendingIntent)
.setAutoCancel(true)
.setOnlyAlertOnce(true)
.build();
notificationManager.notify(Constants.NOTIFICATION_ID, notification);
}
override fun onReceive(context: Context, intent: Intent) {
// ...
if (messageTextView == null && data != null && !StartedServiceActivity.isVisible) {
showNotification(context, data)
}
}
private fun showNotification(context: Context, message: String) {
val notificationManager = context.getSystemService(NotificationManager::class.java)
notificationManager.createNotificationChannel(
NotificationChannel(Constants.CHANNEL_ID, "Started Service", NotificationManager.IMPORTANCE_DEFAULT)
)
val startedServiceActivityIntent = Intent(context, StartedServiceActivity::class.java).apply {
putExtra(Constants.MESSAGE, message)
addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
}
val pendingIntent = PendingIntent.getActivity(
context,
0,
startedServiceActivityIntent,
PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
)
val notification = Notification.Builder(context, Constants.CHANNEL_ID)
.setSmallIcon(android.R.drawable.ic_dialog_info)
.setContentTitle("Started Service")
.setContentText(message)
.setContentIntent(pendingIntent)
.setAutoCancel(true)
.setOnlyAlertOnce(true)
.build()
notificationManager.notify(Constants.NOTIFICATION_ID, notification)
}
Intenția din notificare folosește următorii parametri:
- Intent.FLAG_ACTIVITY_NEW_TASK - prin care activitatea este plasată într-un nou set de sarcini pe stivă, pe care utilizatorul le poate gestiona independent;
- Intent.FLAG_ACTIVITY_SINGLE_TOP - prin care activitatea nu este repornită dacă se găsește deja la baza stivei care reține istoricul operațiunilor realizate de utilizator.
Astfel, activitatea va fi invocată prin intermediul intenției, în
condițiile în care aceasta este activă (se găsește în memorie, fiind
plasată pe stiva de activități, fără a fi vizibilă). De aceea, aceasta
va invoca metoda de callback
onNewIntent()
pe care trebuie realizată afișarea informațiilor transmise în câmpul
extra al intenției.
@Override
protected void onNewIntent(Intent intent) {
super.onNewIntent(intent);
String message = intent.getStringExtra(Constants.MESSAGE);
if (message != null) {
messageTextView.setText(messageTextView.getText().toString() + "\n" + message);
}
}
override fun onNewIntent(intent: Intent) {
super.onNewIntent(intent)
val message = intent.getStringExtra(Constants.MESSAGE)
message?.let {
messageTextView.text = "${messageTextView.text}\n$it"
}
}
Verificați: cât timp activitatea este vizibilă, mesajele apar în câmpul text; după Home, apare o notificare cu ultimul mesaj primit, iar la apăsarea pe ea activitatea revine și afișează mesajul.
8. Experimentați cu comenzile am/pm de la promptul Android adb shell:
pm list packages -3 # third-party packages
pm path <pkg> # path to apk
dumpsys activity services
service list
am start -n <pkg>/<activity>
am startservice -n <pkg>/<service>
am start-foreground-service -n ro.pub.cs.systems.eim.lab05.startedservice/.StartedService <
am broadcast -a <action>