Test practic 1

** Exemplu subiect Colocviu 1, Soluția **

** Rezolvare java:** https://ocw.cs.pub.ro/courses/eim/colocvii/colocviu01

Cerințe pentru colocviul 1

  • un cont GitHub personal;

  • Android SDK (imagine pentru API 36);

  • Android Studio;

  • un dispozitiv mobil:

    • fizic (bring your own device); sau

    • virtual: Genymotion, AVD.

A.1

a) Crearea depozitului GitHub

  1. Autentifică-te în GitHub (Sign in).

  2. Creează un proiect nou (New Repository).

  3. Configurează repository-ul:

    • denumire;

    • tip: public;

    • modul de inițializare:

      • local, cu git init; sau

      • la distanță, cu git clone (depozitul la distanță nu trebuie să fie vid în această situație);

    • fișier README cu numele studentului;

    • .gitignore (Android);

b) Clonarea depozitului

git clone https://www.github.com/perfectstudent/PracticalTest01

c) Crearea aplicației Android

Urmează indicațiile din secțiunea Crearea unei aplicații Android în Android Studio.

d) Configurarea aplicației și înregistrarea componentelor

In fișierul AndroidManifest.xml trebuie declarate toate activitățile și serviciile pe care le va utiliza aplicația.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">
    <application
        android:allowBackup="true"
        android:dataExtractionRules="@xml/data_extraction_rules"
        android:fullBackupContent="@xml/backup_rules"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.PracticalTest01"
        tools:targetApi="31">
        
        <activity
            android:name=".PracticalTest01MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        
        <activity android:name=".PracticalTest01SecondaryActivity" />
        
        <service android:name=".PracticalTest01Service" />
        
    </application>
</manifest>

A.2 Interfața grafică (layout)

Fișier XML în /res/layout.

Pentru interfața principală folosim un LinearLayout vertical pentru a așeza elementele unele sub altele, cu LinearLayout orizontale pentru rânduri. Folosim o împărțire orizontală 50/50 atât pentru rândul de EditText cât și pentru cel de Button prin atribuirea android:layout_weight="1" și android:layout_width="0dp" fiecărui copil din interiorul unui container părinte cu weightSum="2".

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:fitsSystemWindows="true"
    android:padding="16dp">

    <Button
        android:id="@+id/navigate_button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="end"
        android:layout_marginBottom="32dp"
        android:text="NAVIGATE TO SECONDARY ACTIVITY" />

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal"
        android:weightSum="2">

        <EditText
            android:id="@+id/left_text"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:enabled="false"
            android:gravity="center"
            android:saveEnabled="false"
            android:text="0" />

        <EditText
            android:id="@+id/right_text"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:enabled="false"
            android:gravity="center"
            android:saveEnabled="false"
            android:text="0" />
    </LinearLayout>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal"
        android:weightSum="2"
        android:layout_marginTop="16dp">

        <Button
            android:id="@+id/left_button"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:text="PRESS ME!"
            android:layout_marginEnd="8dp"/>

        <Button
            android:id="@+id/right_button"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:text="PRESS ME, TOO!"
            android:layout_marginStart="8dp"/>
    </LinearLayout>
</LinearLayout>

B.1 Tratarea evenimentelor UI

Listener-ele de click sunt atașate butoanelor folosind metoda setOnClickListener. La fiecare apăsare de buton, leftCount sau rightCount este incrementat, iar EditText-ul corespunzător este actualizat imediat folosind .setText() pentru a afișa noua valoare pe ecran.

leftButton.setOnClickListener {
    leftCount++
    leftText.setText(leftCount.toString())
    checkAndStartService()
}

rightButton.setOnClickListener {
    rightCount++
    rightText.setText(rightCount.toString())
    checkAndStartService()
}

B.2 Salvarea/restaurarea stării

Pentru a împiedica sistemul de operare Android să salveze și să restaureze automat starea interfeței, proprietatea android:saveEnabled="false" a fost adăugată câmpurilor de text din layout-ul XML.

Implementarea manuală a salvării și restaurării se face folosind metodele ciclului de viață:

// In interiorul metodei onCreate()
if (savedInstanceState != null) {
    if (savedInstanceState.containsKey("leftCount")) {
        leftCount = savedInstanceState.getInt("leftCount")
        leftText.setText(leftCount.toString())
    }
    if (savedInstanceState.containsKey("rightCount")) {
        rightCount = savedInstanceState.getInt("rightCount")
        rightText.setText(rightCount.toString())
    }
}
// In interiorul clasei PracticalTest01MainActivity.kt
override fun onSaveInstanceState(outState: Bundle) {
    super.onSaveInstanceState(outState)
    outState.putInt("leftCount", leftCount)
    outState.putInt("rightCount", rightCount)
}

