ลดผลกระทบของการอัปเดตเป็นประจำ

คำขอที่แอปส่งไปยังเครือข่ายเป็นสาเหตุหลักที่ทำให้แบตเตอรี่หมดเร็วเนื่องจากจะเปิดสัญญาณวิทยุมือถือหรือ Wi-Fi ซึ่งกินพลังงาน นอกจากพลังงานที่จําเป็นในการส่งและรับแพ็กเก็ตแล้ว วิทยุเหล่านี้ยังใช้พลังงานเพิ่มเติมในการเปิดเครื่องและทำให้เครื่องทำงานอยู่เสมอ การดำเนินการง่ายๆ อย่างคำขอเครือข่ายทุกๆ 15 วินาทีอาจทำให้วิทยุมือถือเปิดอยู่อย่างต่อเนื่องและทำให้แบตเตอรี่หมดเร็ว

การอัปเดตทั่วไปมี 3 ประเภท ได้แก่

• เริ่มโดยผู้ใช้ ทำการอัปเดตตามพฤติกรรมบางอย่างของผู้ใช้ เช่น ท่าทางสัมผัสเพื่อรีเฟรช
• เริ่มต้นโดยแอป ทำการอัปเดตเป็นประจำ
• เริ่มต้นจากเซิร์ฟเวอร์ ทำการอัปเดตตามการแจ้งเตือนจากเซิร์ฟเวอร์

หัวข้อนี้จะกล่าวถึงฟีเจอร์แต่ละรายการและวิธีอื่นๆ ในการเพิ่มประสิทธิภาพเพื่อลดการสิ้นเปลืองแบตเตอรี่

เพิ่มประสิทธิภาพคำขอที่ผู้ใช้เริ่ม

โดยปกติแล้ว คำขอที่ผู้ใช้เริ่มจะตอบสนองต่อพฤติกรรมบางอย่างของผู้ใช้ เช่น แอปที่ใช้อ่านบทความข่าวล่าสุดอาจอนุญาตให้ผู้ใช้ใช้ท่าทางสัมผัส "ปัดเพื่อรีเฟรช" เพื่อตรวจหาบทความใหม่ คุณสามารถใช้เทคนิคต่อไปนี้เพื่อตอบสนองคำขอที่ผู้ใช้เริ่มขณะเพิ่มประสิทธิภาพการใช้งานเครือข่าย

จำกัดคำขอของผู้ใช้

คุณอาจไม่ต้องสนใจคำขอบางอย่างที่ผู้ใช้เริ่มหากไม่จำเป็น เช่น ท่าทางสัมผัสการปัดเพื่อรีเฟรชหลายครั้งในช่วงเวลาสั้นๆ เพื่อตรวจสอบข้อมูลใหม่ในขณะที่ข้อมูลปัจจุบันยังใหม่อยู่ การดําเนินการตามคําขอแต่ละรายการอาจสิ้นเปลืองพลังงานอย่างมากเนื่องจากทำให้วิทยุทำงานอยู่ตลอดเวลา วิธีมีประสิทธิภาพมากขึ้นคือการควบคุมคำขอที่ผู้ใช้เริ่มเพื่อให้ส่งคำขอได้เพียงรายการเดียวในช่วงเวลาหนึ่งๆ ซึ่งจะช่วยลดความถี่ในการใช้วิทยุ

ใช้แคช

การแคชข้อมูลของแอปเป็นการทําสําเนาข้อมูลในเครื่องที่แอปจําเป็นต้องใช้ จากนั้นแอปจะเข้าถึงสำเนาข้อมูลเดียวกันในเครื่องได้หลายครั้งโดยไม่ต้องเปิดการเชื่อมต่อเครือข่ายเพื่อส่งคำขอใหม่

คุณควรแคชข้อมูลให้มากที่สุดเท่าที่จะเป็นไปได้ ซึ่งรวมถึงทรัพยากรแบบคงที่และการดาวน์โหลดแบบออนดีมานด์ เช่น รูปภาพขนาดเต็ม คุณสามารถใช้ส่วนหัวแคช HTTP เพื่อให้แน่ใจว่ากลยุทธ์การแคชจะไม่ทําให้แอปแสดงข้อมูลที่ล้าสมัย ดูข้อมูลเพิ่มเติมเกี่ยวกับการแคชการตอบกลับของเครือข่ายได้ที่หัวข้อหลีกเลี่ยงการดาวน์โหลดซ้ำ

