[Android] App Components (3) - Service 완벽 가이드

 

 

 

Android의 4대 컴포넌트 중 하나인 Service는 UI 없이 백그라운드에서 실행되며 장시간 작업을 수행하는 핵심 요소입니다.

음악 재생, 네트워크 작업, GPS 등 사용자와 직접 상호작용하지 않는 작업을 수행합니다.

 

이 가이드에서는 Service의 개념, 실행 방식, 최신 버전의 제약사항까지 알아보도록 하겠습니다.

 

---

 

Service

UI 없이 Background에서 실행되는 컴포넌트로, 앱의 실행 여부와 관계없이 장시간 수행해야 하는 작업을 처리하는데 사용됩니다.

Service는 앱이 사용자와 직접 상호작용하지 않아도 실행되며, 다른 컴포넌트(Activity, Broadcast Receiver 등)와 상호작용할 수 있습니다.

 

Service는 다음과 같이 2개로 나눌 수 있습니다.

• 포그라운드 서비스(Foreground Service)
  • 알림(Notification)과 합계 백그라운드에서 실행
  • 예) 음악 플레이어, 네비게이션 등
• 백그라운드 서비스(Background Service)
  
  • UI 없이 백그라운드에서 실행
  • Android 8.0(API 26) 이상에서는 실행에 제한
  • 예) 데이터 동기화, 네트워크 요청 등

 

그리고 구현 방식에 차이가 있는 BoundService가 있습니다.

순서대로 하나씩 알아보겠습니다.

 

 

Foreground Service

Foreground Service는 사용자가 현재 실행 중임을 인지할 수 있도록 알림(Notification)을 표시하면서 동작하는 서비스입니다.

보통 오래 실행되거나 중요한 작업(음악 재생, GPS 등)을 수행할 때 사용되며, 시스템의 메모리가 부족해도 쉽게 종료되지 않습니다.

 

다음은 간단한 Foreground Service 구현 예시입니다.

class MyForegroundService: Service() {
	
    override fun onCreate() {
        super.onCreate()
        startForeground(1, createNotification()) // Foreground 상태로 변경
    }

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        // 실행할 작업 수행
        return START_STICKY
    }

    override fun onDestroy() {
        super.onDestroy()
        stopForeground(true) // Foreground Service 종료
    }

    override fun onBind(intent: Intent?): IBinder? {
        return null
    }

    private fun createNotification(): Notification {
        val channelId = "foreground_service_channel"
        val channelName = "Foreground Service Channel"
        
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            val channel = NotificationChannel(
                channelId, channelName, NotificationManager.IMPORTANCE_LOW
            )
            val manager = getSystemService(NotificationManager::class.java)
            manager.createNotificationChannel(channel)
        }

        return NotificationCompat.Builder(this, channelId)
            .setContentTitle("Foreground Service")
            .setSmallIcon(R.drawable.ic_service_icon)
            .build()
    }
}

 

AndroidManifest.xml 내에 서비스를 선언해야 사용할 수 있습니다.

<manifest>
  <application>
      <service android:name=".MyForegroundService" />
  </application>
</manifest>

 

서비스를 실행하고자 하는 위치에서 Intent를 사용해 Foreground Service를 실행합니다.

val serviceIntent = Intent(context, MyForegroundService::class.java)
startForegroundService(serviceIntent)

 

 

Foreground Service를 실행할 때는 반드시 startForeground() 메서드를 호출해야 합니다.

시스템이 서비스 종료를 방지하고, 강제 종료될 가능성을 줄여줍니다.

 

참고로 이 메서드를 호출하지 않으면 Android 8.0(API 26) 이상의 환경에서는 서비스가 실행되지 않습니다.

startForeground(NOTIFICATION_ID, createNotification())

 

 

또한, Android 8.0부터 서비스에서 알림을 띄우기 위해 Notification Channel을 설정해야 합니다.

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
    val channel = NotificationChannel(
        "foreground_service_channel",
        "Foreground Service Channel",
        NotificationManager.IMPORTANCE_LOW
    )
    val manager = getSystemService(NotificationManager::class.java)
    manager.createNotificationChannel(channel)
}

 

 

서비스를 종료할 때는 아래와 같습니다.

첫 번째로 서비스 내에서 아래 함수를 호출하거나,

stopSelf()

 

두 번째로 외부에서 Intent를 사용해 종료합니다.

val serviceIntent = Intent(context, MyForegroundService::class.java)
stopService(serviceIntent)

 

 

Android 버전에 따른 변경 사항

Android 13 이후로 2가지의 유형이 추가되어, Android 14부터 Foreground Service를 8가지 유형으로 분류해야 합니다.

