Batarya Optimizasyonu

Mobil cihazlarda batarya ömrü kritik bir faktördür. Bu bölümde, uygulamanızın batarya tüketimini minimize etmek için kullanabileceğiniz teknik ve stratejiler ele alınacaktır.

Hızlı Karar

Durum	Yaklaşım	Dikkat
Sık ağ çağrısı	Batch ve cache	Veri tazeliği etkilenir
Sürekli arka plan iş	Platform scheduler	OS kısıtlarını aşmaya çalışma
Yoğun CPU işi	Debounce/throttle/isolate	Termal etki ölçülmeli
Konum takibi	Düşük hassasiyet veya geofence	İzin ve batarya maliyeti yüksek

Üretim Kontrol Listesi

• Problem: Hangi özellik batarya tüketimini artırıyor?
• Çözüm: İş sıklığı, ağ batch'i, arka plan sınırı ve fallback davranışı net mi?
• Trade-off: Daha az tüketim genelde daha düşük tazelik veya daha az gerçek zamanlılık demektir.
• Hata durumu: Wake lock leak, runaway retry, background kill ve thermal throttling ele alınmalı.
• Ölçüm: Battery drain, wakeup count, network bytes, CPU time ve background execution time izlenmeli.
• Güvenlik/maliyet: Kullanıcı izni ve şeffaflık korunmalı; fazla arka plan işi retention'ı düşürür.

Temel İlkeler

1. CPU Kullanımını Minimize Etme

• Algoritma Optimizasyonu: Verimli algoritmalar kullanın
• Gereksiz İşlemleri Engelleme: Arka plan işlemlerini sınırlayın
• Cache Kullanımı: Hesaplamaları cache'leyerek tekrarları önleyin

2. Ağ İşlemlerini Optimize Etme

• Batch Requests: Birden fazla isteği birleştirin
• Compression: Veri sıkıştırma kullanın
• Connection Pooling: Bağlantıları yeniden kullanın

Platform-Spesifik Optimizasyonlar

iOS

Background App Refresh

// iOS'ta arka plan yenileme kontrolü
if UIApplication.shared.backgroundRefreshStatus == .available {
    // Arka plan işlemlerini optimize et
    DispatchQueue.global(qos: .background).async {
        // Düşük öncelikli işlemler
    }
}

Power Management

import Foundation

class BatteryManager {
    func getCurrentBatteryLevel() -> Float {
        UIDevice.current.isBatteryMonitoringEnabled = true
        return UIDevice.current.batteryLevel
    }
    
    func getBatteryState() -> UIDevice.BatteryState {
        return UIDevice.current.batteryState
    }
    
    func optimizeForLowBattery() {
        let batteryLevel = getCurrentBatteryLevel()
        if batteryLevel < 0.2 { // %20'nin altında
            // Performans modunu düşür
            // Arka plan senkronizasyonunu durdur
            // Animasyonları azalt
        }
    }
}

Android

Doze Mode ve App Standby

class BatteryOptimizationManager {
    fun handleDozeMode(context: Context) {
        val powerManager = context.getSystemService(Context.POWER_SERVICE) as PowerManager
        
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            val isIgnoringOptimizations = powerManager.isIgnoringBatteryOptimizations(context.packageName)
            if (!isIgnoringOptimizations) {
                // Kullanıcıyı uyar ve ayarlara yönlendir
                requestBatteryOptimizationExemption(context)
            }
        }
    }
    
    private fun requestBatteryOptimizationExemption(context: Context) {
        val intent = Intent(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS).apply {
            data = Uri.parse("package:${context.packageName}")
        }
        context.startActivity(intent)
    }
}

JobScheduler Kullanımı

@TargetApi(Build.VERSION_CODES.LOLLIPOP)
class BatteryOptimizedJobService : JobService() {
    
    override fun onStartJob(params: JobParameters?): Boolean {
        // Arka plan işlemini başlat
        doBackgroundWork(params)
        return true
    }
    
