안드로이드 백그라운드 작업 효율화와 Doze 모드 최적화

# 현재 Doze 모드 상태 확인
adb shell dumpsys deviceidle | grep "mState"

  mState=IDLE

# Doze 모드 강제 진입 (기기 화면 끄고 일정 시간 대기 후 실행)
# 1. 기기 화면 끄기 (power button press)
# 2. 강제 Doze 모드 진입 명령
adb shell dumpsys deviceidle force-idle

# Doze 모드 해제
adb shell dumpsys deviceidle unforce

# Doze 모드 진입 후 유지보수 창 강제 실행 (테스트용)
adb shell dumpsys deviceidle step

# 특정 앱의 현재 대기 버킷 확인
adb shell am get-standby-bucket com.your.package.name

com.your.package.name: 30

# 앱을 Rare 버킷으로 강제 설정 (예: 40)
adb shell am set-standby-bucket com.your.package.name 40

# 앱을 Active 버킷으로 강제 설정 (예: 10)
adb shell am set-standby-bucket com.your.package.name 10

// build.gradle (app-level) 의존성 추가 (2026년 기준 최신 버전)
// AndroidX WorkManager 2.10.x 이상
dependencies {
    implementation "androidx.work:work-runtime-ktx:2.10.0"
}

// MyNetworkWorker.kt
package com.your.package.name

import android.content.Context
import androidx.work.CoroutineWorker
import androidx.work.WorkerParameters
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.withContext
import android.util.Log

class MyNetworkWorker(appContext: Context, workerParams: WorkerParameters) :
    CoroutineWorker(appContext, workerParams) {

    companion object {
        const val TAG = "MyNetworkWorker"
    }

    override suspend fun doWork(): Result {
        Log.d(TAG, "네트워크 작업 시작: ${System.currentTimeMillis()}")
        return withContext(Dispatchers.IO) {
            try {
                // 실제 네트워크 요청 로직 구현
                // 예: Retrofit, Ktor 등을 사용하여 API 호출
                Log.d(TAG, "원격 서버에 데이터 전송 중...")
                delay(5000) // 5초 대기 (네트워크 작업 시뮬레이션)
                val response = "{\"status\": \"success\", \"data\": \"업로드 완료\"}"
                Log.d(TAG, "네트워크 작업 완료: $response")
                Result.success() // 작업 성공
            } catch (e: Exception) {
                Log.e(TAG, "네트워크 작업 실패: ${e.message}", e)
                // 재시도 정책에 따라 Result.retry() 또는 Result.failure() 반환
                Result.retry() // 잠시 후 재시도
            }
        }
    }
}

// MainActivity.kt 또는 Application 클래스
package com.your.package.name

import android.os.Bundle
import android.util.Log
import androidx.appcompat.app.AppCompatActivity
import androidx.work.Constraints
import androidx.work.NetworkType
import androidx.work.OneTimeWorkRequest
import androidx.work.WorkManager
import java.util.concurrent.TimeUnit

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // 1. 제약 조건 정의
        val constraints = Constraints.Builder()
            .setRequiredNetworkType(NetworkType.CONNECTED) // 네트워크 연결 필수
            .setRequiresBatteryNotLow(true) // 배터리 부족 시 실행 안 함
            .build()

        // 2. 일회성 작업 요청 생성
        val networkWorkRequest = OneTimeWorkRequest.Builder(MyNetworkWorker::class.java)
            .setConstraints(constraints) // 위에서 정의한 제약 조건 적용
            .setInitialDelay(10, TimeUnit.SECONDS) // 10초 후 최소 시작
            .addTag(MyNetworkWorker.TAG) // 작업 태그 지정 (관리 용이)
            .setBackoffCriteria(
                androidx.work.BackoffPolicy.EXPONENTIAL, // 지수 백오프 정책
                OneTimeWorkRequest.DEFAULT_BACKOFF_DELAY_MILLIS,
                TimeUnit.MILLISECONDS
            )
            .build()

        // 3. WorkManager에 작업 스케줄링
        WorkManager.getInstance(applicationContext).enqueue(networkWorkRequest)
        Log.d("MainActivity", "네트워크 작업 스케줄링 완료.")

        // 작업 상태 관찰 (옵션)
        WorkManager.getInstance(applicationContext).getWorkInfoByIdLiveData(networkWorkRequest.id)
            .observe(this) { workInfo ->
                if (workInfo != null) {
                    Log.d("MainActivity", "작업 상태: ${workInfo.state}")
                    if (workInfo.state.isFinished) {
                        Log.d("MainActivity", "작업 결과: ${workInfo.outputData.getString("result")}")
                    }
                }
            }
    }
}