이제 앱이 Foreground Service를 시작할 때 적절한 유형을 선언해야 하며, 부적절한 유형을 사용하면 실행이 제한됩니다.

 

Foreground Service 유형	설명
mediaPlayback	음악, 동영상 등의 미디어 재생을 위한 서비스
mediaProjection	화면 녹화, 캡처를 위한 서비스
phoneCall	전화 및 VolP 통화를 위한 서비스
location	GPS와 같은 위치 기반 서비스
connectedDevice	블루투스, USB 등의 기기와 연결된 서비스
health	피트니스 및 건강 관련 서비스
remoteMessaging	푸시 알림을 포함한 원격 메시징 서비스
systemExempted	시스템에서 특별히 허용하는 서비스 (일반 앱에서 사용 불가)

 

 

아래와 같이 AndroidManifest.xml에 Foreground Service 유형을 선언해야 합니다.

<manifest>
  <application>
    <service
        android:name=".MyForegroundService"
        android:foregroundServiceType="mediaPlayback"/>
  </application>
</manifest>

 

그리고 선언한 유형에 맞는 권한을 추가해야 합니다.

<uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK" />

 

 

Background Service

Background Service는 사용자가 직접 인터페이스와 상호작용하지 않는 상태에서 실행되는 서비스를 의미합니다. 즉, 화면에 UI를 띄우지 않고 백그라운드에서 조용히 동작하는 서비스입니다. Foreground Service와 달리, 알림을 따로 표시하지 않아도 됩니다.

 

하지만 Android 8.0 이상부터 강력한 제한이 따르며, Android 13-14부터는 Foreground Service의 유형 분류까지 도입되며 더욱 사용이 어려워졌습니다.

 

 

다음은 간단한 Background Service 예시입니다.

class MyBackgroundService: Service() {

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int) {
        Thread {
            for (i in 1..10) {
                Log.d("Background Service", "Running: $i")
                Thread.sleep(1000)
            }
            stopSelf()
        }.start()
        return START_STICKY
    }

    override fun onBind(intent: Intent?): IBinder? {
        return null
    }
}

<manifest>
  <application>
      <service android:name=".MyBackgroundService" />
  </application>
</manifest>

val serviceIntent = Intent(this, MyBackgroundService::class.java)
startService(serviceIntent)

 

 

Background Service 실행 제한

앞에서 언급했다시피, Android 8.0 이상부터 백그라운드 실행이 제한됩니다. 즉, 앱이 백그라운드에 있으면 startService() 함수 호출이 실패하고, 몇 초 내에 자동으로 종료됩니다.

 

따라서 Background Service의 대안으로, 아래 두 가지 방법이 있습니다.

1. Foreground Service로 대체하기
2. WorkManager 사용하기

앞에서 Foreground Service에 대해 알아보았으니, WorkManager에 대해서만 간략히 설명하겠습니다.

 

 

WorkManager

WorkManager는 백그라운드 작업을 안전하고 효율적으로 실행하기 위한 Jetpack 라이브러리입니다.

앱이 종료되거나 기기가 재부팅되어도 작업을 유지할 수 있고, 네트워크나 배터리 상태 등을 고려하여 작업을 실행할 수 있습니다.

class MyWorker(context: Context, workerParams: WorkerParameters) : Worker(context, workerParams) {
    override fun doWork(): Result {
        // 백그라운드에서 실행할 작업
        return Result.success()
    }
}

// Work 요청 생성 및 실행
val workRequest = OneTimeWorkRequestBuilder<MyWorker>().build()
WorkManager.getInstance(context).enqueue(workRequest)

 

작업을 한 번 또는, 주기적으로 수행하도록 설정할 수 있습니다.

실제로 Foreground Service를 통해 수시로 얻은 사용자 데이터를 하루에 한 번 서버에 저장할 때 WorkManager를 사용했습니다. 실행 간격을 12시간으로 두긴 했는데, 실제로는 더 빠르거나 느려지는 경우가 있었습니다.
정확히 설정한 주기대로 동작하지는 않고, 어느 정도의 오차는 있습니다.

 

728x90

 

 

Bound Service

Bound Service는 클라이언트(Activity, Fragment 등)가 바인딩(Binding)하여 직접 상호작용할 수 있는 서비스입니다. 즉, 클라이언트와 서버가 연결된 형태로 동작하는 서비스입니다.

 

Bound Service는 클라이언트와 서버(서비스) 간의 양방향 통신이 가능하며, 클라이언트가 바인딩을 해제하면 서비스가 자동으로 종료됩니다. Messager, AIDL, Binder 등의 메커니즘을 사용하여 데이터를 교환할 수 있습니다.

 

