이 페이지는 Cloud Translation API를 통해 번역되었습니다.

서비스 개요

Service는 애플리케이션 구성요소 장기 실행 작업을 수행할 수 있습니다 사용자 인터페이스를 제공하지 않습니다. 한 번 사용자가 다른 서비스로 전환한 후에도 일정 기간 서비스가 계속 실행될 수 있음 애플리케이션입니다. 또한 구성요소는 서비스에 바인딩하여 서비스와 상호작용하고 프로세스 간 통신 (IPC) 예를 들어 서비스는 네트워크 트랜잭션을 처리하고 음악, 파일 I/O 수행, 콘텐츠 제공업체와의 상호작용을 모두 백그라운드에서 수행할 수 있습니다.

주의: 서비스는 호스팅의 기본 스레드에서 실행됩니다. 프로세스 서비스가 자체 스레드를 만들지 않고하지 않음 달리 지정하지 않는 한 별도의 프로세스에서 실행됩니다. 차단 작업을 실행하여 애플리케이션 발생을 방지하기 위해 서비스 내에 별도의 스레드가 있어야 합니다. 응답 없음 (ANR) 오류

서비스 유형

서비스에는 세 가지 유형이 있습니다.

포그라운드

포그라운드 서비스는 있습니다. 예를 들어 오디오 앱은 포그라운드 서비스를 사용하여 오디오 트랙입니다. 포그라운드 서비스는 알림을 표시해야 합니다. 포그라운드 서비스는 사용자가 상호작용하지 않을 때도 계속 실행됩니다. 할 수 있습니다.

포그라운드 서비스를 사용할 때 알림을 표시하여 사용자는 서비스가 실행 중임을 적극적으로 인지하고 있습니다. 이 알림을 통해 서비스가 중지되거나 서버에서 삭제되지 않는 한 포그라운드에서 실행되는 것으로 간주됩니다.

구성 방법 자세히 알아보기 포그라운드 서비스를 있습니다.

참고: WorkManager API는 유연한 작업 예약 방법을 제공하며 실행할 수 있는 필요한 경우 이러한 작업을 포그라운드 서비스로 사용할 수 있습니다. 대부분의 경우 WorkManager는 포그라운드 서비스를 직접 사용하는 것보다 더 낫습니다.

배경

백그라운드 서비스는 다른 사람이 직접 알아차리지 못하는 작업을 있습니다. 예를 들어 앱이 서비스를 사용하여 저장소를 압축한 경우 일반적인 백그라운드 서비스입니다

참고: 앱이 API 수준 26 이상을 타겟팅하는 경우 시스템에서 백그라운드 실행에 제한을 적용합니다. 서비스를 요청할 수 있습니다. 최대 예를 들어 위치 정보에 액세스해 백그라운드에 위치합니다. 대신 사용하는 WorkManager에 오신 것을 환영합니다.

바인드

애플리케이션 구성요소가 bindService()를 호출하여 서비스에 바인딩되면 서비스가 바인드됩니다. 바인드된 서비스는 클라이언트-서버 인터페이스를 통해 구성 요소가 서비스와 상호작용하고, 요청을 보내고, 결과를 수신하고, 프로세스 간 통신 (IPC)을 사용하여 프로세스 간에도 동일한 작업을 수행할 수 있습니다. 바인드된 서비스는 다른 애플리케이션 구성 요소가 바인딩된 경우에만 가능합니다. 여러 구성 요소가 모든 것이 바인딩 해제되면 서비스는 소멸됩니다.

이 문서에서는 일반적으로 시작된 서비스와 바인드된 서비스를 개별적으로 논의하지만 서비스는 두 가지 방식으로 작동할 수 있습니다. 즉, 무한히 실행되도록 시작할 수 있고 바인딩합니다. 몇 가지 콜백 메서드를 구현하는지 여부만 확인하면 됩니다. onStartCommand()는 구성요소가 이를 시작하도록 허용하고 onBind()는 바인딩을 허용합니다.

서비스가 시작되었든 바인딩되었든 아니면 둘 다 시작되었든 상관없이 모든 구성 요소가 사용할 수 있는 것과 동일한 방식으로 서비스를 사용할 수 있음 Intent로 시작하여 활동 생성 하지만 포드의 상태를 서비스를 private으로 설정하고 다른 애플리케이션의 액세스를 차단합니다. 자세한 내용은 매니페스트를 참조하세요.

