안드로이드 앱 배터리 소모 최적화 전략 🔋💡

// 배치 처리 예시
List<Data> dataToSend = new ArrayList<>();
// 데이터 수집
for (int i = 0; i < 100; i++) {
    dataToSend.add(new Data());
}
// 한 번에 전송
sendDataInBatch(dataToSend);

// 프리페칭 예시
void onUserEnterSection(String sectionId) {
    // 현재 섹션의 데이터 로드
    loadSectionData(sectionId);
    // 다음 섹션의 데이터 미리 로드
    String nextSectionId = getNextSectionId(sectionId);
    prefetchSectionData(nextSectionId);
}

// Room을 사용한 캐싱 예시
@Dao
interface UserDao {
    @Query("SELECT * FROM user WHERE id = :userId")
    fun getUser(userId: String): User

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    fun insertUser(user: User)
}

// 데이터 조회 시
fun getUser(userId: String) {
    val cachedUser = userDao.getUser(userId)
    if (cachedUser != null) {
        // 캐시된 데이터 사용
        return cachedUser
    } else {
        // 네트워크에서 데이터 가져오기
        val user = api.getUser(userId)
        // 캐시에 저장
        userDao.insertUser(user)
        return user
    }
}

// Glide를 사용한 이미지 로딩 예시
Glide.with(context)
    .load(imageUrl)
    .diskCacheStrategy(DiskCacheStrategy.ALL)
    .placeholder(R.drawable.placeholder)
    .error(R.drawable.error)
    .into(imageView);

fun isWifiConnected(context: Context): Boolean {
    val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    val network = connectivityManager.activeNetwork ?: return false
    val capabilities = connectivityManager.getNetworkCapabilities(network) ?: return false
    return capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
}

// 사용 예
if (isWifiConnected(context)) {
    // Wi-Fi 연결 시 대용량 데이터 다운로드
    downloadLargeData()
} else {
    // 모바일 데이터 연결 시 경고 메시지 표시
    showDataUsageWarning()
}

// 위치 요청 설정
LocationRequest locationRequest = LocationRequest.create();
if (needHighAccuracy) {
    locationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);
} else {
    locationRequest.setPriority(LocationRequest.PRIORITY_BALANCED_POWER_ACCURACY);
}

LocationRequest locationRequest = LocationRequest.create()
    .setInterval(10000)  // 10초마다 업데이트
    .setFastestInterval(5000)  // 가장 빠른 업데이트 간격
    .setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);

Geofence geofence = new Geofence.Builder()
    .setRequestId("myGeofence")
    .setCircularRegion(latitude, longitude, radius)
    .setExpirationDuration(Geofence.NEVER_EXPIRE)
    .setTransitionTypes(Geofence.GEOFENCE_TRANSITION_ENTER | Geofence.GEOFENCE_TRANSITION_EXIT)
    .build();

IntentFilter ifilter = new IntentFilter(Intent.ACTION_BATTERY_CHANGED);
Intent batteryStatus = context.registerReceiver(null, ifilter);

int level = batteryStatus.getIntExtra(BatteryManager.EXTRA_LEVEL, -1);
int scale = batteryStatus.getIntExtra(BatteryManager.EXTRA_SCALE, -1);

float batteryPct = level / (float)scale;

if (batteryPct < 0.15) {  // 배터리가 15% 미만일 때
    // 위치 업데이트 빈도 줄이기
    locationRequest.setInterval(30000);  // 30초로 늘리기
}

ActivityRecognitionClient client = ActivityRecognition.getClient(context);
Task<Void> task = client.requestActivityUpdates(
        30 * 1000,  // 30초마다 업데이트
        getPendingIntent()
);

task.addOnSuccessListener(new OnSuccessListener<Void>() {
    @Override
    public void onSuccess(Void result) {
        // 활동 업데이트 요청 성공
    }
});

private Location lastKnownLocation;

private void updateLastKnownLocation(Location location) {
    lastKnownLocation = location;
    // SharedPreferences나 로컬 데이터베이스에 저장
    saveLocationToPreferences(location);
}

private Location getLastKnownLocation() {
    if (lastKnownLocation == null) {
        // SharedPreferences나 로컬 데이터베이스에서 로드
        lastKnownLocation = loadLocationFromPreferences();
    }
    return lastKnownLocation;
}

// styles.xml
<style name="AppTheme" parent="Theme.AppCompat.DayNight">
    <!-- 테마 속성 설정 -->
</style>