    override fun onStopJob(params: JobParameters?): Boolean {
        // İşlemi durdur
        return false
    }
    
    private fun doBackgroundWork(params: JobParameters?) {
        Thread {
            // Batarya dostu işlemler
            jobFinished(params, false)
        }.start()
    }
}

// JobScheduler kullanımı
class JobSchedulerHelper {
    fun scheduleJob(context: Context) {
        val jobScheduler = context.getSystemService(Context.JOB_SCHEDULER_SERVICE) as JobScheduler
        
        val jobInfo = JobInfo.Builder(JOB_ID, ComponentName(context, BatteryOptimizedJobService::class.java))
            .setRequiredNetworkType(JobInfo.NETWORK_TYPE_UNMETERED) // Sadece WiFi
            .setRequiresCharging(true) // Şarj olurken çalış
            .setRequiresDeviceIdle(true) // Cihaz boştayken çalış
            .setPersisted(true)
            .build()
            
        jobScheduler.schedule(jobInfo)
    }
}

React Native Optimizasyonları

Performance Monitor

import { PerformanceObserver, performance } from 'perf_hooks';

class BatteryOptimizationManager {
  constructor() {
    this.isLowPowerMode = false;
    this.monitorBatteryLevel();
  }
  
  monitorBatteryLevel() {
    // React Native battery level monitoring
    if (Platform.OS === 'ios') {
      this.checkIOSBatteryLevel();
    } else {
      this.checkAndroidBatteryLevel();
    }
  }
  
  checkIOSBatteryLevel() {
    // iOS için batarya seviyesi kontrolü
    const BatteryLevel = NativeModules.BatteryLevel;
    BatteryLevel.getBatteryLevel((level) => {
      if (level < 0.2) {
        this.enableLowPowerMode();
      }
    });
  }
  
  enableLowPowerMode() {
    this.isLowPowerMode = true;
    
    // Animasyonları azalt
    this.reduceAnimations();
    
    // Arka plan görevlerini durdur
    this.pauseBackgroundTasks();
    
    // Ağ isteklerini azalt
    this.reducedNetworkActivity();
  }
  
  reduceAnimations() {
    // Animasyon süresini kısalt
    const animationConfig = {
      duration: this.isLowPowerMode ? 150 : 300,
      useNativeDriver: true
    };
  }
  
  pauseBackgroundTasks() {
    // Periyodik görevleri durdur
    this.cancelScheduledTasks();
  }
  
  reducedNetworkActivity() {
    // Cache'i daha agresif kullan
    // İstekmeri batch'le
    // Compression kullan
  }
}

Memory Management

class MemoryOptimizer {
  constructor() {
    this.imageCache = new Map();
    this.maxCacheSize = 50;
  }
  
  optimizeImageLoading(imageUri) {
    // Düşük bataryada düşük kalite resimleri yükle
    if (this.isLowPowerMode) {
      return this.loadLowQualityImage(imageUri);
    }
    return this.loadHighQualityImage(imageUri);
  }
  
  loadLowQualityImage(imageUri) {
    // Düşük çözünürlük ve yüksek compression
    return {
      uri: imageUri,
      quality: 0.3,
      resize: { width: 200, height: 200 }
    };
  }
  
  clearUnusedCache() {
    // Bellek basıncında cache'i temizle
    if (this.imageCache.size > this.maxCacheSize) {
      const keysToDelete = Array.from(this.imageCache.keys()).slice(0, 10);
      keysToDelete.forEach(key => this.imageCache.delete(key));
    }
  }
}

Flutter Optimizasyonları

Battery Awareness

import 'package:battery_plus/battery_plus.dart';
import 'package:flutter/services.dart';

class BatteryOptimizationService {
  final Battery _battery = Battery();
  bool _isLowPowerMode = false;
  