서비스와 스레드 간의 선택

서비스는 단순히 백그라운드에서 실행될 수 있는 구성 요소일 뿐입니다. 이는 사용자가 따라서 서비스를 생성해야 하는 경우에는 해당 서비스에만 알 수 있습니다

사용자가 상호작용하는 동안에만 기본 스레드 외부에서 작업을 실행해야 하는 경우 대신 다른 애플리케이션의 컨텍스트에서 새 스레드를 생성해야 합니다. 구성요소를 사용합니다. 예를 들어 활동이 실행되는 동안에만 음악을 재생하고 싶다면 onCreate()에서 스레드를 만들 수 있습니다. onStart()에서 실행을 시작합니다 onStop()에서 중지합니다. 또한 java.util.concurrent 패키지의 스레드 풀과 실행자를 사용하는 것이 좋습니다. 또는 Kotlin 코루틴과 Thread 클래스. 자세한 내용은 Android의 스레딩 문서를 참고하세요. 실행을 백그라운드 스레드로 이동

서비스를 사용하더라도 해당 서비스는 기본값이므로 서비스가 집약적이거나 차단 작업을 수행합니다

기본 사항

서비스를 만들려면 Service의 서브클래스를 만들거나 서브클래스를 사용해야 합니다. 기존 서브클래스의 서브클래스를 사용합니다. 구현에서 서비스 수명 주기의 주요 측면을 처리하고 구성요소가 서비스에 바인딩합니다(해당되는 경우). 이들은 콜백 메서드를 실행해야 하는 가장 중요한 재정의:

onStartCommand(): 시스템은 다른 구성요소 (예: 활동)가 서비스 시작을 요청할 때 startService()를 호출하여 이 메서드를 호출합니다. 이 메서드가 실행되면 서비스가 시작되고 백그라운드를 무기한으로 유지할 수 없습니다. 이를 구현하면 개발자가 stopSelf() 또는 stopService()를 호출하여 작업이 완료됩니다. 바인딩만 제공하려면 알 수 있습니다.
onBind(): 시스템은 다른 구성요소가 서비스와 결합하려고 할 때 (예: RPC 수행) bindService()를 호출하여 이 메서드를 호출합니다. 이 메서드를 구현할 때 클라이언트가 IBinder를 반환하여 서비스와 통신하는 데 사용합니다. 항상 이 메서드를 구현하고 하지만 바인딩을 허용하지 않으려면 null입니다.
onCreate(): 시스템은 서비스가 실행 중일 때 일회성 설정 절차를 실행하기 위해 이 메서드를 호출합니다. kubectl을 호출하기 전에 onStartCommand() 또는 onBind())을 입력합니다. 서비스가 이미 실행 중인 경우 이 메서드는 합니다.
onDestroy(): 시스템은 서비스가 더 이상 사용되지 않고 소멸될 때 이 메서드를 호출합니다. 서비스는 스레드, 등록된 스레드와 같은 리소스를 정리하기 위해 이것을 구현해야 합니다. 리스너 또는 수신자입니다. 이는 서비스가 수신하는 마지막 호출입니다.

구성요소가 startService()를 호출하여 서비스를 시작하면 onStartCommand() 호출이 발생합니다. stopSelf() 또는 다른 코드로 자체적으로 중지될 때까지 계속 실행됩니다. 구성요소가 stopService()를 호출하여 이를 중지합니다.

구성요소가 bindService()를 사용하여 서비스를 만들며 onStartCommand()가 호출되지 않으면 서비스가 실행됩니다. 구성 요소가 바인딩된 경우에만 가능합니다. 서비스가 모든 클라이언트에서 바인드 해제된 후에는 시스템이 그것을 소멸시킵니다.

Android 시스템은 메모리가 부족하여 시스템을 복구해야 하는 경우에만 서비스를 중지합니다. 리소스를 많이 사용합니다. 서비스가 사용자가 있는 활동에 바인드된 경우 초점을 맞추면 다운될 가능성이 작습니다. 서비스가 포그라운드에서 실행되도록 선언되면 거의 종료되지 않습니다. 서비스가 시작되고 오래 실행되는 경우 시스템은 해당 위치를 낮춥니다. 백그라운드 작업 목록에 포함되지 않으며, 서비스는 서비스가 시작된 경우 재시작을 원활하게 처리하도록 설계해야 합니다. 있습니다. 시스템이 서비스를 종료해도 리소스가 확보되자마자 시스템이 서비스를 다시 시작합니다. onStartCommand()에서 반환하는 값에 따라서도 달라집니다. 자세한 내용은 시스템이 서비스를 소멸시킬 수 있는 경우에 대한 자세한 내용은 프로세스 및 스레딩 문서를 참조하세요.