// 코드에서 다크 모드 감지
int nightModeFlags = getResources().getConfiguration().uiMode & Configuration.UI_MODE_NIGHT_MASK;
if (nightModeFlags == Configuration.UI_MODE_NIGHT_YES) {
    // 다크 모드일 때의 처리
} else {
    // 라이트 모드일 때의 처리
}

<androidx.constraintlayout.widget.ConstraintLayout
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextView
        android:id="@+id/textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        app:layout_constraintTop_toTopOf  ="parent"
        app:layout_constraintStart_toStartOf="parent"
        android:text="Hello World!" />

    <Button
        android:id="@+id/button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        app:layout_constraintTop_toBottomOf="@id/textView"
        app:layout_constraintStart_toStartOf="parent"
        android:text="Click me" />

</androidx.constraintlayout.widget.ConstraintLayout>

// XML에서 하드웨어 가속 설정
android:hardwareAccelerated="true"

// 코드에서 하드웨어 가속 설정
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
    this.getWindow().setFlags(
        WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED,
        WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED);
}

// 애니메이션 예시
ObjectAnimator animator = ObjectAnimator.ofFloat(view, "translationX", 100f);
animator.setDuration(1000);
animator.start();

// Glide를 사용한 이미지 로딩 및 캐싱
Glide.with(this)
    .load(imageUrl)
    .diskCacheStrategy(DiskCacheStrategy.ALL)
    .override(300, 200) // 이미지 크기 조정
    .into(imageView);

public class MyAdapter extends RecyclerView.Adapter<MyAdapter.ViewHolder> {
    // ViewHolder 구현
    public static class ViewHolder extends RecyclerView.ViewHolder {
        public TextView textView;
        public ViewHolder(View v) {
            super(v);
            textView = v.findViewById(R.id.text_view);
        }
    }

    @Override
    public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        View v = LayoutInflater.from(parent.getContext())
                               .inflate(R.layout.my_text_view, parent, false);
        return new ViewHolder(v);
    }

    @Override
    public void onBindViewHolder(ViewHolder holder, int position) {
        holder.textView.setText(mDataset[position]);
    }
}

// XML에서 GPU 렌더링 설정
android:layerType="hardware"

// 코드에서 GPU 렌더링 설정
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
    view.setLayerType(View.LAYER_TYPE_HARDWARE, null);
}

// WorkManager를 사용한 백그라운드 작업 예시
val constraints = Constraints.Builder()
    .setRequiredNetworkType(NetworkType.UNMETERED)
    .setRequiresBatteryNotLow(true)
    .build()

val workRequest = OneTimeWorkRequestBuilder<MyWorker>()
    .setConstraints(constraints)
    .build()

WorkManager.getInstance(context).enqueue(workRequest)

// MyWorker 클래스
class MyWorker(context: Context, params: WorkerParameters) : Worker(context, params) {
    override fun doWork(): Result {
        // 백그라운드 작업 수행
        return Result.success()
    }
}

// 배치 처리 예시
val database = Room.databaseBuilder(context, AppDatabase::class.java, "database-name").build()

database.runInTransaction {
    // 여러 데이터베이스 연산을 한 번의 트랜잭션으로 처리
    database.userDao().insertAll(users)
    database.postDao().insertAll(posts)
    database.commentDao().insertAll(comments)
}

// Foreground Service 예시
class MyForegroundService : Service() {
    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        val notification = NotificationCompat.Builder(this, CHANNEL_ID)
            .setContentTitle("Foreground Service")
            .setContentText("Running...")
            .setSmallIcon(R.drawable.icon)
            .build()

        startForeground(NOTIFICATION_ID, notification)

        // 장기 실행 작업 수행

        return START_NOT_STICKY
    }

    // 기타 필요한 메서드 구현
}

// JobScheduler 사용 예시
val componentName = ComponentName(context, MyJobService::class.java)
val jobInfo = JobInfo.Builder(JOB_ID, componentName)
    .setRequiresCharging(true)
    .setRequiredNetworkType(JobInfo.NETWORK_TYPE_UNMETERED)
    .setPeriodic(15 * 60 * 1000)  // 15분마다 실행
    .build()

val scheduler = context.getSystemService(Context.JOB_SCHEDULER_SERVICE) as JobScheduler
scheduler.schedule(jobInfo)

// Wake Lock 사용 예시
val wakeLock: PowerManager.WakeLock = (getSystemService(Context.POWER_SERVICE) as PowerManager).run {
    newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "MyApp::MyWakelockTag").apply {
        acquire()
    }
}

