Какие знаешь типы Service?

Типы Service в Android: полный обзор

Service — это компонент Android для выполнения долгоживущих операций в фоне. Понимание разных типов Service критически важно для правильной архитектуры приложения.

StartedService (Запущенный Service)

Определение: Service, который запускается явно и работает независимо от вызывающего компонента.

// Запуск Service
val intent = Intent(this, MyService::class.java)
startService(intent)

// Service отдельно от запустившего его Activity
class MyService : Service() {
    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        // Выполняем фоновую работу
        Thread {
            performLongRunningTask()
        }.start()
        
        // Service продолжит работать даже после закрытия Activity
        return START_STICKY  // Перезапустится при убийстве
    }
    
    override fun onBind(intent: Intent?): IBinder? = null
}

Характеристики:

• Работает в главном потоке (UI thread)
• Не имеет автоматической связи с вызывающим компонентом
• Может работать после закрытия Activity
• Обработка событий идёт в onStartCommand()

Когда использовать:

• Загрузка файлов
• Синхронизация данных с сервером
• Музыка в фоне
• Длительные операции, которые не нужно останавливать

Foreground Service

Определение: Service, который работает "в переднем плане" и показывает уведомление пользователю.

class MusicService : Service() {
    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        // Создаём уведомление
        val notification = NotificationCompat.Builder(this, CHANNEL_ID)
            .setContentTitle("Музыка играет")
            .setContentText("Нажми для паузы")
            .setSmallIcon(R.drawable.ic_music)
            .build()
        
        // Запускаем как foreground service
        startForeground(NOTIFICATION_ID, notification)
        
        // Начинаем воспроизведение
        startPlayingMusic()
        
        return START_STICKY
    }
}

Характеристики:

• Показывает постоянное уведомление
• Сложнее системе убить такой Service
• Требует Notification
• На Android 12+ требует FOREGROUND_SERVICE permission

Когда использовать:

• Музыкальные плеры
• Навигация в реальном времени
• Прямые трансляции
• Видеозвонки

Bound Service (Привязанный Service)

Определение: Service, с которым компонент может связаться через Binder и обмениваться данными.

class MathService : Service() {
    private val binder = LocalBinder()
    
    inner class LocalBinder : Binder() {
        fun getService(): MathService = this@MathService
    }
    
    fun add(a: Int, b: Int): Int = a + b
    
    override fun onBind(intent: Intent?): IBinder = binder
}

// В Activity
class MainActivity : AppCompatActivity() {
    private var mathService: MathService? = null
    private var bound = false
    
    private val connection = object : ServiceConnection {
        override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
            val binder = service as MathService.LocalBinder
            mathService = binder.getService()
            bound = true
        }
        
        override fun onServiceDisconnected(name: ComponentName?) {
            bound = false
        }
    }
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        // Привязываемся к Service
        val intent = Intent(this, MathService::class.java)
        bindService(intent, connection, Context.BIND_AUTO_CREATE)
    }
    
    fun calculateSum() {
        if (bound) {
            val result = mathService?.add(5, 3)  // Прямой вызов метода
            println("Result: $result")
        }
    }
    
    override fun onDestroy() {
        super.onDestroy()
        if (bound) {
            unbindService(connection)
        }
    }
}

Характеристики:

• Двусторонняя коммуникация через Binder
• Service существует пока есть привязки
• Работает в главном потоке
• Не требует уведомления

Когда использовать:

• Музыкальный плеер с контролем из Activity
• Синхронизация данных между компонентами
• Отправка запросов к Service и получение результатов

Intent Service (Deprecated)

Определение: Специальный Service для выполнения однократных операций в отдельном потоке.

// Старый способ (не использовать в новых проектах)
class DownloadService : IntentService("download") {
    override fun onHandleIntent(intent: Intent?) {
        // Выполняется в отдельном потоке
        downloadFile()
    }
}

Почему deprecated:

• Заменён на WorkManager
• Плохо поддерживает современные Android API
• Ограниченная гибкость

IntentService vs JobService vs WorkManager

Современный подход — использовать WorkManager:

class DownloadWorker(context: Context, params: WorkerParameters) : Worker(context, params) {
    override fun doWork(): Result {
        return try {
            downloadFile()
            Result.success()
        } catch (e: Exception) {
            Result.retry()  // Переполнить
        }
    }
}

// Запуск
val downloadWork = OneTimeWorkRequestBuilder<DownloadWorker>()
    .build()
WorkManager.getInstance(context).enqueueUniqueWork(
    "download",
    ExistingWorkPolicy.KEEP,
    downloadWork
)

JobService

Для планируемых задач:

class MyJobService : JobService() {
    override fun onStartJob(params: JobParameters?): Boolean {
        Thread {
            performWork()
            jobFinished(params, false)  // Задача завершена
        }.start()
        return true  // Work in progress
    }
    
    override fun onStopJob(params: JobParameters?): Boolean {
        return true  // Переполнить при перебое
    }
}

Практическое сравнение

Важные замечания

Никогда не выполняй тяжёлую работу в главном потоке:

// Правильно
override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
    Thread {
        // Тяжёлая работа в отдельном потоке
        performNetworkCall()
        stopSelf(startId)  // Сам себя останавливаем
    }.start()
    return START_NOT_STICKY
}

// Или с Kotlin Coroutines
override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
    lifecycleScope.launch(Dispatchers.IO) {
        performNetworkCall()
        stopSelf(startId)
    }
    return START_NOT_STICKY
}

Выводы

1. Started Service — для фоновой работы независимо от UI
2. Foreground Service — когда нужно уведомление
3. Bound Service — для двусторонней коммуникации
4. WorkManager — для периодических и надёжных задач
5. IntentService — забыть, это прошлое
6. Всегда выполняй тяжёлую работу в отдельных потоках