다음 섹션에서는 startService() 및 bindService() 서비스 메서드 및 사용 방법 다른 애플리케이션 구성 요소에서 가져옵니다.

매니페스트에서 서비스 선언

애플리케이션의 매니페스트 파일에 대한 올바른 액세스를 허용해야 합니다.

서비스를 선언하려면 <service> 요소를 추가합니다. <application>의 하위 요소로 요소가 포함됩니다. 예를 들면 다음과 같습니다.

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

<service> 요소를 참고하세요. 참조하세요.

<service> 요소에 포함할 수 있는 다른 속성은 다음과 같습니다. 서비스 및 프로세스를 시작하는 데 필요한 권한과 같은 지정할 수도 있습니다 android:name 속성이 유일한 필수 속성으로, 서비스의 클래스 이름을 지정합니다. 후(After) 배포 시 애플리케이션이 중단될 위험을 방지하려면 이 이름을 변경하지 않은 상태로 두세요. 명시적 인텐트에 의존하여 서비스를 시작하거나 바인딩하기 때문입니다 (Things 이는 변경될 수 없음 참조).

주의: 앱이 안전하게 보호될 수 있도록 하려면 항상 명시적 인텐트는 Service를 시작할 때 발생하며, 다음에 대한 인텐트 필터를 선언하지 않음 제공합니다 암시적 인텐트를 사용하여 서비스를 시작하면 보안 위험이 있습니다. 인텐트에 응답하는 서비스에 대해 확신할 수 있고, 사용자가 어떤 서비스를 시작됩니다 Android 5.0 (API 수준 21)부터는 bindService()를 호출합니다.

다음 방법으로 자신의 앱에만 서비스를 사용하도록 할 수 있습니다. android:exported 포함 속성을 사용하고 false로 설정하면 됩니다. 이렇게 하면 다른 앱이 명시적 인텐트를 사용하는 경우에도 마찬가지입니다.

참고: 사용자는 기기에서 실행 중인 서비스를 확인할 수 있습니다. 만약 신뢰할 수 없는 서비스가 있는 경우 서비스를 중지할 수 있습니다. 포함 사용자가 실수로 서비스를 중단하지 않으려면 를 사용하여 android:description 드림 속성을 <service> 요소를 정의할 수 있습니다. 설명에는 서비스의 기능과 이점을 설명하는 짧은 문장을 제공하세요. 제공합니다

시작된 서비스 생성

시작된 서비스는 다른 구성요소가 startService()를 호출하여 시작하여 서비스의 onStartCommand() 메서드를 사용하여 지도 가장자리에 패딩을 추가할 수 있습니다.

서비스가 시작되면 수명 주기를 가지며 확인할 수 있습니다 해당 서비스는 백그라운드에서 무한히 실행될 수 있습니다. 컨테이너를 시작한 구성 요소가 제거됩니다. 따라서 서비스는 작업이 시작될 때 자체적으로 중지되어야 합니다. stopSelf()를 호출하여 완료되거나 다른 구성요소가 stopService()를 호출하여 중지합니다.

활동과 같은 애플리케이션 구성요소는 startService()를 호출하고 Intent를 전달하여 서비스를 시작할 수 있습니다. - 서비스를 지정하고 서비스에서 사용할 모든 데이터를 포함합니다. 서비스는 onStartCommand() 메서드에서 이 Intent를 호출합니다.

예를 들어 어느 액티비티가 온라인 데이터베이스에 어떤 데이터를 저장해야 한다고 가정해보겠습니다. 활동 컴패니언 서비스를 시작하고 인텐트를 startService()에 전달하여 저장할 데이터를 전달할 수 있습니다. 서비스는 onStartCommand()에서 인텐트를 수신하고 인터넷에 연결하고 데이터베이스 트랜잭션을 생성합니다 트랜잭션이 완료되면 서비스는 자체적으로 중지되고 있습니다.