C.1 Definirea unei activități secundare

Layout secundar

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:fitsSystemWindows="true"
    android:padding="16dp"
    android:gravity="center_horizontal">

    <TextView
        android:id="@+id/total_text"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textSize="24sp"
        android:layout_marginBottom="32dp" />

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal"
        android:weightSum="2">

        <Button
            android:id="@+id/ok_button"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:text="OK" />

        <Button
            android:id="@+id/cancel_button"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:text="Cancel" />
    </LinearLayout>
</LinearLayout>

Cod activitate secundară

package ro.pub.cs.systems.eim.practicaltest01

import android.content.Intent
import android.os.Bundle
import android.widget.Button
import android.widget.TextView
import androidx.appcompat.app.AppCompatActivity

class PracticalTest01SecondaryActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_practical_test01_secondary)

        val totalText: TextView = findViewById(R.id.total_text)
        val okButton: Button = findViewById(R.id.ok_button)
        val cancelButton: Button = findViewById(R.id.cancel_button)

        if (intent != null && intent.hasExtra("totalClicks")) {
            val clicks = intent.getIntExtra("totalClicks", 0)
            totalText.text = "Total clicks: $clicks"
        }

        okButton.setOnClickListener {
            setResult(RESULT_OK, Intent())
            finish()
        }

        cancelButton.setOnClickListener {
            setResult(RESULT_CANCELED, Intent())
            finish()
        }
    }
}

C.2 Navigarea către activitatea secundară

Se utilizează ActivityResultLauncher în detrimentul metodei depreciate startActivityForResult.

// In PracticalTest01MainActivity.kt
private val activityResultLauncher = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
    if (result.resultCode == RESULT_OK) {
        Toast.makeText(this, "Result from secondary activity: OK", Toast.LENGTH_LONG).show()
    } else if (result.resultCode == RESULT_CANCELED) {
        Toast.makeText(this, "Result from secondary activity: CANCELED", Toast.LENGTH_LONG).show()
    }
}

// In interiorul metodei onCreate()
navigateButton.setOnClickListener {
    val intent = Intent(this, PracticalTest01SecondaryActivity::class.java)
    val totalClicks = leftCount + rightCount
    intent.putExtra("totalClicks", totalClicks)
    activityResultLauncher.launch(intent)
}

D.1 Serviciu Android (started service)

Pornire/Oprire serviciu din activitatea principală

// In PracticalTest01MainActivity.kt
private fun checkAndStartService() {
    if (leftCount + rightCount > SERVICE_THRESHOLD && !serviceStarted) {
        val intent = Intent(this, PracticalTest01Service::class.java)
        intent.putExtra("firstNumber", leftCount)
        intent.putExtra("secondNumber", rightCount)
        startService(intent)
        serviceStarted = true
    }
}

override fun onDestroy() {
    val intent = Intent(this, PracticalTest01Service::class.java)
    stopService(intent)
    super.onDestroy()
}

Implementare serviciu

// PracticalTest01Service.kt
package ro.pub.cs.systems.eim.practicaltest01

import android.app.Service
import android.content.Context
import android.content.Intent
import android.os.IBinder

class PracticalTest01Service : Service() {
    private var processingThread: ProcessingThread? = null

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        val first = intent?.getIntExtra("firstNumber", 0) ?: 0
        val second = intent?.getIntExtra("secondNumber", 0) ?: 0
        processingThread = ProcessingThread(this, first, second)
        processingThread?.start()
        return START_REDELIVER_INTENT
    }

    override fun onBind(intent: Intent?): IBinder? = null

    override fun onDestroy() {
        processingThread?.stopThread()
        super.onDestroy()
    }
}

Thread de procesare periodică

// In acelasi pachet, clasa ProcessingThread
class ProcessingThread(private val context: Context, private val num1: Int, private val num2: Int) : Thread() {
    private var isRunning = true
    private val actions = listOf(
        "ro.pub.cs.systems.eim.action1",
        "ro.pub.cs.systems.eim.action2",
        "ro.pub.cs.systems.eim.action3"
    )

