# Mobile App Performance Optimizatsiyasi: Millisekundlar Imperiyasining Chuqur Anatomiyasi — Zamonaviy Mobil Texnologiyalarning Professional Sirlari 📱⚡ Zamonaviy mobil dunyo — bu millisekundlar ustidagi kurash maydoni. Bir marta sekin ochilgan ilova foydalanuvchini abadiy yo'qotishi mumkin, chunki inson miyasi 100 millisekunddan ortiq kechikishni darhol sezadi. App Store va Google Play-da 5 yulduzli reytingga ega bo'lgan ilovalarning 87% performance jihatidan eng yuqori standartlarga javob beradi. Biroq performance optimizatsiyasi — bu faqat texnik masala emas, balki biznes strategiyasining muhim qismidir. ## Performance Optimizatsiyasining Fundamental Printsiplari Mobile performance optimizatsiyasi bir necha asosiy tamoyillarga asoslanadi. Birinchidan, **responsiveness principle** — har qanday user interaction 100ms ichida javob berishi kerak. Bu neurological research asosida aniqlangan: inson miyasi 100ms dan ortiq kechikishni "sekin" deb qabul qiladi. Ikkinchidan, **efficiency principle** — minimal resurslar bilan maksimal natijaga erishish. Mobil qurilmalar battery, memory va processing power jihatidan cheklangan, shuning uchun har bir operation optimize bo'lishi kerak. Uchinchi printsip **predictability** — ilova har xil device va network sharoitlarida consistent performance ko'rsatishi kerak. Bu ayniqsa Android ecosystem uchun muhim, chunki fragment (parcha-parcha) bo'lingan market da ming xil device mavjud. To'rtinchi printsip **scalability** — user base o'sgan sari performance degradation bo'lmasligi kerak. > [!NOTE] > Google tadqiqotlari shuni ko'rsatadiki, mobile web page ning 3 sekunddan ortiq yuklanishi bounce rate ni 53% ga oshiradi. Bu native mobile applications uchun ham tegishli. Performance optimizatsiyasi uch asosiy layer da amalga oshiriladi: **Application Layer** (kod va arxitektura), **Runtime Layer** (virtual machine, garbage collector), va **System Layer** (operating system, hardware). Har bir layer da turli optimization technique lari qo'llaniladi, biroq eng katta ta'sir application layer da amalga oshiriladi. ```mermaid flowchart TD A["Performance Optimization"] --> B["Application Layer"] A --> C["Runtime Layer"] A --> D["System Layer"] B --> B1["Code Optimization"] B --> B2["Architecture Patterns"] B --> B3["Data Structures"] C --> C1["Memory Management"] C --> C2["Garbage Collection"] C --> C3["JIT Compilation"] D --> D1["OS Scheduler"] D --> D2["Hardware Abstraction"] D --> D3["Driver Optimization"] ``` ## Performance Optimizatsiyasining Tarixiy Evolyutsiyasi va Zamonaviy Kontekst Mobile performance optimizatsiyasining tarixi 2007-yilda birinchi iPhone ning paydo bo'lishi bilan boshlandi. O'sha paytda 128MB operativ xotiraga ega iPhone uchun har bir bayt qimmatli edi. Steve Jobs "60 FPS yoki hech narsa yo'q" tamoyilini e'lon qilganda, bu butun mobil industria uchun yangi standart bo'ldi. Apple muhandislari **immediate mode rendering** o'rniga **retained mode graphics** dan foydalanib, GPU acceleration ni maksimal darajada exploit qilishdi. 2010-yillarda Android ning paydo bo'lishi bilan vaziyat yanada murakkablashdi. Har xil ekran o'lchamlari, turli xil chipsetlar, xotirani boshqarish mexanizmlari bularning barchasi development community ni yangi yondashuvlar izlashga majbur qildi. Google ning Project Butter (Android 4.1) performance muammolarini hal qilishga qaratilgan birinchi tizimli yondashuv edi. **VSync synchronization**, **triple buffering**, va **CPU/GPU coordination** kabi texnikalar joriy etildi. Cross-platform framework larning paydo bo'lishi performance landscape ni butunlay o'zgartirdi. 2015-yil React Native ning paydo bo'lishi bilan JavaScript bridge architecture yangi bottleneck larni yaratdi, biroq ayni paytda development speed ni sezilarli oshirdi. Facebook muhandislari **asynchronous bridge communication** va **native module caching** orqali bu muammolarni hal qilishga harakat qildilar. Flutter ning 2017-yilgi debyuti esa **direct rendering** paradigmasini olib keldi. Google Skia graphics engine dan foydalanib, platform native widgets ni bypass qilish orqali consistent performance ni barcha device larda ta'minlaydi. Bu yondashuv ayniqsa custom UI animations va complex graphics uchun afzallik beradi. > [!TIP] > Zamonaviy performance optimization da "write once, optimize everywhere" printsipidan "write optimized, run everywhere" ga o'tish kuzatilmoqda. ## Memory Management: Mobil Resurslar Imperiyasining Arxitekturasi Memory management mobil performance optimizatsiyasining eng fundamental jihati hisoblanadi. Zamonaviy smartphone lar 4GB dan 16GB gacha RAM ga ega bo'lsa ham, operating system va background processlar tufayli har bir ilovaga ajratilgan memory juda cheklangan. **Working set** (faol ishlatilayotgan memory) va **virtual memory** (disk ga swapped memory) orasidagi farq mobile performance ga bevosita ta'sir qiladi. iOS platformasida memory management **Automatic Reference Counting (ARC)** asosida ishlaydi. Bu compile-time memory management technique bo'lib, runtime overhead ni kamaytiradi. Biroq ARC **retain cycle** larni automatic hal qila olmaydi bir-biriga strong reference qiluvchi obyektlar memory da abadiy qolishi mumkin. Bu ayniqsa closure va delegate pattern lar ishlatilganda kuzatiladi. **Weak reference** va **unowned reference** lar retain cycle larni oldini olish uchun ishlatiladi. Android platformasida **generational garbage collection** mexanizmi qo'llaniladi. Young generation (yangi obyektlar), old generation (uzoq yashovchi obyektlar), va permanent generation (class metadata) turli algorithmlar bilan boshqariladi. ART (Android Runtime) **concurrent marking** va **parallel sweeping** orqali GC pause larini minimalizatsiya qiladi. Biroq large heap allocation lari GC pressure ni oshiradi va UI janking ga olib keladi. React Native da **dual-heap architecture** mavjud: JavaScript heap (V8/Hermes) va native heap. JavaScript obyektlari serialization/deserialization orqali native code bilan interact qiladi, bu esa additional memory pressure yaratadi. **Memory fragmentation** ikkala heap da ham ro'y berishi mumkin, natijada available memory bo'lsa ham, large continuous blocks allocate qilib bo'lmaydi. Flutter da **object pooling** va **widget recycling** orqali memory pressure kamaytiriladi. **InheritedWidget** va **Provider** pattern lar orqali state management optimize qilinadi. Flutter engine ning Dart VM si **incremental garbage collection** ishlatadi, bu UI thread ga ta'sirni kamaytiradi. ```swift // Flutter - Advanced Memory Pool Implementation class ObjectPool { final List _available = []; final Set _inUse = {}; final T Function() _creator; final void Function(T)? _resetFunction; final int _maxPoolSize; ObjectPool({ required T Function() creator, void Function(T)? resetFunction, int maxPoolSize = 50, }) : _creator = creator, _resetFunction = resetFunction, _maxPoolSize = maxPoolSize; T acquire() { T object; if (_available.isNotEmpty) { object = _available.removeLast(); } else { object = _creator(); } _inUse.add(object); return object; } void release(T object) { if (!_inUse.remove(object)) { return; // Object not in use } _resetFunction?.call(object); if (_available.length < _maxPoolSize) { _available.add(object); } // If pool is full, let object be garbage collected } void clear() { _available.clear(); _inUse.clear(); } int get activeCount => _inUse.length; int get availableCount => _available.length; } // Usage in widget context class OptimizedListWidget extends StatefulWidget { @override _OptimizedListWidgetState createState() => _OptimizedListWidgetState(); } class _OptimizedListWidgetState extends State { late ObjectPool _itemPool; @override void initState() { super.initState(); _itemPool = ObjectPool( creator: () => ListItemData(), resetFunction: (item) => item.reset(), maxPoolSize: 100, ); } @override void dispose() { _itemPool.clear(); super.dispose(); } } ``` Memory pool pattern yukroida ko'rsatilgan kabi, frequent allocation/deallocation larni kamaytirish uchun ishlatiladi. Bu gaming va multimedia applications lar uchun ayniqsa foydali. Object pool pre-allocated objects ni reuse qilish orqali garbage collection pressure ni kamaytiradi. **Memory mapping** va **memory-mapped files** katta datasets bilan ishlash uchun samarali texnika. Operating system virtual memory management ni leverage qilib, physical RAM dan ko'ra katta data structures bilan ishlash imkonini beradi. Biroq bu technique page fault lar va disk I/O overhead ni keltirib chiqarishi mumkin. **Copy-on-Write (COW)** semantics memory usage ni optimize qilish uchun ishlatiladi. Bir necha obyekt bir xil data ga reference qilganda, actual copy faqat modification vaqtida amalga oshiriladi. Swift ning value types va Kotlin ning immutable collections bu printsipdan foydalanadi. > [!WARNING] > Memory leaks mobile applications da critical issue hisoblanadi, chunki user process ni restart qila olmaydi. Desktop applications da process restart orqali memory tozalanadi, biroq mobile da bu imkon yo'q. ## Memory Profiling va Leak Detection Memory leak larni detect qilish uchun zamonaviy development tools sophisticated techniques ishlatadi. **Heap snapshot analysis** belgilangan vaqt oralig'ida memory allocation patterns ni tahlil qiladi. **Reference chain analysis** obyektlar orasidagi dependency graph ni visualize qilib, leak source ni topishga yordam beradi. **Weak reference pattern** va **observer pattern** lar memory leak larning asosiy sababi. Event listener lar, notification observers, va callback functions automatic cleanup qilinmasa, strong reference cycle lar hosil bo'ladi. **Automatic cleanup** uchun lifecycle-aware components va scope-based resource management ishlatiladi. Memory fragmentation internal fragmentation (allocated block ichidagi unused space) va external fragmentation (free blocks orasidagi unusable gaps) ga bo'linadi. **Memory compaction** va **garbage collection generational algorithms** fragmentation ni kamaytirish uchun ishlatiladi. ## Rendering Performance va UI Thread Optimizatsiyasi Rendering performance mobil user experience ning eng ko'rinadigan jihati. Human visual system 16.67 millisecondda bir marta yangilanishni perceive qiladi, shuning uchun **60 FPS** maintain qilish critical requirement. Zamonaviy flagship devices 90Hz, 120Hz va hatto 144Hz refresh rate larga ega, bu performance requirements ni yanada qat'iylashtiradi. **Frame pacing** va **VSync synchronization** smooth animation lar uchun zarur. GPU rendering va display refresh cycle lar synchronize bo'lishi kerak, aks holda **screen tearing** yoki **stuttering** ro'y beradi. Android da **Choreographer API** va iOS da **CADisplayLink** frame timing ni coordinate qilish uchun ishlatiladi. iOS platformasida rendering **Core Animation** framework orqali amalga oshiriladi. **Layer tree** va **presentation tree** parallel da maintain qilinadi. Main thread da layout calculation va constraint solving amalga oshiriladi, GPU da esa compositing va final rendering. **Implicit animation** va **explicit animation** lar GPU da hardware-accelerated bo'lib ishlaydi. Android rendering pipeline yanada complex: **View hierarchy traversal**, **measure/layout/draw** phases, **surface flinger** composition, va **hardware composer (HWC)** display output. **RenderScript** va **Vulkan API** low-level graphics programming uchun ishlatiladi. **GPU overdraw** va **layer blending** performance bottleneck larining asosiy sabablari. React Native rendering architecture **three-threaded model** dan foydalanadi: **JavaScript thread** (business logic), **Shadow thread** (layout calculation), **Main thread** (UI updates). **Bridge serialization** overhead significant performance impact qiladi. **Fabric architecture** (React Native 0.68+) synchronous native calls orqali bridge overhead ni kamaytiradi. Flutter **immediate mode rendering** va **retained mode optimization** ni combine qiladi. **Widget tree**, **element tree**, va **render tree** uch level abstraction. **Skia graphics engine** to'g'ridan-to'g'ri GPU bilan ishlaydi, platform native widgets bypass qilinadi. Bu consistent performance beradi, biroq platform-specific accessibility features dan mahrum qilishi mumkin. ```kotlin // iOS - Advanced Layer Optimization Techniques class HighPerformanceImageView: UIView { private var imageLayer: CALayer? private var placeholderLayer: CALayer? override class var layerClass: AnyClass { return CALayer.self } override init(frame: CGRect) { super.init(frame: frame) setupOptimizedLayers() } private func setupOptimizedLayers() { // Disable implicit animations for better performance CATransaction.begin() CATransaction.setDisableActions(true) layer.drawsAsynchronously = true layer.shouldRasterize = false // Dynamic content shouldn't be rasterized // Setup image layer with optimal settings imageLayer = CALayer() imageLayer?.contentsGravity = .resizeAspectFill imageLayer?.masksToBounds = true imageLayer?.allowsGroupOpacity = false layer.addSublayer(imageLayer!) // Placeholder layer for loading states placeholderLayer = CALayer() placeholderLayer?.backgroundColor = UIColor.systemGray6.cgColor layer.insertSublayer(placeholderLayer!, at: 0) CATransaction.commit() } func setImage(_ image: UIImage?, animated: Bool = false) { guard let imageLayer = self.imageLayer else { return } if animated && imageLayer.contents != nil { // Smooth transition animation let transition = CATransition() transition.type = .fade transition.duration = 0.3 transition.timingFunction = CAMediaTimingFunction(name: .easeInEaseOut) imageLayer.add(transition, forKey: "imageTransition") } imageLayer.contents = image?.cgImage // Hide placeholder when image is loaded placeholderLayer?.isHidden = image != nil } override func layoutSubviews() { super.layoutSubviews() CATransaction.begin() CATransaction.setDisableActions(true) imageLayer?.frame = bounds placeholderLayer?.frame = bounds CATransaction.commit() } } // Advanced shadow optimization extension UIView { func applyOptimizedShadow( color: UIColor = .black, alpha: Float = 0.3, x: CGFloat = 0, y: CGFloat = 2, blur: CGFloat = 4 ) { layer.shadowColor = color.cgColor layer.shadowOpacity = alpha layer.shadowOffset = CGSize(width: x, height: y) layer.shadowRadius = blur // Pre-calculate shadow path for better performance layer.shadowPath = UIBezierPath( roundedRect: bounds, cornerRadius: layer.cornerRadius ).cgPath // Rasterize only for static content if !layer.hasAnimations() { layer.shouldRasterize = true layer.rasterizationScale = UIScreen.main.scale } } } ``` Yuqoridagi kodda iOS layer optimization techniques ko'rsatilgan. **CATransaction** implicit animation larni disable qilish uchun ishlatiladi. **drawsAsynchronously** background thread da drawing operations ni amalga oshiradi. **shadowPath** pre-calculation shadow rendering performance ni 3-4 marta yaxshilaydi. **Overdraw detection** va **layer blending optimization** critical performance factors. iOS da Simulator > Debug > Color Blended Layers orqali blending hotspot larni visualization qilish mumkin. Android da "Debug GPU overdraw" developer option similar functionality beradi. **View recycling** va **cell reuse patterns** list performance uchun zarur. **UITableViewCell** va **RecyclerView.ViewHolder** expensive view creation ni avoid qilish uchun object pool pattern dan foydalanadi. **Prefetching** va **predictive loading** user scroll behavior asosida content ni oldindan tayyorlaydi. **Layout thrashing** performance killer bo'lib, style property larining tez-tez o'zgarishi continuous relayout cycle yaratadi. **Constraint priority** va **layout guide** lar complex UI lar uchun efficient layout system beradi. **Batch updates** multiple layout changes ni single pass da amalga oshiradi. > [!TIP] > GPU memory bandwidth mobile devices da limited resource. Texture compression (ASTC, ETC2) va mipmap generation memory usage ni 50-70% gacha kamaytirishi mumkin. ## Advanced Animation Optimization Animation performance optimization bir nechta layer da amalga oshiriladi. **Transform animation** lar (scale, rotation, translation) GPU da hardware-accelerated, **property animation** lar (width, height, background color) esa CPU intensive. **Composite layer** yaratish orqali animation lar main thread dan ajratish mumkin. **Bezier curve** va **spring physics** animation lar natural motion ni simulate qiladi, biroq complex calculation talab qiladi. **Lookup table** va **interpolation function** lar performance ni optimize qilish uchun ishlatiladi. **Animation batching** multiple simultaneous animations ni coordinate qiladi. **Lottie animation** lar designer-developer workflow ni yaxshilaydi, biroq JSON parsing va vector rendering overhead keltirib chiqaradi. **Pre-rendered sprite sheet** alternative approach bo'lib, memory usage ko'p, biroq CPU/GPU load kam. ## Network Optimizatsiyasi va API Performance Strategiyalari Network latency mobile applications uchun eng critical bottleneck lardan biri. 4G LTE da average round-trip time 50-100ms, 5G da theoretical 1-10ms, biroq real-world conditions da significantly yuqori. **Network topology**, **congestion control**, va **radio resource management** actual latency ga ta'sir qiladi. **HTTP/2 multiplexing** bir connection orqali parallel request larni enable qiladi, **HTTP/3 QUIC protocol** esa UDP asosida head-of-line blocking muammosini hal qiladi. Biroq mobile browser support va CDN compatibility hali ham limited. **Connection pooling** va **keep-alive mechanism** lar connection overhead ni kamaytiradi. **GraphQL** REST API ga nisbatan mobile uchun optimal, chunki client-side field selection over-fetching ni eliminate qiladi. **Query complexity analysis** va **depth limiting** DoS attack larni prevent qiladi. **DataLoader pattern** N+1 query problem ni solve qiladi. Biroq GraphQL caching strategy lari REST ga nisbatan complex. **gRPC binary protocol** JSON ga nisbatan 60-70% kam bandwidth ishlatadi. **Protocol Buffers serialization** type-safe va version-compatible. **Bidirectional streaming** real-time communication uchun WebSocket alternative. Google, Netflix, Uber kabi companies microservices architecture da gRPC dan extensive foydalanadi. API pagination strategy lari user experience ga direct impact qiladi. **Cursor-based pagination** large datasets uchun consistent performance beradi. **Infinite scrolling** user engagement oshiradi, biroq memory consumption va SEO challenges yaratadi. **Virtual scrolling** large lists uchun DOM/Widget nodes ni recycle qiladi. ```swift // Advanced Network Request Management with Intelligent Caching class IntelligentNetworkManager { constructor(config = {}) { this.cache = new Map(); this.pendingRequests = new Map(); this.requestQueue = []; this.retryQueues = new Map(); this.circuitBreakers = new Map(); // Configuration with defaults this.config = { maxCacheSize: config.maxCacheSize || 100, defaultTTL: config.defaultTTL || 300000, // 5 minutes maxRetries: config.maxRetries || 3, baseRetryDelay: config.baseRetryDelay || 1000, circuitBreakerThreshold: config.circuitBreakerThreshold || 5, batchTimeout: config.batchTimeout || 100, ...config }; this.networkMonitor = this.initializeNetworkMonitoring(); this.startBatchProcessor(); } // Intelligent request with fallback strategies async request(url, options = {}) { const requestId = this.generateRequestId(url, options); // Circuit breaker check if (this.isCircuitBreakerOpen(url)) { throw new Error(`Circuit breaker open for ${url}`); } // Check cache first const cacheResult = await this.checkCache(requestId); if (cacheResult && !options.bypassCache) { return cacheResult; } // Deduplication - check pending requests if (this.pendingRequests.has(requestId)) { return this.pendingRequests.get(requestId); } // Create request with intelligent retry const requestPromise = this.executeWithRetry(url, options, requestId); this.pendingRequests.set(requestId, requestPromise); try { const result = await requestPromise; this.updateCache(requestId, result, options.ttl); this.recordSuccess(url); return result; } catch (error) { this.recordFailure(url); throw error; } finally { this.pendingRequests.delete(requestId); } } // Exponential backoff with jitter async executeWithRetry(url, options, requestId) { let lastError; for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) { try { return await this.executeRequest(url, options); } catch (error) { lastError = error; // Don't retry on client errors (4xx) if (error.status >= 400 && error.status < 500) { throw error; } if (attempt < this.config.maxRetries) { const delay = this.calculateRetryDelay(attempt); await this.sleep(delay); } } } throw lastError; } calculateRetryDelay(attempt) { // Exponential backoff with jitter const baseDelay = this.config.baseRetryDelay * Math.pow(2, attempt); const jitter = Math.random() * 0.3 * baseDelay; // 30% jitter return baseDelay + jitter; } // Network-aware request optimization async executeRequest(url, options) { const networkInfo = this.getNetworkInfo(); const optimizedOptions = this.optimizeRequestForNetwork(options, networkInfo); const controller = new AbortController(); const timeout = this.calculateTimeout(networkInfo); const timeoutId = setTimeout(() => controller.abort(), timeout); try { const response = await fetch(url, { ...optimizedOptions, signal: controller.signal }); if (!response.ok) { throw new NetworkError( `HTTP ${response.status}: ${response.statusText}`, response.status ); } const data = await response.json(); return { data, metadata: { timestamp: Date.now(), networkType: networkInfo.type, responseTime: Date.now() - startTime } }; } finally { clearTimeout(timeoutId); } } // Adaptive timeout based on network conditions calculateTimeout(networkInfo) { const baseTimeout = 10000; // 10 seconds const multipliers = { 'slow-2g': 3, '2g': 2.5, '3g': 1.5, '4g': 1, '5g': 0.8 }; return baseTimeout * (multipliers[networkInfo.effectiveType] || 1); } // Circuit breaker implementation recordFailure(url) { const failures = this.circuitBreakers.get(url) || 0; this.circuitBreakers.set(url, failures + 1); if (failures + 1 >= this.config.circuitBreakerThreshold) { setTimeout(() => { this.circuitBreakers.delete(url); }, 60000); // Reset after 1 minute } } isCircuitBreakerOpen(url) { const failures = this.circuitBreakers.get(url) || 0; return failures >= this.config.circuitBreakerThreshold; } } // Custom error class for better error handling class NetworkError extends Error { constructor(message, status, response = null) { super(message); this.name = 'NetworkError'; this.status = status; this.response = response; } } ``` Yuqoridagi implementation advanced network management features ni ko'rsatadi: **circuit breaker pattern**, **exponential backoff with jitter**, **network-adaptive timeouts**, va **intelligent caching**. Real-world production applications da bu kabi comprehensive approach zarur. **Request batching** multiple API calls ni combine qilib, network roundtrips ni kamaytiradi. **GraphQL query batching** va **REST API composition** texnikalari ishlatiladi. **Debouncing** va **throttling** user input driven requests ni optimize qiladi. **Offline-first architecture** PWA va hybrid applications uchun critical. **Service Worker caching strategies**: Cache First, Network First, Cache Only, Network Only, va Stale While Revalidate. **Background Sync** offline actions ni online bo'lganda execute qiladi. **CDN optimization** global content delivery uchun zarur. **Edge computing** va **geographic load balancing** latency ni minimize qiladi. **Image optimization services** (Cloudinary, ImageKit) automatic format conversion va responsive delivery beradi. | Network Protocol | Advantages | Disadvantages | Use Cases | | ------------------ | ------------ | --------------- | ----------- | | HTTP/1.1 | Simple, widely supported | Head-of-line blocking, multiple connections | Legacy APIs | | HTTP/2 | Multiplexing, header compression | Complex, limited mobile support | Modern web APIs | | HTTP/3 (QUIC) | No HOL blocking, fast handshake | New protocol, limited adoption | High-performance apps | | WebSocket | Real-time, low latency | Connection overhead, battery drain | Chat, gaming, live data | | gRPC | Efficient, type-safe, streaming | Binary format, learning curve | Microservices | ## Battery Life Optimizatsiyasi va Background Processing Battery optimization zamonaviy mobile development ning eng strategic jihatlaridan biri. Foydalanuvchilar battery life ni performance dan ham muhimroq priority deb hisoblaydi. **Battery chemistry** (Lithium-ion) va **charging cycle** limitations tufayli efficient power management critical requirement. **CPU frequency scaling** va **dynamic voltage adjustment** processor power consumption ni control qiladi. **Big.LITTLE architecture** (ARM) high-performance va energy-efficient core larni combine qiladi. Heavy computational tasks big cores da, background tasks LITTLE cores da bajariladi. **Network radio optimization** battery draining ning asosiy sababi. **Radio State Machine** (Idle, FACH, DCH) power consumption ga ta'sir qiladi. Request batching, intelligent scheduling, va adaptive polling intervals radio active time ni minimize qiladi. **WiFi scanning** va **Bluetooth discovery** continuous battery drain qiladi. **Location services** GPS, cellular triangulation, va WiFi positioning turli power profiles bilan ishlaydi. **Significant location change monitoring** continuous GPS tracking ga alternative beradi. **Geofencing** va **region monitoring** battery efficient location awareness beradi. iOS da **Background App Refresh** va Android da **Doze mode** background activity ni drastically limit qiladi. **Background processing budget** har bir app uchun limited time allocation beradi. **Push notifications** background processing alternative sifatida ishlatiladi. **Database optimization** ham battery ga ta'sir qiladi. Frequent small writes NAND flash wear oshiradi. **Write amplification** va **garbage collection** (SSD) additional power consumption keltirib chiqaradi. **Batch database operations** va **transaction optimization** I/O operations ni minimize qiladi. **Sensor fusion** va **low-power sensor APIs** battery consumption ni optimize qiladi. **Accelerometer** va **gyroscope** continuously power consumption qiladi. **Step detector** va **significant motion** high-level APIs power efficient sensing beradi. ```kotlin // Android - Comprehensive Battery Optimization Manager class BatteryOptimizationManager(private val context: Context) { private val batteryManager = context.getSystemService(Context.BATTERY_SERVICE) as BatteryManager private val powerManager = context.getSystemService(Context.POWER_SERVICE) as PowerManager private val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager // Battery-aware task scheduler class BatteryAwareScheduler { private val taskQueue = PriorityQueue(compareBy { it.priority }) private var batteryLevel = 100 private var isCharging = false data class ScheduledTask( val id: String, val task: suspend () -> Unit, val priority: Int, val batteryThreshold: Int, val requiresCharging: Boolean = false, val networkRequired: Boolean = false ) fun scheduleTask(task: ScheduledTask) { if (canExecuteTask(task)) { executeImmediately(task) } else { taskQueue.offer(task) } } } } ```