주의: 서비스는 애플리케이션과 동일한 프로세스에서 실행됩니다. 기본 스레드에 선언됩니다. 서비스가 사용자가 동일한 액티비티의 액티비티와 상호작용하는 동안 집약적이거나 차단 작업을 수행하는 경우 서비스가 활동 성능을 저하시킵니다. 애플리케이션에 영향을 주지 않기 위해 서비스 내에서 새 스레드를 시작해야 합니다.

Service 클래스가 기본 클래스임 클래스를 확장하는 데 사용할 수 있습니다. 이 클래스를 확장할 때는 그 안에 있는 새 스레드를 만드는 것이 중요합니다. 서비스가 모든 작업을 완료할 수 있습니다. 서비스가 애플리케이션의 기본 스레드를 이로 인해 애플리케이션이 실행 중인 모든 활동의 성능이 느려질 수 있습니다.

Android 프레임워크는 IntentService 서브클래스를 사용하는 Service의 서브클래스입니다. 한 번에 하나씩 모든 시작 요청을 처리하도록 작업자 스레드가 필요합니다. 이 클래스를 사용하는 것은 권장 옵션은 몇 가지 이유로 Android 8 Oreo부터는 제대로 작동하지 않기 때문입니다. 백그라운드 실행 제한이 도입되었습니다. 또한 Android 11부터 지원이 중단됩니다. JobIntentService를 Android 최신 버전과 호환되는 IntentService를 대체합니다.

다음 섹션에서는 자체 맞춤 서비스를 구현하는 방법을 설명합니다. 대부분의 사용 사례에 대신 WorkManager를 사용하는 것이 좋습니다. Android에서의 백그라운드 처리에 관한 가이드를 참고하세요. 요구사항에 맞는 솔루션이 있는지 확인할 수 있습니다.

서비스 클래스 확장

Service 클래스를 확장할 수 있습니다. 수신 인텐트를 처리해야 합니다 기본 구현은 다음과 같습니다.

Kotlin

class HelloService : Service() {

    private var serviceLooper: Looper? = null
    private var serviceHandler: ServiceHandler? = null

    // Handler that receives messages from the thread
    private inner class ServiceHandler(looper: Looper) : Handler(looper) {

        override fun handleMessage(msg: Message) {
            // Normally we would do some work here, like download a file.
            // For our sample, we just sleep for 5 seconds.
            try {
                Thread.sleep(5000)
            } catch (e: InterruptedException) {
                // Restore interrupt status.
                Thread.currentThread().interrupt()
            }

            // Stop the service using the startId, so that we don't stop
            // the service in the middle of handling another job
            stopSelf(msg.arg1)
        }
    }

    override fun onCreate() {
        // Start up the thread running the service.  Note that we create a
        // separate thread because the service normally runs in the process's
        // main thread, which we don't want to block.  We also make it
        // background priority so CPU-intensive work will not disrupt our UI.
        HandlerThread("ServiceStartArguments", Process.THREAD_PRIORITY_BACKGROUND).apply {
            start()

            // Get the HandlerThread's Looper and use it for our Handler
            serviceLooper = looper
            serviceHandler = ServiceHandler(looper)
        }
    }

    override fun onStartCommand(intent: Intent, flags: Int, startId: Int): Int {
        Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show()

        // For each start request, send a message to start a job and deliver the
        // start ID so we know which request we're stopping when we finish the job
        serviceHandler?.obtainMessage()?.also { msg ->
            msg.arg1 = startId
            serviceHandler?.sendMessage(msg)
        }

        // If we get killed, after returning from here, restart
        return START_STICKY
    }

    override fun onBind(intent: Intent): IBinder? {
        // We don't provide binding, so return null
        return null
    }

    override fun onDestroy() {
        Toast.makeText(this, "service done", Toast.LENGTH_SHORT).show()
    }
}

자바

public class HelloService extends Service {
  private Looper serviceLooper;
  private ServiceHandler serviceHandler;

  // Handler that receives messages from the thread
  private final class ServiceHandler extends Handler {
      public ServiceHandler(Looper looper) {
          super(looper);
      }
      @Override
      public void handleMessage(Message msg) {
          // Normally we would do some work here, like download a file.
          // For our sample, we just sleep for 5 seconds.
          try {
              Thread.sleep(5000);
          } catch (InterruptedException e) {
              // Restore interrupt status.
              Thread.currentThread().interrupt();
          }
          // Stop the service using the startId, so that we don't stop
          // the service in the middle of handling another job
          stopSelf(msg.arg1);
      }
  }