try {
    // 중요한 작업 수행
} finally {
    wakeLock.release()
}

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)

// 센서 리스너 등록
sensorManager.registerListener(this, accelerometer, SensorManager.SENSOR_DELAY_NORMAL)

// 사용 완료 후 반드시 리스너 해제
sensorManager.unregisterListener(this)

// 샘플링 레이트 설정 예시
sensorManager.registerListener(this, accelerometer, SensorManager.SENSOR_DELAY_NORMAL)
// 또는
sensorManager.registerListener(this, accelerometer, 1000000) // 마이크로초 단위

class SensorBatchProcessor : SensorEventListener {
    private val sensorData = mutableListOf<SensorEvent>()
    private val BATCH_SIZE = 50

    override fun onSensorChanged(event: SensorEvent) {
        sensorData.add(event)
        if (sensorData.size >= BATCH_SIZE) {
            processBatch()
        }
    }

    private fun processBatch() {
        // 배치 데이터 처리 로직
        sensorData.clear()
    }

    // 기타 필요한 메서드 구현
}

class AdaptiveSensorManager(private val context: Context) {
    private val sensorManager = context.getSystemService(Context.SENSOR_SERVICE) as SensorManager
    private val accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)

    fun adjustSensorUsage(isMoving: Boolean) {
        if (isMoving) {
            sensorManager.registerListener(this, accelerometer, SensorManager.SENSOR_DELAY_NORMAL)
        } else {
            sensorManager.registerListener(this, accelerometer, SensorManager.SENSOR_DELAY_UI)
        }
    }

    // 기타 필요한 메서드 구현
}

class SensorDataCache {
    private var lastAccelerometerData: FloatArray? = null
    private var lastUpdateTime: Long = 0
    private val CACHE_DURATION = 5000 // 5초

    fun getAccelerometerData(sensorManager: SensorManager): FloatArray? {
        val currentTime = System.currentTimeMillis()
        if (lastAccelerometerData == null || currentTime - lastUpdateTime > CACHE_DURATION) {
            val accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
            // 센서에서 새로운 데이터 읽기
            // lastAccelerometerData 및 lastUpdateTime 업데이트
        }
        return lastAccelerometerData
    }
}

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val stepCounter = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER)

sensorManager.registerListener(this, stepCounter, SensorManager.SENSOR_DELAY_NORMAL)

class NetworkBatchProcessor {
    private val requests = mutableListOf<NetworkRequest>()
    private val BATCH_SIZE = 10

    fun addRequest(request: NetworkRequest) {
        requests.add(request)
        if (requests.size >= BATCH_SIZE) {
            processBatch()
        }
    }

    private fun processBatch() {
        // 배치 요청 처리 로직
        sendBatchRequest(requests)
        requests.clear()
    }

    // 기타 필요한 메서드 구현
}

// OkHttp를 사용한 gzip 압축 예시
val client = OkHttpClient.Builder()
    .addInterceptor { chain ->
        val originalRequest = chain.request()
        val compressedRequest = originalRequest.newBuilder()
            .header("Accept-Encoding", "gzip")
            .build()
        chain.proceed(compressedRequest)
    }
    .build()

// Retrofit과 O  kHttp를 사용한 캐싱 예시
val cacheSize = 10 * 1024 * 1024 // 10 MB
val cache = Cache(context.cacheDir, cacheSize.toLong())

val client = OkHttpClient.Builder()
    .cache(cache)
    .addInterceptor { chain ->
        var request = chain.request()
        request = if (hasNetwork(context))
            request.newBuilder().header("Cache-Control", "public, max-age=" + 5).build()
        else
            request.newBuilder().header("Cache-Control", "public, only-if-cached, max-stale=" + 60 * 60 * 24 * 7).build()
        chain.proceed(request)
    }
    .build()

val retrofit = Retrofit.Builder()
    .baseUrl("https://api.example.com/")
    .client(client)
    .build()

class AdaptivePoller(private val initialInterval: Long = 1000) {
    private var currentInterval = initialInterval
    private var lastPollTime = 0L

    fun shouldPoll(): Boolean {
        val now = System.currentTimeMillis()
        if (now - lastPollTime >= currentInterval) {
            lastPollTime = now
            return true
        }
        return false
    }

