आपका ऐप्लिकेशन, नेटवर्क से जो अनुरोध करता है उनकी वजह से बैटरी ज़्यादा खर्च होती है. ऐसा इसलिए होता है, क्योंकि वे अनुरोध ज़्यादा बैटरी खर्च करने वाले मोबाइल या वाई-फ़ाई रेडियो को चालू कर देते हैं. पैकेट भेजने और पाने के लिए ज़रूरी पावर के अलावा, ये रेडियो सिर्फ़ चालू होने और चालू रहने के लिए ज़्यादा पावर खर्च करते हैं. हर 15 सेकंड में नेटवर्क का अनुरोध करने जैसी सामान्य गतिविधि से भी, मोबाइल रेडियो लगातार चालू रह सकता है. इससे बैटरी तेज़ी से खर्च हो सकती है.
आम तौर पर, नियमित अपडेट तीन तरह के होते हैं:
- उपयोगकर्ता ने इसकी प्रोसेस शुरू की. उपयोगकर्ता के किसी व्यवहार के आधार पर अपडेट करना. जैसे, नीचे स्वाइप करके रीफ़्रेश करने का जेस्चर.
- ऐप्लिकेशन से शुरू किया गया. बार-बार अपडेट करना.
- सर्वर से शुरू किया गया. सर्वर से मिली सूचना के जवाब में अपडेट करना.
इस विषय में, इनमें से हर एक के बारे में बताया गया है. साथ ही, बैटरी खर्च को कम करने के लिए, इन्हें ऑप्टिमाइज़ करने के अन्य तरीकों के बारे में बताया गया है.
उपयोगकर्ता के अनुरोधों को ऑप्टिमाइज़ करना
उपयोगकर्ता की ओर से किए गए अनुरोध, आम तौर पर उपयोगकर्ता के किसी व्यवहार के जवाब में होते हैं. उदाहरण के लिए, ताज़ा समाचार रिपोर्ट पढ़ने के लिए इस्तेमाल किए जाने वाले ऐप्लिकेशन में, उपयोगकर्ता को नई रिपोर्ट देखने के लिए, नीचे स्वाइप करके रीफ़्रेश करने की सुविधा दी जा सकती है. नेटवर्क के इस्तेमाल को ऑप्टिमाइज़ करते समय, उपयोगकर्ता के अनुरोधों का जवाब देने के लिए, इन तकनीकों का इस्तेमाल किया जा सकता है.
उपयोगकर्ता के अनुरोधों को थ्रॉटल करना
अगर उपयोगकर्ता के कुछ अनुरोधों की ज़रूरत नहीं है, तो उन्हें अनदेखा किया जा सकता है. जैसे, मौजूदा डेटा के अपडेट होने के दौरान, नए डेटा की जांच करने के लिए, कम समय में कई बार नीचे स्वाइप करके रीफ़्रेश करने के जेस्चर का इस्तेमाल करना. हर अनुरोध पर कार्रवाई करने से, रेडियो चालू रहता है. इससे काफ़ी बैटरी खर्च हो सकती है. ज़्यादा असरदार तरीका यह है कि उपयोगकर्ता की ओर से किए जाने वाले अनुरोधों को सीमित किया जाए, ताकि एक तय समय में सिर्फ़ एक अनुरोध किया जा सके. इससे रेडियो का इस्तेमाल कम हो जाता है.
कैश मेमोरी का इस्तेमाल करना
अपने ऐप्लिकेशन के डेटा को कैश मेमोरी में सेव करने का मतलब है कि उस जानकारी की एक लोकल कॉपी बनाई जा रही है जिसकी ज़रूरत आपके ऐप्लिकेशन को रेफ़रंस के तौर पर पड़ती है. इसके बाद, आपका ऐप्लिकेशन नए अनुरोध करने के लिए इंटरनेट कनेक्शन खोले बिना, जानकारी की उसी लोकल कॉपी को कई बार ऐक्सेस कर सकता है.
आपको डेटा को ज़्यादा से ज़्यादा कैश मेमोरी में सेव करना चाहिए. इसमें स्टैटिक रिसॉर्स और मांग पर डाउनलोड किए जाने वाले डेटा, जैसे कि फ़ुल-साइज़ इमेज शामिल हैं. एचटीटीपी कैश हेडर का इस्तेमाल करके, यह पक्का किया जा सकता है कि कैश मेमोरी में डेटा सेव करने की आपकी रणनीति की वजह से, आपके ऐप्लिकेशन में पुराना डेटा न दिखे. नेटवर्क रिस्पॉन्स को कैश मेमोरी में सेव करने के बारे में ज़्यादा जानने के लिए, बार-बार डाउनलोड करने से बचें लेख पढ़ें.
Android 11 और इसके बाद के वर्शन पर, आपका ऐप्लिकेशन उन बड़े डेटासेट का इस्तेमाल कर सकता है जिनका इस्तेमाल अन्य ऐप्लिकेशन, मशीन लर्निंग और मीडिया प्लेबैक जैसे कामों के लिए करते हैं. जब आपके ऐप्लिकेशन को किसी शेयर किए गए डेटासेट को ऐक्सेस करना होता है, तो वह नई कॉपी डाउनलोड करने से पहले, कैश मेमोरी में सेव किए गए वर्शन की जांच कर सकता है. शेयर किए गए डेटासेट के बारे में ज़्यादा जानने के लिए, शेयर किए गए डेटासेट ऐक्सेस करना लेख पढ़ें.
ज़्यादा बैंडविड्थ का इस्तेमाल करके, कम समय में ज़्यादा डेटा डाउनलोड करना
वायरलेस रेडियो से कनेक्ट होने पर, ज़्यादा बैंडविड्थ के लिए आम तौर पर ज़्यादा बैटरी खर्च होती है. इसका मतलब है कि 5G में आम तौर पर एलटीई के मुकाबले ज़्यादा बैटरी खर्च होती है. एलटीई में 3G के मुकाबले ज़्यादा बैटरी खर्च होती है.
इसका मतलब है कि रेडियो की बुनियादी स्थिति, रेडियो टेक्नोलॉजी के आधार पर अलग-अलग होती है. आम तौर पर, ज़्यादा बैंडविड्थ वाले रेडियो के लिए, स्थिति में बदलाव होने के बाद टेल-टाइम की वजह से बैटरी पर पड़ने वाला असर ज़्यादा होता है. टेल-टाइम के बारे में ज़्यादा जानकारी के लिए, रेडियो स्टेट मशीन देखें.
वहीं, ज़्यादा बैंडविथ का मतलब है कि ज़्यादा डेटा को पहले से फ़ेच किया जा सकता है. इससे, उतने ही समय में ज़्यादा डेटा डाउनलोड किया जा सकता है. शायद कम सहजता से, क्योंकि टेल-टाइम बैटरी की लागत ज़्यादा होती है. इसलिए, अपडेट की फ़्रीक्वेंसी को कम करने के लिए, हर ट्रांसफ़र सेशन के दौरान रेडियो को ज़्यादा समय तक चालू रखना भी ज़्यादा असरदार होता है.
उदाहरण के लिए, अगर एलटीई रेडियो की बैंडविड्थ और ऊर्जा की खपत 3G से दोगुनी है, तो आपको हर सेशन के दौरान चार गुना ज़्यादा डेटा डाउनलोड करना चाहिए. इसके अलावा, 10 एमबी तक डेटा डाउनलोड किया जा सकता है. इतना ज़्यादा डेटा डाउनलोड करते समय, यह ध्यान रखना ज़रूरी है कि प्रीफ़ेच करने से, डिवाइस के स्टोरेज पर क्या असर पड़ेगा. साथ ही, प्रीफ़ेच कैश को नियमित तौर पर खाली करना ज़रूरी है.
डिफ़ॉल्ट नेटवर्क के लिए लिसनर को रजिस्टर करने के लिए, ConnectivityManager का इस्तेमाल किया जा सकता है. साथ ही, डिवाइस के मौजूदा कनेक्शन टाइप का पता लगाने के लिए, PhoneStateListener को रजिस्टर करने के लिए, TelephonyManager का इस्तेमाल किया जा सकता है. कनेक्शन टाइप की जानकारी मिलने के बाद,
प्रीफ़ेचिंग रूटीन में इस तरह बदलाव किया जा सकता है:
Kotlin
val cm = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager val tm = getSystemService(Context.TELEPHONY_SERVICE) as TelephonyManager private var hasWifi = false private var hasCellular = false private var cellModifier: Float = 1f private val networkCallback = object : ConnectivityManager.NetworkCallback() { // Network capabilities have changed for the network override fun onCapabilitiesChanged( network: Network, networkCapabilities: NetworkCapabilities ) { super.onCapabilitiesChanged(network, networkCapabilities) hasCellular = networkCapabilities .hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) hasWifi = networkCapabilities .hasTransport(NetworkCapabilities.TRANSPORT_WIFI) } } private val phoneStateListener = object : PhoneStateListener() { override fun onPreciseDataConnectionStateChanged( dataConnectionState: PreciseDataConnectionState ) { cellModifier = when (dataConnectionState.networkType) { TelephonyManager.NETWORK_TYPE_LTE or TelephonyManager.NETWORK_TYPE_HSPAP -> 4f TelephonyManager.NETWORK_TYPE_EDGE or TelephonyManager.NETWORK_TYPE_GPRS -> 1/2f else -> 1f } } private class NetworkState { private var defaultNetwork: Network? = null private var defaultCapabilities: NetworkCapabilities? = null fun setDefaultNetwork(network: Network?, caps: NetworkCapabilities?) = synchronized(this) { defaultNetwork = network defaultCapabilities = caps } val isDefaultNetworkWifi get() = synchronized(this) { defaultCapabilities?.hasTransport(TRANSPORT_WIFI) ?: false } val isDefaultNetworkCellular get() = synchronized(this) { defaultCapabilities?.hasTransport(TRANSPORT_CELLULAR) ?: false } val isDefaultNetworkUnmetered get() = synchronized(this) { defaultCapabilities?.hasCapability(NET_CAPABILITY_NOT_METERED) ?: false } var cellNetworkType: Int = TelephonyManager.NETWORK_TYPE_UNKNOWN get() = synchronized(this) { field } set(t) = synchronized(this) { field = t } private val cellModifier: Float get() = synchronized(this) { when (cellNetworkType) { TelephonyManager.NETWORK_TYPE_LTE or TelephonyManager.NETWORK_TYPE_HSPAP -> 4f TelephonyManager.NETWORK_TYPE_EDGE or TelephonyManager.NETWORK_TYPE_GPRS -> 1 / 2f else -> 1f } } val prefetchCacheSize: Int get() = when { isDefaultNetworkWifi -> MAX_PREFETCH_CACHE isDefaultNetworkCellular -> (DEFAULT_PREFETCH_CACHE * cellModifier).toInt() else -> DEFAULT_PREFETCH_CACHE } } private val networkState = NetworkState() private val networkCallback = object : ConnectivityManager.NetworkCallback() { // Network capabilities have changed for the network override fun onCapabilitiesChanged( network: Network, networkCapabilities: NetworkCapabilities ) { networkState.setDefaultNetwork(network, networkCapabilities) } override fun onLost(network: Network?) { networkState.setDefaultNetwork(null, null) } } private val telephonyCallback = object : TelephonyCallback(), TelephonyCallback.PreciseDataConnectionStateListener { override fun onPreciseDataConnectionStateChanged(dataConnectionState: PreciseDataConnectionState) { networkState.cellNetworkType = dataConnectionState.networkType } } connectivityManager.registerDefaultNetworkCallback(networkCallback) telephonyManager.registerTelephonyCallback(telephonyCallback) private val prefetchCacheSize: Int get() { return when { hasWifi -> MAX_PREFETCH_CACHE hasCellular -> (DEFAULT_PREFETCH_CACHE * cellModifier).toInt() else -> DEFAULT_PREFETCH_CACHE } } }
Java
ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE); TelephonyManager tm = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE); private boolean hasWifi = false; private boolean hasCellular = false; private float cellModifier = 1f; private ConnectivityManager.NetworkCallback networkCallback = new ConnectivityManager.NetworkCallback() { @Override public void onCapabilitiesChanged( @NonNull Network network, @NonNull NetworkCapabilities networkCapabilities ) { super.onCapabilitiesChanged(network, networkCapabilities); hasCellular = networkCapabilities .hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR); hasWifi = networkCapabilities .hasTransport(NetworkCapabilities.TRANSPORT_WIFI); } }; private PhoneStateListener phoneStateListener = new PhoneStateListener() { @Override public void onPreciseDataConnectionStateChanged( @NonNull PreciseDataConnectionState dataConnectionState ) { switch (dataConnectionState.getNetworkType()) { case (TelephonyManager.NETWORK_TYPE_LTE | TelephonyManager.NETWORK_TYPE_HSPAP): cellModifier = 4; Break; case (TelephonyManager.NETWORK_TYPE_EDGE | TelephonyManager.NETWORK_TYPE_GPRS): cellModifier = 1/2.0f; Break; default: cellModifier = 1; Break; } } }; cm.registerDefaultNetworkCallback(networkCallback); tm.listen( phoneStateListener, PhoneStateListener.LISTEN_PRECISE_DATA_CONNECTION_STATE ); public int getPrefetchCacheSize() { if (hasWifi) { return MAX_PREFETCH_SIZE; } if (hasCellular) { return (int) (DEFAULT_PREFETCH_SIZE * cellModifier); } return DEFAULT_PREFETCH_SIZE; }
ऐप्लिकेशन से शुरू किए गए अनुरोधों को ऑप्टिमाइज़ करना
ऐप्लिकेशन से शुरू किए गए अनुरोध, आम तौर पर किसी शेड्यूल के हिसाब से होते हैं. जैसे, कोई ऐप्लिकेशन जो बैकएंड सेवा को लॉग या आंकड़े भेजता है. ऐप्लिकेशन से शुरू किए गए अनुरोधों को मैनेज करते समय, उन अनुरोधों की प्राथमिकता पर ध्यान दें. साथ ही, यह भी देखें कि क्या उन्हें एक साथ बैच किया जा सकता है और क्या उन्हें तब तक के लिए टाला जा सकता है, जब तक डिवाइस चार्ज न हो जाए या किसी ऐसे नेटवर्क से कनेक्ट न हो जाए जिसमें डेटा इस्तेमाल की कोई सीमा न हो. इन अनुरोधों को ऑप्टिमाइज़ किया जा सकता है. इसके लिए, सावधानी से शेड्यूल बनाएं और WorkManager जैसी लाइब्रेरी का इस्तेमाल करें.
नेटवर्क के अनुरोधों को बैच में भेजना
किसी फ़ोन या टैबलेट पर रेडियो चालू करने, कनेक्शन बनाने, और रेडियो को चालू रखने की प्रोसेस में काफ़ी बैटरी खर्च होती है. इस वजह से, अलग-अलग अनुरोधों को रैंडम समय पर प्रोसेस करने से, ज़्यादा बैटरी खर्च हो सकती है और बैटरी लाइफ़ कम हो सकती है. इससे बेहतर तरीका यह है कि नेटवर्क के अनुरोधों के सेट को सूची में जोड़ें और उन्हें एक साथ प्रोसेस करें. इससे सिस्टम को रेडियो चालू करने के लिए सिर्फ़ एक बार बिजली खर्च करनी पड़ती है और ऐप्लिकेशन के लिए अनुरोध किया गया सारा डेटा भी मिल जाता है.
WorkManager का इस्तेमाल करना
WorkManager लाइब्रेरी का इस्तेमाल करके, काम को बेहतर शेड्यूल के हिसाब से किया जा सकता है. इसमें यह ध्यान रखा जाता है कि नेटवर्क की उपलब्धता और पावर स्टेटस जैसी खास शर्तें पूरी हो रही हैं या नहीं. उदाहरण के लिए, मान लें कि आपके पास DownloadHeadlinesWorker नाम की एक Worker सबक्लास है, जो ताज़ा खबरों की हेडलाइन को वापस लाती है. इस वर्कर को हर घंटे चलाने के लिए शेड्यूल किया जा सकता है. इसके लिए, डिवाइस को ऐसे नेटवर्क से कनेक्ट करना होगा जिसमें डेटा इस्तेमाल की कोई सीमा न हो और डिवाइस की बैटरी कम न हो. साथ ही, डेटा वापस पाने में कोई समस्या होने पर, फिर से कोशिश करने की कस्टम रणनीति अपनाई जा सकती है. इसके बारे में यहां बताया गया है:
val constraints = Constraints.Builder() .setRequiredNetworkType(NetworkType.UNMETERED) .setRequiresBatteryNotLow(true) .build() val request = PeriodicWorkRequestBuilder<DownloadHeadlinesWorker>(1, TimeUnit.HOURS) .setConstraints(constraints) .setBackoffCriteria(BackoffPolicy.LINEAR, 1L, TimeUnit.MINUTES) .build() WorkManager.getInstance(context).enqueue(request)
WorkManager के अलावा, Android प्लैटफ़ॉर्म पर कई अन्य टूल भी उपलब्ध हैं. इनकी मदद से, नेटवर्किंग से जुड़े टास्क पूरे करने के लिए बेहतर शेड्यूल बनाया जा सकता है. जैसे, पोलिंग. इन टूल को इस्तेमाल करने के बारे में ज़्यादा जानने के लिए, बैकग्राउंड में चल रही प्रोसेस की गाइड देखें.
सर्वर से शुरू किए गए अनुरोधों को ऑप्टिमाइज़ करना
सर्वर से शुरू किए गए अनुरोध, आम तौर पर सर्वर से मिली सूचना के जवाब में होते हैं. उदाहरण के लिए, ताज़ा समाचार रिपोर्ट पढ़ने के लिए इस्तेमाल किए जाने वाले ऐप्लिकेशन को, उपयोगकर्ता की पसंद के मुताबिक बनाई गई नई रिपोर्ट के बारे में सूचना मिल सकती है. इसके बाद, वह ऐप्लिकेशन उन रिपोर्ट को डाउनलोड कर लेता है.
Firebase क्लाउड से मैसेज की मदद से सर्वर अपडेट भेजना
Firebase क्लाउड से मैसेज (FCM) एक आसान तरीका है. इसका इस्तेमाल, सर्वर से किसी ऐप्लिकेशन के इंस्टेंस में डेटा ट्रांसमिट करने के लिए किया जाता है. FCM का इस्तेमाल करके, आपका सर्वर किसी डिवाइस पर चल रहे आपके ऐप्लिकेशन को सूचना दे सकता है कि उसके लिए नया डेटा उपलब्ध है.
पोलिंग में, आपके ऐप्लिकेशन को नए डेटा के लिए सर्वर को नियमित तौर पर पिंग करना पड़ता है. इसके मुकाबले, इवेंट-ड्रिवन मॉडल में आपका ऐप्लिकेशन नया कनेक्शन सिर्फ़ तब बनाता है, जब उसे पता होता है कि डाउनलोड करने के लिए डेटा मौजूद है. यह मॉडल, आपके ऐप्लिकेशन में जानकारी अपडेट करते समय, ग़ैर-ज़रूरी कनेक्शन को कम करता है और इंतज़ार के समय को कम करता है.
FCM को लागू करने के लिए, टीसीपी/आईपी कनेक्शन का इस्तेमाल किया जाता है. इससे, लगातार बने रहने वाले कनेक्शन की संख्या कम हो जाती है. साथ ही, प्लैटफ़ॉर्म को बैंडविड्थ को ऑप्टिमाइज़ करने और बैटरी लाइफ़ पर पड़ने वाले असर को कम करने में मदद मिलती है.