  @Override
  public void onCreate() {
    // Start up the thread running the service. Note that we create a
    // separate thread because the service normally runs in the process's
    // main thread, which we don't want to block. We also make it
    // background priority so CPU-intensive work doesn't disrupt our UI.
    HandlerThread thread = new HandlerThread("ServiceStartArguments",
            Process.THREAD_PRIORITY_BACKGROUND);
    thread.start();

    // Get the HandlerThread's Looper and use it for our Handler
    serviceLooper = thread.getLooper();
    serviceHandler = new ServiceHandler(serviceLooper);
  }

  @Override
  public int onStartCommand(Intent intent, int flags, int startId) {
      Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show();

      // For each start request, send a message to start a job and deliver the
      // start ID so we know which request we're stopping when we finish the job
      Message msg = serviceHandler.obtainMessage();
      msg.arg1 = startId;
      serviceHandler.sendMessage(msg);

      // If we get killed, after returning from here, restart
      return START_STICKY;
  }

  @Override
  public IBinder onBind(Intent intent) {
      // We don't provide binding, so return null
      return null;
  }

  @Override
  public void onDestroy() {
    Toast.makeText(this, "service done", Toast.LENGTH_SHORT).show();
  }
}

예시 코드는 onStartCommand()에서 모든 수신 전화를 처리합니다. 백그라운드 스레드에서 실행되는 Handler에 작업을 게시합니다. IntentService처럼 작동하고 모든 요청을 순차적으로 차례로 처리합니다. 예를 들어 여러 요청을 동시에 실행하려는 경우 스레드 풀에서 작업을 실행하도록 코드를 변경할 수 있습니다.

onStartCommand() 메서드는 정수입니다. 이 정수는 시스템이 서비스를 계속하는 방법을 설명하는 값입니다. 종료한다는 것입니다. 반환 값 onStartCommand()의 값은 다음 중 하나여야 합니다. 상수:

START_NOT_STICKY: onStartCommand() 반환 후에 시스템이 서비스를 종료하는 경우 서비스를 다시 만들지 마세요. 대기 중인 서비스가 있는 경우가 아니라면 인텐트를 전송합니다. 필요하지 않을 때 서비스를 실행하지 않는 가장 안전한 옵션입니다. 그리고 애플리케이션이 완료되지 않은 작업을 간단히 다시 시작할 수 있는 경우에 적합합니다.
START_STICKY: onStartCommand()가 반환된 후 시스템이 서비스를 종료하면 서비스를 다시 만들고 onStartCommand()를 호출하되 마지막 인텐트는 다시 전송하지 않습니다. 대신 시스템이 onStartCommand()을 호출하는데 null 인텐트로 간주됩니다. 이 경우 전달될 수 있습니다 이는 동영상 플레이어의 무기한 실행되고 작업을 기다리는 중인지를 나타냅니다.
START_REDELIVER_INTENT: onStartCommand()가 반환된 후 시스템이 서비스를 종료하는 경우 서비스를 다시 만들고 서비스에 전달된 마지막 인텐트로 onStartCommand()를 호출합니다. 있습니다. 모든 보류 인텐트가 차례로 전달됩니다. 다음과 같은 서비스에 적합합니다. 즉시 재개되어야 하는 작업(예: 파일 다운로드)을 적극적으로 수행 중인 경우.

이러한 반환 값에 대한 자세한 내용은 링크된 참조를 확인하세요. 문서를 참조하세요.

서비스 시작

다음과 같이 액티비티나 다른 애플리케이션 구성 요소에서 서비스를 시작할 수 있습니다. Intent 전달 startService() 또는 startForegroundService()로 변경합니다. 이 Android 시스템에서 서비스의 onStartCommand() 메서드를 호출하여 Intent에 전달합니다. 시작할 서비스를 지정합니다

참고: 앱이 API 수준 26 이상을 타겟팅하는 경우 시스템은 백그라운드 서비스 사용 또는 생성에 제한을 두는 앱이 포그라운드에 있는 경우 발생합니다. 앱에서 포그라운드 서비스를 생성해야 하는 경우 앱은 startForegroundService()를 호출해야 합니다. 이 메서드는 백그라운드 서비스를 생성하지만 메서드는 서비스에 자체 승격할 것을 시스템에 포그라운드에서 실행되는 것으로 간주됩니다. 서비스가 생성되면 서비스는 startForeground() 메서드를 5초입니다.