    fun adjustInterval(dataChanged: Boolean) {
        if (dataChanged) {
            currentInterval = (currentInterval * 0.8).toLong().coerceAtLeast(initialInterval)
        } else {
            currentInterval = (currentInterval * 1.2).toLong().coerceAtMost(initialInterval * 10)
        }
    }
}

// Glide를 사용한 이미지 로딩 및 리사이징 예시
Glide.with(context)
    .load(imageUrl)
    .override(300, 200) // 이미지 크기 조정
    .format(DecodeFormat.PREFER_RGB_565) // 메모리 사용량 감소
    .diskCacheStrategy(DiskCacheStrategy.ALL)
    .into(imageView)

fun isWifiConnected(context: Context): Boolean {
    val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    val network = connectivityManager.activeNetwork ?: return false
    val capabilities = connectivityManager.getNetworkCapabilities(network) ?: return false
    return capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
}

// 사용 예
if (isWifiConnected(context)) {
    downloadLargeData()
} else {
    showDataUsageWarning()
}

// WorkManager를 사용한 주기적 동기화 예시
val syncWorkRequest = PeriodicWorkRequestBuilder<SyncWorker>(1, TimeUnit.HOURS)
    .setConstraints(Constraints.Builder()
        .setRequiredNetworkType(NetworkType.CONNECTED)
        .setRequiresBatteryNotLow(true)
        .build())
    .build()

WorkManager.getInstance(context).enqueueUniquePeriodicWork(
    "dataSyncWork",
    ExistingPeriodicWorkPolicy.KEEP,
    syncWorkRequest
)

class MyActivity : AppCompatActivity() {
    private lateinit var handler: Handler
    private lateinit var runnable: Runnable

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

        handler = Handler(Looper.getMainLooper())
        runnable = Runnable { /* 작업 수행 */ }
    }

    override fun onResume() {
        super.onResume()
        handler.postDelayed(runnable, 1000)
    }

    override fun onPause() {
        super.onPause()
        handler.removeCallbacks(runnable) // 메모리 누수 방지
    }
}

class ObjectPool<T>(private val factory: () -> T) {
    private val pool = mutableListOf<T>()

    fun acquire(): T {
        if (pool.isEmpty()) {
            return factory()
        }
        return pool.removeAt(pool.size - 1)
    }

    fun release(obj: T) {
        pool.add(obj)
    }
}

// 사용 예
val rectanglePool = ObjectPool { Rectangle() }

val rectangle = rectanglePool.acquire()
// 사용 후
rectanglePool.release(rectangle)

fun decodeSampledBitmapFromResource(res: Resources, resId: Int, reqWidth: Int, reqHeight: Int): Bitmap {
    // 이미지 크기 확인
    val options = BitmapFactory.Options().apply { inJustDecodeBounds = true }
    BitmapFactory.decodeResource(res, resId, options)

    // 샘플 크기 계산
    options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight)

    // 비트맵 디코드
    options.inJustDecodeBounds = false
    return BitmapFactory.decodeResource(res, resId, options)
}

fun calculateInSampleSize(options: BitmapFactory.Options, reqWidth: Int, reqHeight: Int): Int {
    val (height: Int, width: Int) = options.run { outHeight to outWidth }
    var inSampleSize = 1

    if (height > reqHeight || width > reqWidth) {
        val halfHeight: Int = height / 2
        val halfWidth: Int = width / 2

        while (halfHeight / inSampleSize >= reqHeight && halfWidth / inSampleSize >= reqWidth) {
            inSampleSize *= 2
        }
    }

    return inSampleSize
}

class MyAsyncTask(activity: Activity) : AsyncTask<Void, Void, String>() {
    private val activityReference: WeakReference<Activity> = WeakReference(activity)

    override fun doInBackground(vararg params: Void): String {
        // 백그라운드 작업 수행
        return "Result"
    }

    override fun onPostExecute(result: String) {
        val activity = activityReference.get()
        if (activity == null || activity.isFinishing) return
        // 결과 처리
    }
}

class MemoryCache<K, V>(private val maxSize: Int) {
    private val cache = LinkedHashMap<K, V>(0, 0.75f, true)

    @Synchronized
    fun put(key: K, value: V) {
        if (cache.size >= maxSize) {
            val eldest = cache.entries.iterator().next()
            cache.remove(eldest.key)
        }
        cache[key] = value
    }

    @Synchronized
    fun get(key: K): V? = cache[key]

    @Synchronized
    fun remove(key: K) = cache.remove(key)

    @Synchronized
    fun clear() = cache.clear()
}

