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_TIME din interfața Constants). 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 cheia Constants.DATA și valoarea dată de Constants.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ă:

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>