예를 들어 활동은 아래와 같이 startService()가 포함된 명시적 인텐트를 사용하여 이전 섹션의 예시 서비스 (HelloService)를 시작할 수 있습니다.

Kotlin

startService(Intent(this, HelloService::class.java))

자바

startService(new Intent(this, HelloService.class));

startService() 메서드가 즉시 결과를 반환합니다. Android 시스템에서 서비스의 onStartCommand() 메서드를 호출합니다. 서비스가 아직 실행되고 있지 않으면 시스템은 먼저 onCreate()를 호출한 다음 이를 호출합니다. onStartCommand()

서비스가 바인딩도 제공하지 않는 경우 startService()와 함께 전달된 인텐트가 애플리케이션 구성요소와 서비스입니다 그러나 서비스가 결과를 돌려보내도록 하려면 서비스를 시작하는 클라이언트는 브로드캐스트의 PendingIntent를 만들 수 있습니다. (getBroadcast() 사용) 서비스에 전달 서비스를 시작하는 Intent에서 시작됩니다. 그러면 서비스는 결과를 제공합니다.

서비스를 시작하기 위해 여러 번 요청하면 서비스의 onStartCommand() 그러나 중지 요청은 한 번만 중지하려면 서비스 (stopSelf() 또는 stopService() 사용)가 필요합니다.

서비스 중지

시작된 서비스는 자신의 수명 주기를 직접 관리해야 합니다. 즉, 시스템은 중단되거나 시스템 메모리와 서비스를 복구해야 하는 경우가 아니면 서비스를 소멸시킬 수 있음 onStartCommand()가 반환된 후 계속 실행됩니다. 이 서비스는 stopSelf() 또는 다른 메서드를 호출하여 자체적으로 중지되어야 함 구성요소는 stopService()를 호출하여 정지할 수 있습니다.

stopSelf() 또는 stopService()로 중지를 요청하면 시스템은 즉시 서비스를 소멸시킵니다. 있습니다.

서비스가 onStartCommand()에 대한 여러 요청을 동시에 처리하는 경우 새 요청을 받았을 수 있으므로 시작 요청 처리가 완료되면 start 요청 (첫 번째 요청 끝에서 중지하면 두 번째 요청이 종료됨) 피해야 할 사항 stopSelf(int)를 사용하여 서비스는 항상 가장 최근 시작 요청을 기반으로 합니다. 즉, stopSelf(int)를 호출할 때 시작 요청의 ID (startId onStartCommand()(으)로 전송) 입니다. 그런 다음 stopSelf(int)를 호출할 수 있기 전에 서비스에서 새 시작 요청을 수신하면 ID가 일치하지 않으며 서비스는 중지되지 않습니다.

주의: 시스템 리소스 낭비를 피하고 배터리 전원을 완전히 공급하려면 애플리케이션이 작동하면 서비스가 중지되도록 해야 합니다. 필요한 경우 다른 구성요소는 stopService()를 호출하여 서비스를 중지할 수 있습니다. 서비스에 바인딩을 사용 설정하더라도 서비스가 onStartCommand() 호출을 받으면 항상 서비스를 직접 중지해야 합니다.

서비스의 수명 주기에 관한 자세한 내용은 아래의 서비스 수명 주기 관리 섹션을 참고하세요.

바인드된 서비스 생성

바인드된 서비스란 bindService()를 호출하여 애플리케이션 구성요소가 이 서비스에 바인드되어 오래 지속되는 연결을 만들 수 있게 해주는 서비스입니다. 일반적으로 구성요소가 startService()를 호출하여 이를 시작하는 것을 허용하지 않습니다.

활동에서 서비스와 상호작용하려는 경우 바인드된 서비스 생성 애플리케이션의 기능을 다른 구성요소에 노출하거나 애플리케이션의 다른 응용 프로그램에 연결할 수 있습니다.

바인드된 서비스를 생성하려면 onBind() 콜백 메서드를 구현하여 바인드된 IBinder를 반환합니다. 서비스와의 통신을 위한 인터페이스를 정의합니다. 그러면 다른 애플리케이션 구성 요소가 bindService(): 인터페이스 가져오기 서비스에서 메서드를 호출할 수 있습니다. 이 서비스는 현재 상태를 나타내는 애플리케이션 구성요소를 이 서비스에 바인딩된 구성 요소가 없으면 시스템이 이를 소멸시킵니다. 바인드된 서비스는 서비스가 중지될 때와 같은 방식으로 중지할 필요가 없습니다. onStartCommand()부터 시작되었습니다.