    override fun run() {
        while (isRunning) {
            val date = java.util.Date().toString()
            val arithmeticMean = (num1 + num2) / 2.0
            val geometricMean = Math.sqrt((num1 * num2).toDouble())
            
            val intent = Intent()
            intent.action = actions.random()
            intent.putExtra("message", "Time: $date, ArithMean: $arithmeticMean, GeomMean: $geometricMean")
            context.sendBroadcast(intent) 
            
            try {
                sleep(10000) 
            } catch (e: InterruptedException) {
                e.printStackTrace()
            }
        }
    }

    fun stopThread() {
        isRunning = false
    }
}

D.2 BroadcastReceiver

Implementăm recepția mesajelor trimise de către serviciu folosind un BroadcastReceiver înregistrat pe filtre de intenții explicite. Incepând cu Android 13 (Tiramisu), este necesar ca flag-ul de export să fie specificat.

// In PracticalTest01MainActivity.kt
private val messageBroadcastReceiver = object : BroadcastReceiver() {
    override fun onReceive(context: Context?, intent: Intent?) {
        Log.d("PracticalTest01Broadcast", intent?.getStringExtra("message") ?: "Empty")
    }
}

private val intentFilter = IntentFilter().apply {
    addAction("ro.pub.cs.systems.eim.action1")
    addAction("ro.pub.cs.systems.eim.action2")
    addAction("ro.pub.cs.systems.eim.action3")
}

override fun onResume() {
    super.onResume()
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
        registerReceiver(messageBroadcastReceiver, intentFilter, RECEIVER_EXPORTED)
    } else {
        registerReceiver(messageBroadcastReceiver, intentFilter)
    }
}

override fun onPause() {
    unregisterReceiver(messageBroadcastReceiver)
    super.onPause()
}

D.3 Comenzi Git utile

# adaugă toate modificările
git add *

# commit cu mesaj
git commit -m "finished tasks for PracticalTest01"

# push pe master
git push origin master

Configurare utilizator (dacă e necesar):

git config --global user.name "Perfect Student"
git config --global user.email perfectstudent@cs.pub.ro

Varianta Jetpack Compose

A.1. Application Setup and Component Registration

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">
    <application
        android:allowBackup="true"
        android:dataExtractionRules="@xml/data_extraction_rules"
        android:fullBackupContent="@xml/backup_rules"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.PracticalTest01"
        tools:targetApi="31">
        <activity
            android:name=".PracticalTest01MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <activity android:name=".PracticalTest01SecondaryActivity" />
        <service android:name=".PracticalTest01Service" />
    </application>
</manifest>

Configurăm structura proiectului și componentele Android necesare în AndroidManifest.xml. Activitatea PracticalTest01MainActivity este setată ca activitate de lansare (launcher) folosind un intent filter. De asemenea, am declarat PracticalTest01SecondaryActivity și PracticalTest01Service aici, astfel încât sistemul Android să le recunoască. Numele pachetului ro.pub.cs.systems.eim.practicaltest01 este păstrat strict în toate fișierele.

A.2. Graphical Interface

Column(
    modifier = Modifier
        .fillMaxSize()
        .systemBarsPadding()
        .padding(16.dp),
    horizontalAlignment = Alignment.CenterHorizontally
) {
    Spacer(modifier = Modifier.height(16.dp))
    Row(modifier = Modifier.fillMaxWidth()) {
        TextField(
            value = leftCount.toString(),
            onValueChange = {},
            readOnly = true,
            modifier = Modifier.weight(1f),
            textStyle = LocalTextStyle.current.copy(textAlign = TextAlign.Center),
            colors = TextFieldDefaults.colors(
                unfocusedContainerColor = Color.Transparent,
                focusedContainerColor = Color.Transparent
            )
        )
        TextField(
            value = rightCount.toString(),
            onValueChange = {},
            readOnly = true,
            modifier = Modifier.weight(1f),
            textStyle = LocalTextStyle.current.copy(textAlign = TextAlign.Center),
            colors = TextFieldDefaults.colors(
                unfocusedContainerColor = Color.Transparent,
                focusedContainerColor = Color.Transparent
            )
        )
    }
    
    Spacer(modifier = Modifier.height(16.dp))
}

Am folosit un Column pentru alinierea verticală și Row pentru elementele orizontale. Folosim o împărțire orizontală 50/50 pentru TextField și Button, aplicând Modifier.weight(1f) fiecărui copil. Am folosit RectangleShape și culoarea lightgray pentru a crea interfața după imaginea din examen.