class MyClass {
    private val heavyObject: HeavyObject by lazy {
        HeavyObject()
    }

    fun doSomething() {
        // heavyObject는 이 메서드가 처음 호출될 때 초기화됩니다.
        heavyObject.performTask()
    }
}

val jobScheduler = getSystemService(Context.JOB_SCHEDULER_SERVICE) as JobScheduler

val jobInfo = JobInfo.Builder(JOB_ID, ComponentName(this, MyJobService::class.java))
    .setRequiresCharging(true)
    .setRequiredNetworkType(JobInfo.NETWORK_TYPE_UNMETERED)
    .setPeriodic(15 * 60 * 1000)  // 15분마다 실행
    .build()

jobScheduler.schedule(jobInfo)

// Doze 모드에서도 실행되어야 하는 중요한 작업의 경우
val alarmManager = getSystemService(Context.ALARM_SERVICE) as AlarmManager
val intent = Intent(this, MyBroadcastReceiver::class.java)
val pendingIntent = PendingIntent.getBroadcast(this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT)

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
    alarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, triggerAtMillis, pendingIntent)
} else {
    alarmManager.setExact(AlarmManager.RTC_WAKEUP, triggerAtMillis, pendingIntent)
}

class BatteryReceiver : BroadcastReceiver() {
    override fun onReceive(context: Context, intent: Intent) {
        val level = intent.getIntExtra(BatteryManager.EXTRA_LEVEL, -1)
        val scale = intent.getIntExtra(BatteryManager.EXTRA_SCALE, -1)
        val batteryPct = level * 100 / scale.toFloat()

        if (batteryPct < 15) {
            // 배터리가 15% 미만일 때의 처리
            reduceBatteryConsumption()
        }
    }
}

// 사용 예
val filter = IntentFilter(Intent.ACTION_BATTERY_CHANGED)
registerReceiver(BatteryReceiver(), filter)

val powerManager = getSystemService(Context.POWER_SERVICE) as PowerManager
val wakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "MyApp::MyWakelockTag")

try {
    wakeLock.acquire(10*60*1000L /*10 minutes*/)
    // 중요한 작업 수행
} finally {
    wakeLock.release()
}

val constraints = Constraints.Builder()
    .setRequiredNetworkType(NetworkType.UNMETERED)
    .setRequiresBatteryNotLow(true)
    .setRequiresCharging(true)
    .build()

val workRequest = PeriodicWorkRequestBuilder<MyWorker>(1, TimeUnit.HOURS)
    .setConstraints(constraints)
    .build()

WorkManager.getInstance(context).enqueueUniquePeriodicWork(
    "myWork",
    ExistingPeriodicWorkPolicy.KEEP,
    workRequest
)

// 비효율적인 방법
for (int i = 0; i < 1000; i++) {
    String s = "Hello, World!";
    // s 사용
}

// 효율적인 방법
String s = "Hello, World!";
for (int i = 0; i < 1000; i++) {
    // s 사용
}

// 비효율적인 방법
for (int i = 0; i < list.size(); i++) {
    // list.size()가 매 반복마다 호출됨
}

// 효율적인 방법
int size = list.size();
for (int i = 0; i < size; i++) {
    // size는 한 번만 계산됨
}

// 비효율적인 방법
String result = "";
for (int i = 0; i < 1000; i++) {
    result += "a";
}

// 효율적인 방법
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append("a");
}
String result = sb.toString();

import androidx.annotation.IntDef

class MyClass {
    @IntDef({APPLE, BANANA, ORANGE})
    @Retention(RetentionPolicy.SOURCE)
    annotation class Fruit

    companion object {
        const val APPLE = 0
        const val BANANA = 1
        const val ORANGE = 2
    }

    @Fruit
    var currentFruit: Int = APPLE
}

class MyClass {
    val heavyObject: HeavyObject by lazy {
        HeavyObject()
    }
}

class MyClass {
    companion object {
        const val MAX_COUNT = 100
    }
}

// 비효율적인 방법
Integer sum = 0;
for (int i = 0; i < 1000; i++) {
    sum += i;  // 매 반복마다 박싱/언박싱 발생
}

// 효율적인 방법
int sum = 0;
for (int i = 0; i < 1000; i++) {
    sum += i;
}

inline fun doSomething(action: () -> Unit) {
    // 함수 내용
    action()
}

lifecycleScope.launch {
    val result = withContext(Dispatchers.IO) {
        // 백그라운드 작업 수행
    }
    // UI 업데이트
}