  Future<void> initializeBatteryMonitoring() async {
    _battery.batteryLevel.then((batteryLevel) {
      if (batteryLevel < 20) {
        _enableLowPowerMode();
      }
    });
    
    _battery.onBatteryStateChanged.listen((BatteryState state) {
      _handleBatteryStateChange(state);
    });
  }
  
  void _enableLowPowerMode() {
    _isLowPowerMode = true;
    
    // Widget rebuild'lerini azalt
    _optimizeWidgetUpdates();
    
    // Animasyonları yavaşlat
    _reduceAnimationSpeed();
    
    // Arka plan işlemlerini durdur
    _pauseBackgroundOperations();
  }
  
  void _optimizeWidgetUpdates() {
    // setState çağrılarını batch'le
    // Gereksiz rebuild'leri önle
  }
  
  void _reduceAnimationSpeed() {
    // Animation controller'ların süresini artır
    const Duration normalDuration = Duration(milliseconds: 300);
    Duration optimizedDuration = _isLowPowerMode 
        ? Duration(milliseconds: 500)
        : normalDuration;
  }
  
  void _pauseBackgroundOperations() {
    // Timer'ları durdur
    // Periyodik görevleri ertele
  }
}

Performance Optimization

class PerformanceOptimizer {
  static const int _maxCacheSize = 100;
  final Map<String, dynamic> _cache = {};
  
  // Lazy loading implementation
  Widget buildOptimizedList(List<dynamic> items) {
    return ListView.builder(
      cacheExtent: _isLowPowerMode ? 200 : 500,
      itemCount: items.length,
      itemBuilder: (context, index) {
        return _buildOptimizedListItem(items[index], index);
      },
    );
  }
  
  Widget _buildOptimizedListItem(dynamic item, int index) {
    // Düşük güç modunda basit widget'lar kullan
    if (_isLowPowerMode) {
      return _buildSimpleListItem(item);
    }
    return _buildRichListItem(item);
  }
  
  Widget _buildSimpleListItem(dynamic item) {
    return ListTile(
      title: Text(item.title),
      // Minimal UI elements
    );
  }
  
  Widget _buildRichListItem(dynamic item) {
    return Card(
      child: Column(
        children: [
          // Rich UI with images, animations, etc.
        ],
      ),
    );
  }
}

En İyi Uygulamalar

1. Proaktif Monitoring

• Batarya seviyesini sürekli izleyin
• Kullanıcı davranışlarına göre optimize edin
• Performance metrikleri toplayın

2. Adaptive UI

• Düşük bataryada UI karmaşıklığını azaltın
• Animasyonları minimize edin
• Renk derinliğini azaltın (OLED ekranlar için)

3. Background Task Management

• Gerekli olmayan arka plan görevlerini durdurun
• Senkronizasyonu geciktirin
• Push notification'ları kullanın

4. Network Optimization

• WiFi bağlantısını tercih edin
• Request'leri batch'leyin
• Cache'i agresif şekilde kullanın

5. Resource Management

• Memory leak'leri önleyin
• CPU-intensive işlemleri erteleyin
• GPU kullanımını minimize edin

Ölçüm ve Testing

Battery Usage Profiling

// Batarya kullanımını ölçme
class BatteryProfiler {
  constructor() {
    this.startTime = Date.now();
    this.startBatteryLevel = null;
  }
  
  async startProfiling() {
    this.startBatteryLevel = await this.getBatteryLevel();
    this.startTime = Date.now();
  }
  
  async endProfiling() {
    const endBatteryLevel = await this.getBatteryLevel();
    const endTime = Date.now();
    
    const batteryDrain = this.startBatteryLevel - endBatteryLevel;
    const duration = endTime - this.startTime;
    
    return {
      batteryDrainPercent: batteryDrain * 100,
      durationMs: duration,
      drainRate: (batteryDrain * 100) / (duration / 1000 / 60) // % per minute
    };
  }
}

Bu optimizasyonları uygulayarak, uygulamanızın batarya tüketimini önemli ölçüde azaltabilir ve kullanıcı deneyimini iyileştirebilirsiniz.