B.1 Tratarea evenimentelor UI

Row(modifier = Modifier.fillMaxWidth()) {
    Button(
        onClick = {
            leftCount++
            checkAndStartService()
        },
        modifier = Modifier.weight(1f).padding(end = 8.dp),
        shape = RectangleShape,
        colors = ButtonDefaults.buttonColors(
            containerColor = Color(0xFFE0E0E0),
            contentColor = Color.Black
        )
    ) {
        Text("PRESS ME!")
    }
    Button(
        onClick = {
            rightCount++
            checkAndStartService()
        },
        modifier = Modifier.weight(1f).padding(start = 8.dp),
        shape = RectangleShape,
        colors = ButtonDefaults.buttonColors(
            containerColor = Color(0xFFE0E0E0),
            contentColor = Color.Black
        )
    ) {
        Text("PRESS ME, TOO!")
    }
}

Listener-ele de click sunt gestionate nativ în Compose prin parametrii lambda onClick ai componentelor Button. Când se apasă "PRESS ME!", se incrementează direct variabilele de stare (leftCount++ sau rightCount++). Deoarece Compose observă aceste variabile, declanșează instantaneu o recompoziție a interfeței pentru a afișa noile valori în câmpurile de text.

B.2 Salvarea/restaurarea stării

val context = LocalContext.current
var leftCount by rememberSaveable { mutableIntStateOf(0) }
var rightCount by rememberSaveable { mutableIntStateOf(0) }
var serviceStarted by rememberSaveable { mutableStateOf(false) }
val serviceThreshold = 5

Pentru a preveni pierderea datelor în timpul unei schimbări de configurare sau al opririi procesului, folosim funcția rememberSaveable din Compose. Aceasta salvează automat variabila în bundle-ul stării instanței și o restaurează fără probleme, eliminând nevoia de suprascrieri manuale ale onSaveInstanceState.

C.1 Definirea unei activități secundare

package ro.pub.cs.systems.eim.practicaltest01

import android.app.Activity
import android.content.Intent
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.compose.material3.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.RectangleShape
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp

class PracticalTest01SecondaryActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val totalClicks = intent?.getIntExtra("totalClicks", 0) ?: 0
        
        setContent {
            Column(
                modifier = Modifier.fillMaxSize().padding(16.dp),
                horizontalAlignment = Alignment.CenterHorizontally,
                verticalArrangement = Arrangement.Top
            ) {
                Text(text = "Total clicks: $totalClicks", fontSize = 24.sp)
                Spacer(modifier = Modifier.height(32.dp))
                Row(modifier = Modifier.fillMaxWidth()) {
                    Button(
                        onClick = {
                            setResult(Activity.RESULT_OK, Intent())
                            finish()
                        },
                        modifier = Modifier.weight(1f).padding(end = 8.dp),
                        shape = RectangleShape,
                        colors = ButtonDefaults.buttonColors(
                            containerColor = Color(0xFFE0E0E0),
                            contentColor = Color.Black
                        )
                    ) {
                        Text("OK")
                    }
                    Button(
                        onClick = {
                            setResult(Activity.RESULT_CANCELED, Intent())
                            finish()
                        },
                        modifier = Modifier.weight(1f).padding(start = 8.dp),
                        shape = RectangleShape,
                        colors = ButtonDefaults.buttonColors(
                            containerColor = Color(0xFFE0E0E0),
                            contentColor = Color.Black
                        )
                    ) {
                        Text("Cancel")
                    }
                }
            }
        }
    }
}

Se creează fișierul PracticalTest01MainActivity.kt, folosind Column pentru a așeza elementele vertical și plasând 2 componente TextField într-un Row orizontal, astfel încât să fie unul lângă altul, folosind Modifier.weight(1f) pentru ca ele să aibă același spațiu; câmpurile de text sunt doar pentru citire (read only) și au fundal transparent.

C.2 Navigarea către activitatea secundară

val launcher = rememberLauncherForActivityResult(
    contract = ActivityResultContracts.StartActivityForResult()
) { result ->
    if (result.resultCode == Activity.RESULT_OK) {
        Toast.makeText(context, "Result from secondary activity: OK", Toast.LENGTH_LONG).show()
    } else if (result.resultCode == Activity.RESULT_CANCELED) {
        Toast.makeText(context, "Result from secondary activity: CANCELED", Toast.LENGTH_LONG).show()
    }
}

