Implementación de servicios en Android: normal services y foreground services

Android has several core components that are essential for developing functional applications. These include activities, which are responsible for displaying the interface to the user via Compose AMOLED, and services, which manage background tasks such as tracking the user's location.

What types of services exist in Android?

There are two main categories of services:

• Normal services (normal services): these have no guarantee of continuity if the operating system needs to free up resources; they might stop if the application is closed.
• Foreground services: These have a high priority level and are guaranteed to run as long as they display a persistent notification indicating their activity to the user.

How to create a normal service in Android step by step?

To implement a normal service such as Tracking Service, it is essential to follow these steps:

1. Create the service class: it must extend from the Service class and carry the Android Entry Point annotation if dependency injection is used.

2. Implement required methods:

   • onBind(): establishes binding between activities and services. May return null if not needed for our case.
   • onStartCommand(): determines how and when the service is executed.

3. Manage the service logic:

4. Define internal variables (e.g. isServiceActive) to ensure that the service only runs once simultaneously.
5. Add specific functions such as Start and Stop to start and stop the task, handling corroutine cancellation appropriately.

override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int  {    when(intent?.action)  {        ACTION_START -> start()        ACTION_STOP -> stop()     }    return START_STICKY}

1. Declare the service in the manifest: this allows the operating system to initialize it properly.

<service android:name=".TrackingService" />

1. Launch the service from an activity using intents:

Intent(context, TrackingService::class.java).apply  {    action  = TrackingService.ACTION_START}.also  { context.startService(it)  }

What happens if the application is closed during the execution of the normal service?

A normal service might stop if the application that connects to it shuts down or the operating system needs resources. When tracking through logs, it is clear when the operating system terminates the execution of the service.

However, this limitation is precisely what differentiates the normal service from the foreground service, which ensures continuity even after the application is closed, as long as certain conditions are met, such as continuously displaying a persistent notification.

Learning how to use these services according to your needs will allow you to develop robust and efficient applications.

If you have any doubts or wish to go deeper into a particular aspect, we invite you to share your comment!