Updater: Simplify activity status for cnstate monitor (0f47e5a6) · Commits · e / os / android_packages_apps_Updater

src/org/lineageos/updater/UpdatesCheckReceiver.java

+36 −8

Original line number	Diff line number	Diff line
		@@ -23,6 +23,9 @@ import android.content.BroadcastReceiver;
		import android.content.Context;
		import android.content.Intent;
		import android.content.SharedPreferences;
		import android.net.ConnectivityManager;
		import android.net.NetworkCapabilities;
		import android.net.NetworkRequest;
		import android.os.SystemClock;
		import android.util.Log;

		@@ -30,6 +33,7 @@ import androidx.core.app.NotificationCompat;
		import androidx.preference.PreferenceManager;

		import org.json.JSONException;
		import org.lineageos.updater.controller.UpdaterService;
		import org.lineageos.updater.download.DownloadClient;
		import org.lineageos.updater.misc.ConnectionStateMonitor;
		import org.lineageos.updater.misc.Constants;
		@@ -50,14 +54,19 @@ public class UpdatesCheckReceiver extends BroadcastReceiver {
		private static final String NEW_UPDATES_NOTIFICATION_CHANNEL =
		"new_updates_notification_channel";

		private final NetworkRequest networkRequest = new NetworkRequest.Builder()
		.addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR)
		.addTransportType(NetworkCapabilities.TRANSPORT_ETHERNET)
		.addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
		.build();

		private ConnectivityManager.NetworkCallback cnState;
		private ConnectivityManager connectivityManager;

		@Override
		public void onReceive(final Context context, Intent intent) {
		final ConnectionStateMonitor cnState =
		new ConnectionStateMonitor(context);

		if (Intent.ACTION_BOOT_COMPLETED.equals(intent.getAction())) {
		Utils.cleanupDownloadsDir(context);
		cnState.setNetworkCallbackActive(false);
		}

		final SharedPreferences preferences =
		@@ -71,13 +80,17 @@ public class UpdatesCheckReceiver extends BroadcastReceiver {
		// work like repeating alarms. To check for update at the exact time.
		updateRepeatingUpdatesCheck(context);

		cnState = new ConnectionStateMonitor().getInstance(context);
		connectivityManager = (ConnectivityManager)
		context.getSystemService(Context.CONNECTIVITY_SERVICE);

		if (!Utils.isNetworkAvailable(context)) {
		if (!cnState.isNetworkCallbackActive()) {
		cnState.setupNetworkCallback(true);
		if (!UpdaterService.isNetworkCallBackActive()) {
		setupNetworkCallback(true);
		}
		return;
		} else if (cnState.isNetworkCallbackActive()) {
		cnState.setupNetworkCallback(false);
		} else if (UpdaterService.isNetworkCallBackActive()) {
		setupNetworkCallback(false);
		}

		final File json = Utils.getCachedUpdateList(context);
		@@ -129,6 +142,21 @@ public class UpdatesCheckReceiver extends BroadcastReceiver {
		}
		}

		public void setupNetworkCallback(boolean shouldEnable) {
		if (shouldEnable) {
		connectivityManager.registerNetworkCallback(networkRequest, cnState);
		} else {
		try {
		connectivityManager.unregisterNetworkCallback(cnState);
		} catch (IllegalArgumentException e) {
		Log.e(TAG, "Network callback was not registered");
		}
		}

		UpdaterService.setNetworkCallBackActive(shouldEnable);
		Log.d(TAG, "Network callback enabled: " + shouldEnable);
		}

		private static void showNotification(Context context) {
		NotificationManager notificationManager = context.getSystemService(
		NotificationManager.class);

src/org/lineageos/updater/controller/UpdaterService.java

+8 −3

Original line number	Diff line number	Diff line
		@@ -42,7 +42,6 @@ import org.lineageos.updater.R;
		import org.lineageos.updater.UpdaterReceiver;
		import org.lineageos.updater.UpdatesActivity;
		import org.lineageos.updater.misc.BuildInfoUtils;
		import org.lineageos.updater.misc.ConnectionStateMonitor;
		import org.lineageos.updater.misc.Constants;
		import org.lineageos.updater.misc.StringGenerator;
		import org.lineageos.updater.misc.Utils;
		@@ -75,6 +74,7 @@ public class UpdaterService extends Service {
		private static final int NOTIFICATION_ID = 10;

		private final IBinder mBinder = new LocalBinder();
		private static boolean isNetworkCallBackActive = false;
		private boolean mHasClients;

		private BroadcastReceiver mBroadcastReceiver;
		@@ -249,9 +249,8 @@ public class UpdaterService extends Service {
		}

		private void tryStopSelf() {
		ConnectionStateMonitor cnState = new ConnectionStateMonitor(this);
		if (!mHasClients && !mUpdaterController.hasActiveDownloads() &&
		!mUpdaterController.isInstallingUpdate() && !cnState.isNetworkCallbackActive()) {
		!mUpdaterController.isInstallingUpdate() && !isNetworkCallBackActive()) {
		Log.d(TAG, "Service no longer needed, stopping");
		stopSelf();
		}
		@@ -475,6 +474,12 @@ public class UpdaterService extends Service {
		}
		}

		public static void setNetworkCallBackActive(boolean isActive) {
		isNetworkCallBackActive = isActive;
		}

		public static boolean isNetworkCallBackActive() { return isNetworkCallBackActive; }

		private void handleDownloadProgressChange(UpdateInfo update) {
		int progress = update.getProgress();
		mNotificationBuilder.setProgress(100, progress, false);

src/org/lineageos/updater/misc/ConnectionStateMonitor.kt

+35 −54

Original line number	Diff line number	Diff line
		@@ -17,62 +17,47 @@ package org.lineageos.updater.misc

		import android.content.Context
		import android.content.Intent
		import android.content.SharedPreferences
		import android.net.ConnectivityManager
		import android.net.Network
		import android.net.NetworkCapabilities
		import android.net.NetworkRequest
		import android.os.Handler
		import android.os.Looper
		import android.util.Log
		import androidx.preference.PreferenceManager

		import org.lineageos.updater.UpdatesCheckReceiver

		class ConnectionStateMonitor(private val mContext: Context) : ConnectivityManager.NetworkCallback() {
		private val networkRequest: NetworkRequest = NetworkRequest.Builder()
		.addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR)
		.addTransportType(NetworkCapabilities.TRANSPORT_ETHERNET)
		.addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
		.build()
		private val pref: SharedPreferences = PreferenceManager.getDefaultSharedPreferences(mContext)

		fun isNetworkCallbackActive(): Boolean {
		return pref.getBoolean(Constants.PREF_NETWORK_CALLBACK_ACTIVE, false)
		class ConnectionStateMonitor {
		companion object {
		private var instance: ConnectivityManager.NetworkCallback? = null
		}

		fun setNetworkCallbackActive(shouldEnable: Boolean) {
		pref.edit().putBoolean(Constants.PREF_NETWORK_CALLBACK_ACTIVE, shouldEnable).apply()
		fun getInstance(context: Context): ConnectivityManager.NetworkCallback {
		if (instance == null) {
		instance = networkCallback(context)
		}

		fun setupNetworkCallback(shouldEnable: Boolean) {
		val connectivityManager: ConnectivityManager =
		mContext.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager

		if (shouldEnable) {
		connectivityManager.registerNetworkCallback(networkRequest, this)
		} else {
		try {
		connectivityManager.unregisterNetworkCallback(this)
		} catch (e: IllegalArgumentException) {
		Log.e(tag, "Network callback was not registered")
		}
		return instance!!
		}

		setNetworkCallbackActive(shouldEnable)
		Log.d(tag, "Network callback enabled: $shouldEnable")
		}
		/**
		* API callbacks to determine which status we currently in
		* we need the below callbacks:
		* - onAvailable: device connected to a network of course
		* - onLost: when the connection completely lost
		*/
		fun networkCallback(context: Context) = object: ConnectivityManager.NetworkCallback() {
		private val tag = "ConnectionStateMonitor"
		private val delayExecute = 10000L // 10 seconds

		private fun startUpdatesCheckReceiver(): Runnable = Runnable {
		val broadcastIntent = Intent()
		broadcastIntent.setClassName(mContext, UpdatesCheckReceiver::class.java.name)
		mContext.sendBroadcast(broadcastIntent)
		broadcastIntent.setClassName(context, UpdatesCheckReceiver::class.java.name)
		context.sendBroadcast(broadcastIntent)
		}

		private fun checkForUpdates() {
		// Delay because some phones takes time go online
		Handler(Looper.getMainLooper()).postDelayed(
		startUpdatesCheckReceiver(), delayExecute)
		startUpdatesCheckReceiver(), delayExecute
		)
		}

		override fun onAvailable(network: Network) {
		@@ -84,9 +69,5 @@ class ConnectionStateMonitor(private val mContext: Context) : ConnectivityManage
		Log.d(tag, "Network not available")
		checkForUpdates()
		}

		companion object {
		private const val tag = "ConnectionStateMonitor"
		private const val delayExecute = 10000L // 10 seconds
		}
		}