Button(
    onClick = {
        val intent = Intent(context, PracticalTest01SecondaryActivity::class.java).apply {
            putExtra("totalClicks", leftCount + rightCount)
        }
        launcher.launch(intent)
    },
    shape = RectangleShape,
    colors = ButtonDefaults.buttonColors(
        containerColor = Color(0xFFE0E0E0),
        contentColor = Color.Black
    ),
    modifier = Modifier.align(Alignment.End)
) {
    Text("NAVIGATE TO SECONDARY ACTIVITY")
}

La apăsare, se calculează numărul total de click-uri, se atașează unui Intent prin putExtra(), iar apoi se lansează activitatea secundară. Se folosește rememberLauncherForActivityResult, care ascultă activ rezultatul returnat și declanșează un mesaj Toast care afișează dacă acțiunea a fost OK sau CANCELED.

D.1 Serviciu Android (started service)

// In PracticalTest01MainActivity.kt
fun checkAndStartService() {
    if (leftCount + rightCount > serviceThreshold && !serviceStarted) {
        val intent = Intent(context, PracticalTest01Service::class.java).apply {
            putExtra("firstNumber", leftCount)
            putExtra("secondNumber", rightCount)
        }
        context.startService(intent)
        serviceStarted = true
    }
}

override fun onDestroy() {
    stopService(Intent(this, PracticalTest01Service::class.java))
    super.onDestroy()
}
// PracticalTest01Service.kt
package ro.pub.cs.systems.eim.practicaltest01

import android.app.Service
import android.content.Context
import android.content.Intent
import android.os.IBinder

class PracticalTest01Service : Service() {
    private var processingThread: ProcessingThread? = null
    
    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        val first = intent?.getIntExtra("firstNumber", 0) ?: 0
        val second = intent?.getIntExtra("secondNumber", 0) ?: 0
        processingThread = ProcessingThread(this, first, second)
        processingThread?.start()
        return START_REDELIVER_INTENT
    }
    
    override fun onBind(intent: Intent?): IBinder? = null
    
    override fun onDestroy() {
        processingThread?.stopThread()
        super.onDestroy()
    }
}

class ProcessingThread(private val context: Context, private val num1: Int, private val num2: Int) : Thread() {
    private var isRunning = true
    private val actions = listOf(
        "ro.pub.cs.systems.eim.action1",
        "ro.pub.cs.systems.eim.action2",
        "ro.pub.cs.systems.eim.action3"
    )
    
    override fun run() {
        while (isRunning) {
            val date = java.util.Date().toString()
            val arithmeticMean = (num1 + num2) / 2.0
            val geometricMean = Math.sqrt((num1 * num2).toDouble())
            val intent = Intent()
            intent.action = actions.random()
            intent.putExtra("message", "Time: $date, ArithMean: $arithmeticMean, GeomMean: $geometricMean")
            context.sendBroadcast(intent)
            try {
                sleep(10000)
            } catch (e: InterruptedException) {
                e.printStackTrace()
            }
        }
    }
    
    fun stopThread() {
        isRunning = false
    }
}

Creăm un fișier Kotlin nou numit PracticalTest01Service.kt care să acționeze ca lucrător de fundal (background worker) și îl înregistrăm în AndroidManifest.xml pentru ca sistemul Android să știe că există. Dacă sunt mai mult de 5 click-uri, pornește în fundal. Odată pornit, serviciul creează o sarcină separată (un Thread) care rulează într-o buclă continuă. La fiecare 10 secunde, acest thread calculează media click-urilor, împachetează calculul într-un mesaj cu o etichetă aleatorie și îl transmite (broadcast) în tot sistemul; când închizi aplicația principală, ea îi spune automat serviciului din fundal să se oprească, ca să nu ruleze la nesfârșit și să consume resurse.

D.2 BroadcastReceiver

DisposableEffect(context) {
    val receiver = object : BroadcastReceiver() {
        override fun onReceive(c: Context?, intent: Intent?) {
            Log.d("PracticalTest01Broadcast", intent?.getStringExtra("message") ?: "Empty")
        }
    }
    val filter = IntentFilter().apply {
        addAction("ro.pub.cs.systems.eim.action1")
        addAction("ro.pub.cs.systems.eim.action2")
        addAction("ro.pub.cs.systems.eim.action3")
    }
    ContextCompat.registerReceiver(
        context,
        receiver,
        filter,
        ContextCompat.RECEIVER_NOT_EXPORTED
    )
    
    onDispose {
        context.unregisterReceiver(receiver)
    }
}