ใน Android 11 ขึ้นไป แอปของคุณจะใช้ชุดข้อมูลขนาดใหญ่เดียวกันกับที่แอปอื่นๆ ใช้สำหรับกรณีการใช้งานต่างๆ เช่น แมชชีนเลิร์นนิงและการเล่นสื่อ เมื่อแอปของคุณจำเป็นต้องเข้าถึงชุดข้อมูลที่แชร์ แอปจะตรวจสอบเวอร์ชันที่แคชไว้ก่อน แล้วจึงพยายามดาวน์โหลดสำเนาใหม่ ดูข้อมูลเพิ่มเติมเกี่ยวกับชุดข้อมูลที่แชร์ได้ที่เข้าถึงชุดข้อมูลที่แชร์

ใช้แบนด์วิดท์มากขึ้นเพื่อดาวน์โหลดข้อมูลมากขึ้นแต่ให้นานขึ้น

เมื่อเชื่อมต่อผ่านวิทยุไร้สาย โดยทั่วไปแล้วแบนด์วิดท์ที่สูงขึ้นจะมาพร้อมกับค่าใช้จ่ายแบตเตอรี่ที่สูงขึ้น ซึ่งหมายความว่า 5G มักจะใช้พลังงานมากกว่า LTE และทำให้แบตเตอรี่หมดเร็วกว่า 3G

ซึ่งหมายความว่าแม้ว่าสถานะวิทยุพื้นฐานจะแตกต่างกันไปตามเทคโนโลยีวิทยุ แต่โดยทั่วไปแล้ว ผลกระทบของแบตเตอรี่แบบสัมพัทธ์ของเวลาสิ้นสุดการเปลี่ยนแปลงสถานะจะมากกว่าสำหรับวิทยุที่มีแบนด์วิดท์สูงกว่า ดูข้อมูลเพิ่มเติมเกี่ยวกับเวลาที่เหลือได้ที่สถานะวิทยุ

ในขณะเดียวกัน แบนด์วิดท์ที่สูงขึ้นยังช่วยให้คุณทำการเตรียมความพร้อมล่วงหน้าได้มากขึ้น ซึ่งจะส่งผลให้ดาวน์โหลดข้อมูลได้มากขึ้นในช่วงเวลาเดียวกัน สิ่งหนึ่งที่อาจไม่ค่อยชัดเจนนักคือ เนื่องจากต้นทุนแบตเตอรี่ในช่วงท้ายค่อนข้างสูงกว่า การเปิดใช้งานวิทยุเป็นเวลานานขึ้นในช่วงเซสชันการโอนแต่ละครั้งจึงมีประสิทธิภาพมากกว่าเพื่อลดความถี่ในการอัปเดต

ตัวอย่างเช่น หากวิทยุ LTE มีแบนด์วิดท์เป็น 2 เท่าและต้นทุนพลังงานเป็น 2 เท่าของ 3G คุณควรดาวน์โหลดข้อมูลเป็น 4 เท่าในแต่ละเซสชัน หรืออาจมากถึง 10 MB เมื่อดาวน์โหลดข้อมูลจำนวนมากเช่นนี้ คุณควรคำนึงถึงผลของการโหลดล่วงหน้าที่มีต่อพื้นที่เก็บข้อมูลในเครื่องที่มีอยู่และล้างแคชการโหลดล่วงหน้าเป็นประจำ