바인드된 서비스를 생성하려면 클라이언트가 아웃바운드를 사용할 수 있는 방법을 지정하는 서비스와 통신할 수 있습니다 서비스 간의 이 인터페이스는 클라이언트는 IBinder의 구현이어야 하며 이는 서비스에서 다음을 충족해야 합니다. onBind() 콜백 메서드에서 반환합니다. 클라이언트가 IBinder를 수신한 후 시작할 수 있습니다. 서비스와 상호작용하게 됩니다

여러 클라이언트가 서비스에 한꺼번에 바인딩될 수 있습니다. 클라이언트가 광고주와의 상호작용을 완료하면 unbindService()를 호출하여 바인딩을 해제합니다. 서비스에 바인딩된 클라이언트가 하나도 없으면 시스템이 해당 서비스를 소멸시킵니다.

바인드된 서비스를 구현하는 방법에는 여러 가지가 있으며, 구현은 더 복잡할 수 있습니다 이러한 이유로 바인드된 서비스 논의는 바인드된 서비스에 대한 별도 문서를 참조하세요.

사용자에게 알림 전송

서비스가 실행 중일 때 스낵바 알림 또는 상태 표시줄 알림을 사용하여 사용자에게 이벤트를 알릴 수 있습니다.

스낵바 알림은 다음 시간 동안만 현재 창의 표면에 표시되는 메시지입니다. 사라지기 직전의 순간입니다. 상태 표시줄 알림은 상태 표시줄에 아이콘이 메시지 (예: 액티비티 시작)를 사용자가 선택할 수 있습니다.

일반적으로 다음과 같은 백그라운드 작업 시 상태 표시줄 알림을 사용하는 것이 가장 좋은 기법입니다. 파일 다운로드가 완료되었으며 이제 사용자가 조치를 취할 수 있습니다. 사용자가 확장된 뷰에서 알림을 선택하면 알림이 액티비티를 시작할 수 있고, (예: 다운로드한 파일 표시)

서비스 수명 주기 관리

서비스의 수명 주기는 액티비티의 수명 주기보다 훨씬 간단합니다. 하지만 이보다 더 중요한 것은 서비스가 생성되고 소멸되는 방식에 주의를 기울여야 합니다 백그라운드에서 실행될 수 있습니다.

생성된 시점부터 소멸될 때까지의 서비스 수명 주기는 다음 두 경로 중 하나입니다.

시작된 서비스
다른 구성요소가 startService()를 호출하면 서비스가 생성됩니다. 그러면 서비스가 무기한으로 실행되며 stopSelf()를 호출하여 자체적으로 정지합니다. 또 다른 구성요소가 stopService()를 호출하여 서비스를 제공할 수 있습니다. 서비스가 중단되면 시스템이 이를 소멸시킵니다.
바인딩된 서비스
다른 구성요소 (클라이언트)가 bindService()를 호출하면 서비스가 생성됩니다. 그런 다음 클라이언트가 서비스와 통신합니다. IBinder 인터페이스를 통해 구현됩니다. 클라이언트는 다음을 호출하여 연결을 종료할 수 있습니다. unbindService() 여러 클라이언트가 모두 바인딩을 해제하면 시스템이 해당 서비스를 소멸시킵니다. 서비스 스스로 멈추지 않아도 됩니다.

이 두 경로는 완전히 별개는 아닙니다. 이미 사용 중인 서비스에 바인딩하거나 startService()(으)로 시작합니다. 예를 들어 재생할 음악을 식별하는 Intent로 startService()를 호출하여 백그라운드 음악 서비스를 시작합니다. 나중에 사용자가 플레이어를 일부 제어하거나 활동이 있다면 bindService()를 호출하여 서비스에 바인딩할 수 있습니다. 이와 같은 경우 stopService() 또는 stopSelf()는 모든 클라이언트가 바인딩 해제될 때까지 실제로 서비스를 중지하지 않습니다.

수명 주기 콜백 구현

활동과 마찬가지로 서비스에는 모니터링을 위해 구현할 수 있는 수명 주기 콜백 메서드가 있습니다. 적절한 시간에 작업을 수행할 수 있도록 하기 위한 것입니다. 다음 스켈레톤 서비스는 각 수명 주기 메서드를 보여줍니다.

Kotlin