Bound Service 기본적인 동작은 다음과 같습니다.

1. 클라이언트가 bindService()를 호출하여 서비스에 바인딩
2. 서비스는 onBind()를 구현하여 IBinder 객체를 반환
3. 클라이언트는 IBinder를 통해 서비스의 메서드를 호출
4. 클라이언트가 unbindService()를 호출하거나 소멸되면 서비스도 종료

 

Bound Service를 구현하는 여러 가지 방법을 하나씩 살펴보겠습니다.

 

LocalBinder

클라이언트와 서비스가 같은 프로세스에서 실행될 때 사용하는 가장 간단한 방법입니다.

서비스에서 Binder 객체를 반환하면, 클라이언트는 이를 이용해 서비스의 메서드를 직접 호출할 수 있습니다.

 

직접 메서드를 호출하기 때문에 성능이 좋고 여러 개의 클라이언트를 동시에 연결할 수 있습니다.

하지만 다른 프로세스에서는 사용할 수 없습니다.

 

기본적인 동작은 다음과 같습니다.

1. 서비스에서 Binder 객체를 생성하고 반환
2. 클라이언트가 bindService()를 호출하면, onBind()에서 Binder를 반환
3. 클라이언트는 Binder를 이용해 서비스의 메서드를 직접 호출

다음은 LocalBinder를 사용하여 구현한 코드입니다.

class MyLocalService : Service() {
    private val binder = LocalBinder()

    inner class LocalBinder : Binder() {
        fun getService(): MyBoundService = this@MyLocalService
    }

    override fun onBind(intent: Intent?): IBinder {
        return binder
    }

    fun getData(): String {
        return "Hello from Bound Service!"
    }
}

class MainActivity : AppCompatActivity() {
    private var service: MyLocalService? = null
    private var isBound = false
    private val connection = object : ServiceConnection {
        override fun onServiceConnected(name: ComponentName?, binder: IBinder?) {
            val localBinder = binder as MyLocalService.LocalBinder
            service = localBinder.getService()
            isBound = true
        }

        override fun onServiceDisconnected(name: ComponentName?) {
            isBound = false
        }
    }

    override fun onStart() {
        super.onStart()
        val intent = Intent(this, MyLocalService::class.java)
        bindService(intent, connection, Context.BIND_AUTO_CREATE)
    }

    override fun onStop() {
        super.onStop()
        if (isBound) {
            unbindService(connection)
            isBound = false
        }
    }
}

 

여기서 MyBoundService가 서버, MainActivity가 클라이언트의 역할입니다.

 

정리하자면, Local Binder는 같은 앱 내에서 서비스의 메서드를 직접 호출할 때, 프로세스 간 통신(IPC)이 필요 없을 때 사용합니다.

예를 들어 음악 플레이어 앱에서 현재 재생 중인 곡의 정보를 가져오거나, 피트니스 앱에서 실시간 센서 데이터를 가져오는 경우에 사용할 수 있습니다.

 

 

Messenger

IPC(Inter-Process-Communication)를 지원하는 방식입니다. 핸들러를 이용하여 서비스와 클라이언트 간에 메시지를 주고받으며 비동기 처리가 가능합니다. 따라서 Messenger는 비동기 메시징 방식이기 때문에 직접 메서드를 호출할 수 없습니다.

이 방식은 클라이언트가 서비스에 직접 접근할 필요 없이 요청을 메시지 형태로 전달하는 방식입니다. 따라서 데이터를 Message 객체로 전달해야 하며, 대용량 데이터 처리에는 적합하지 않습니다.

 

기본적인 동작은 다음과 같습니다.

1. 서비스는 Handler를 생성하여 Messenger를 통해 클라이언트의 메시지를 처리
2. 클라이언트는 Messenger 객체를 사용하여 메시지를 전송
3. 서비스는 메시지를 받고 필요한 작업을 수행한 후 응답을 보낼 수 있음

다음은 Messenger를 사용하여 구현한 코드입니다.

class MyMessengerService : Service() {
    private val messenger = Messenger(IncomingHandler())

    inner class IncomingHandler : Handler(Looper.getMainLooper()) {
        override fun handleMessage(msg: Message) {
            when (msg.what) {
                1 -> Log.d("MessengerService", "Received Message from Client")
                else -> super.handleMessage(msg)
            }
        }
    }

    override fun onBind(intent: Intent?): IBinder {
        return messenger.binder
    }
}