คุณสามารถใช้ ConnectivityManager เพื่อลงทะเบียน Listener สําหรับเครือข่ายเริ่มต้น และ TelephonyManager เพื่อลงทะเบียน PhoneStateListener เพื่อระบุประเภทการเชื่อมต่ออุปกรณ์ปัจจุบัน เมื่อทราบประเภทการเชื่อมต่อแล้ว คุณก็แก้ไขกิจวัตรการอ่านล่วงหน้าได้ตามต้องการ ดังนี้

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 เพื่อทำงานตามกำหนดการที่มีประสิทธิภาพซึ่งพิจารณาว่าเป็นไปตามเงื่อนไขที่เฉพาะเจาะจงหรือไม่ เช่น ความพร้อมใช้งานของเครือข่ายและสถานะพลังงาน ตัวอย่างเช่น สมมติว่าคุณมีคลาสย่อย Worker ชื่อ DownloadHeadlinesWorker ซึ่งดึงข้อมูลบรรทัดแรกของข่าวล่าสุด คุณสามารถกำหนดเวลาให้ Handler นี้ทำงานทุกชั่วโมงได้ โดยมีเงื่อนไขว่าอุปกรณ์เชื่อมต่อกับเครือข่ายแบบไม่จำกัดปริมาณการใช้งานและแบตเตอรี่ของอุปกรณ์ไม่เหลือน้อย โดยมีกลยุทธ์การลองอีกครั้งที่กำหนดเองหากมีปัญหาในการดึงข้อมูล ดังที่แสดงด้านล่าง

Kotlin

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)

Java

Constraints constraints = new Constraints.Builder()
        .setRequiredNetworkType(NetworkType.UNMETERED)
        .setRequiresBatteryNotLow(true)
        .build();
WorkRequest request = new PeriodicWorkRequest.Builder(DownloadHeadlinesWorker.class, 1, TimeUnit.HOURS)
        .setBackoffCriteria(BackoffPolicy.LINEAR, 1L, TimeUnit.MINUTES)
        .build();
WorkManager.getInstance(this).enqueue(request);

นอกจาก WorkManager แล้ว แพลตฟอร์ม Android ยังมีเครื่องมืออื่นๆ อีกหลายรายการที่จะช่วยคุณสร้างกำหนดการที่มีประสิทธิภาพเพื่อทำงานด้านเครือข่ายให้เสร็จสิ้น เช่น การสำรวจ ดูข้อมูลเพิ่มเติมเกี่ยวกับการใช้เครื่องมือเหล่านี้ได้ที่คำแนะนำเกี่ยวกับการประมวลผลในเบื้องหลัง

เพิ่มประสิทธิภาพคําขอที่เริ่มโดยเซิร์ฟเวอร์

โดยปกติแล้ว คำขอที่เซิร์ฟเวอร์เป็นผู้เริ่มจะตอบสนองต่อการแจ้งเตือนจากเซิร์ฟเวอร์ เช่น แอปที่ใช้อ่านบทความข่าวล่าสุดอาจได้รับการแจ้งเตือนเกี่ยวกับบทความกลุ่มใหม่ซึ่งตรงกับค่ากําหนดการปรับให้เหมาะกับผู้ใช้ จากนั้นแอปจะดาวน์โหลดบทความเหล่านั้น

ส่งการอัปเดตเซิร์ฟเวอร์ด้วย Firebase Cloud Messaging

Firebase Cloud Messaging (FCM) เป็นกลไกที่เบามากซึ่งใช้ในการส่งข้อมูลจากเซิร์ฟเวอร์ไปยังอินสแตนซ์แอปที่เฉพาะเจาะจง เมื่อใช้ FCM เซิร์ฟเวอร์จะแจ้งให้แอปที่ทำงานในอุปกรณ์หนึ่งๆ ทราบว่ามีข้อมูลใหม่ให้ใช้งาน

เมื่อเทียบกับการโหวต ซึ่งแอปต้องส่งคําสั่ง ping เซิร์ฟเวอร์เป็นประจําเพื่อค้นหาข้อมูลใหม่ รูปแบบที่ทำงานตามเหตุการณ์นี้ช่วยให้แอปสร้างการเชื่อมต่อใหม่ได้ก็ต่อเมื่อรู้ว่ามีข้อมูลให้ดาวน์โหลดเท่านั้น โมเดลนี้จะลดการเชื่อมต่อที่ไม่จำเป็นและลดความล่าช้าเมื่ออัปเดตข้อมูลภายในแอป

FCM ติดตั้งใช้งานโดยใช้การเชื่อมต่อ TCP/IP แบบถาวร วิธีนี้ช่วยลดจำนวนการเชื่อมต่อแบบถาวรและช่วยให้แพลตฟอร์มเพิ่มประสิทธิภาพแบนด์วิดท์และลดผลกระทบที่อาจเกิดขึ้นกับอายุการใช้งานแบตเตอรี่