class ExampleService : Service() {
    private var startMode: Int = 0             // indicates how to behave if the service is killed
    private var binder: IBinder? = null        // interface for clients that bind
    private var allowRebind: Boolean = false   // indicates whether onRebind should be used

    override fun onCreate() {
        // The service is being created
    }

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        // The service is starting, due to a call to startService()
        return startMode
    }

    override fun onBind(intent: Intent): IBinder? {
        // A client is binding to the service with bindService()
        return binder
    }

    override fun onUnbind(intent: Intent): Boolean {
        // All clients have unbound with unbindService()
        return allowRebind
    }

    override fun onRebind(intent: Intent) {
        // A client is binding to the service with bindService(),
        // after onUnbind() has already been called
    }

    override fun onDestroy() {
        // The service is no longer used and is being destroyed
    }
}

자바

public class ExampleService extends Service {
    int startMode;       // indicates how to behave if the service is killed
    IBinder binder;      // interface for clients that bind
    boolean allowRebind; // indicates whether onRebind should be used

    @Override
    public void onCreate() {
        // The service is being created
    }
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // The service is starting, due to a call to startService()
        return startMode;
    }
    @Override
    public IBinder onBind(Intent intent) {
        // A client is binding to the service with bindService()
        return binder;
    }
    @Override
    public boolean onUnbind(Intent intent) {
        // All clients have unbound with unbindService()
        return allowRebind;
    }
    @Override
    public void onRebind(Intent intent) {
        // A client is binding to the service with bindService(),
        // after onUnbind() has already been called
    }
    @Override
    public void onDestroy() {
        // The service is no longer used and is being destroyed
    }
}

참고: 활동 수명 주기 콜백 메서드와 달리 않아도 됩니다.

그림 2. 서비스 수명 주기. 왼쪽의 다이어그램 startService()로 서비스가 생성된 경우의 수명 주기를 보여주고, 오른쪽 다이어그램은 서비스 생성 시의 수명 주기를 보여줍니다. bindService().

그림 2는 서비스에 대한 일반적인 콜백 메서드를 나타낸 것입니다. 그림은 1과 0의 해당 서비스에서 startService()이(가) 만든 서비스 작성자: bindService(), 유지 서비스가 어떻게 시작되었든 상관없이 클라이언트가 잠재적으로 그것에 바인드할 수 있도록 할 수 있습니다. startService()를 호출하는 클라이언트에 의해 처음에 onStartCommand()로 시작된 서비스 onBind() 호출을 계속 수신할 수 있습니다 (클라이언트가 bindService()).

이러한 메서드를 구현하면 서비스의 두 중첩 루프를 모니터링할 수 있습니다. 수명 주기:

서비스의 전체 전체 기간은 onCreate()가 호출된 시점과 onDestroy()가 반환되는 시점 사이에 발생합니다. 활동처럼 서비스는 onCreate()하고 onDestroy()의 나머지 리소스를 모두 해제합니다. 예를 들어 음악 재생 서비스는 onCreate()에서 음악이 재생되는 스레드를 만든 다음 onDestroy()에서 스레드를 중지할 수 있습니다.
참고: onCreate() onDestroy() 메서드는 모든 서비스에 대해 호출됩니다. startService() 또는 bindService()에 의해 생성됩니다.
서비스의 활성 전체 기간은 onStartCommand() 또는 onBind() 호출로 시작합니다. 각 메서드에는 startService() 또는 bindService()에 전달된 Intent가 전달됩니다.
서비스가 시작되면 활성 전체 기간은 전체 기간과 동시에 종료됩니다. 서비스가 종료됩니다 (onStartCommand()가 반환된 후에도 서비스가 계속 활성 상태임). 서비스가 바인딩된 경우 onUnbind()가 반환되면 활성 전체 기간이 종료됩니다.

참고: 시작된 서비스는 stopSelf() 또는 stopService()이면 이 콜백에 관한 각 콜백은 (onStop() 콜백 없음) 서비스가 클라이언트에 바인드되지 않는 한 서비스가 중지되면 시스템에서 이를 소멸시킵니다. 수신된 콜백은 onDestroy()가 유일합니다.

바인딩을 제공하는 서비스 만들기에 대한 자세한 내용은 바인드된 서비스 문서, 여기에는 onRebind()에 관한 자세한 정보가 포함되어 있습니다. 수명 주기 관리 섹션에 대한 구현합니다