class ClientActivity : AppCompatActivity() {
    private var messenger: Messenger? = null
    private val connection = object : ServiceConnection {
        override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
            messenger = Messenger(service)
            val message = Message.obtain(null, 1)
            messenger?.send(message)
        }

        override fun onServiceDisconnected(name: ComponentName?) {
            messenger = null
        }
    }

    override fun onStart() {
        super.onStart()
        Intent(this, MyMessengerService::class.java).also { intent ->
            bindService(intent, connection, Context.BIND_AUTO_CREATE)
        }
    }

    override fun onStop() {
        super.onStop()
        unbindService(connection)
    }
}

 

Messenger는 여러 클라이언트가 하나의 서비스와 통신해야 하지만, 한 번에 하나의 요청만 처리하면 되는 경우에 사용합니다.

또한 프로세스 간 통신(IPC)이 필요하지만 단순히 메시지 전달이 주목적일 때, 그리고 서비스가 여러 클라이언트와 연결되지만 요청을 순차적으로 처리할 때 사용합니다.

 

예를 들자면, 파일 다운로드 상태를 UI와 Notification에 동시에 전달하거나, 게임 앱에서 백그라운드 서비스가 서버에서 데이터를 받아와 UI를 업데이트하는 경우에 사용될 수 있습니다.

 

 

AIDL(Android Interface Definition Language)

AIDL은 다른 프로세스에서도 서비스의 메서드를 직접 호출할 수 있도록 지원하는 IPC 방식입니다.

Messagenger보다 더 강력한 기능을 제공하며, 다중 클라이언트가 동시에 요청을 보낼 수 있습니다. 하지만 설정이 복잡하고, 개발 비용이 높다는 단점이 있습니다.

 

기본적인 동작은 다음과 같습니다.

1. AIDL 파일을 생성하여 인터페이스 정의 (.aidl 파일)
2. 컴파일러가 자동으로 Stub 클래스를 생성
3. 클라이언트는 binderService()를 통해 서비스에 바인딩
4. 클라이언트는 Stub 객체를 사용하여 원격 메서드를 직접 호출

다음은 AIDL를 사용하여 구현한 코드입니다.

AIDL은 앞선 LocalBinder, Messenger와 달리 .aidl 파일을 생성해야 합니다.

package com.example.aidl;
interface MyAidlInterface {
    String getMessage();
}

class MyAidlService : Service() {
    private val binder = object : MyAidlInterface.Stub() {
        override fun getMessage(): String {
            return "Hello from AIDL Service!"
        }
    }

    override fun onBind(intent: Intent?): IBinder {
        return binder
    }
}

class ClientActivity : AppCompatActivity() {
    private var myService: MyAidlInterface? = null
    private val connection = object : ServiceConnection {
        override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
            myService = MyAidlInterface.Stub.asInterface(service)
            Log.d("AIDLService", "Message: ${myService?.getMessage()}")
        }

        override fun onServiceDisconnected(name: ComponentName?) {
            myService = null
        }
    }

    override fun onStart() {
        super.onStart()
        Intent(this, MyAidlService::class.java).also { intent ->
            bindService(intent, connection, Context.BIND_AUTO_CREATE)
        }
    }

    override fun onStop() {
        super.onStop()
        unbindService(connection)
    }
}

 

정리하자면 AIDL은 멀티 프로세스 환경에서 클라이언트가 원격 메서드를 호출하고, 복잡한 데이터(객체, 리스트 등)를 처리할 때 사용합니다. 병렬로 처리해야 하는 요청이 있거나, 여러 클라이언트가 동시에 요청을 보내고 응답을 받아야 하는 경우에도 사용할 수 있습니다.

 

예를 들면 미디어 플레이어 앱이 Android System Media Session Service와 통신하거나, VPN 서비스에서 네트워크 트래픽을 제어하는 경우에 사용할 수 있습니다.

 

---

 

지금까지 서비스에 대한 개념과 동작 방식, 다양한 유형에 대해 살펴보았습니다. 안드로이드에서 서비스는 백그라운드 작업을 수행하는 핵심적인 컴포넌트이지만, 배터리 최적화 및 사용자 경험을 고려해야 하므로 사용에 주의가 필요합니다.

특히 최신 안드로이드 버전에서는 백그라운드 서비스에 대한 제약이 강화되어 WorkManager와 같은 대체 방안을 권장하고 있습니다.

 

서비스는 앱의 구조와 성능에 큰 영향을 미칠 수 있으므로, 상황에 맞는 최적의 방식을 선택하여 효율적으로 구현하는 것이 가장 중요합니다.

 

---

안드로이드 개발자 로드맵을 따라 정리한 내용입니다.