// MyJobService.kt
package com.your.package.name

import android.app.job.JobParameters
import android.app.job.JobService
import android.util.Log
import kotlinx.coroutines.*

class MyJobService : JobService() {

    private val jobScope = CoroutineScope(Dispatchers.IO + SupervisorJob())

    companion object {
        const val TAG = "MyJobService"
        const val JOB_ID = 1001 // 고유한 Job ID
    }

    override fun onStartJob(params: JobParameters?): Boolean {
        Log.d(TAG, "Job ${params?.jobId} 시작. 제약 조건: ${params?.extras}")

        // 백그라운드 작업을 코루틴으로 실행
        jobScope.launch {
            try {
                Log.d(TAG, "오래 걸리는 작업 수행 중...")
                delay(7000) // 7초 대기 (작업 시뮬레이션)
                Log.d(TAG, "작업 완료!")
                jobFinished(params, false) // 작업 완료, 재시도 필요 없음
            } catch (e: Exception) {
                Log.e(TAG, "작업 실패: ${e.message}", e)
                jobFinished(params, true) // 작업 실패, 재시도 필요함
            }
        }

        return true // 작업이 백그라운드 스레드에서 계속 실행될 것임을 시스템에 알림
    }

    override fun onStopJob(params: JobParameters?): Boolean {
        Log.d(TAG, "Job ${params?.jobId} 중단됨. 재시도 여부: ${params?.jobId}")
        jobScope.cancel() // 코루틴 취소
        return true // 작업 재시도 여부 (true: 재시도, false: 재시도 안 함)
    }
}

<!-- AndroidManifest.xml -->
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.your.package.name">

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

    <application
        ...>
        <service
            android:name=".MyJobService"
            android:permission="android.permission.BIND_JOB_SERVICE"
            android:exported="true"/>
    </application>
</manifest>

// MainActivity.kt 또는 Application 클래스
package com.your.package.name

import android.app.job.JobInfo
import android.app.job.JobScheduler
import android.content.ComponentName
import android.os.Bundle
import android.util.Log
import androidx.appcompat.app.AppCompatActivity
import java.util.concurrent.TimeUnit

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // JobScheduler 인스턴스 가져오기
        val jobScheduler = getSystemService(JOB_SCHEDULER_SERVICE) as JobScheduler

        // JobInfo 빌더를 사용하여 작업 정의
        val jobInfo = JobInfo.Builder(MyJobService.JOB_ID, ComponentName(this, MyJobService::class.java))
            .setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY) // 아무 네트워크 연결 시 실행
            .setPersisted(true) // 기기 재부팅 후에도 작업 유지
            .setRequiresCharging(false) // 충전 중이 아닐 때도 실행 가능
            .setMinimumLatency(TimeUnit.SECONDS.toMillis(5)) // 최소 5초 후에 실행
            // .setPeriodic(TimeUnit.HOURS.toMillis(1), TimeUnit.MINUTES.toMillis(15)) // 주기적 작업 (1시간마다, 유연성 15분)
            .build()

        // 작업 스케줄링
        val resultCode = jobScheduler.schedule(jobInfo)
        if (resultCode == JobScheduler.RESULT_SUCCESS) {
            Log.d("MainActivity", "JobScheduler 작업 스케줄링 성공.")
        } else {
            Log.e("MainActivity", "JobScheduler 작업 스케줄링 실패.")
        }

        // 특정 작업 취소
        // jobScheduler.cancel(MyJobService.JOB_ID)
        // 모든 작업 취소
        // jobScheduler.cancelAll()
    }
}