Add Update settings screen for NewPipe Material

Author: wizdom13

app/src/main/java/org/schabi/newpipe/MainActivity.java

@@ -216,7 +216,7 @@ protected void onPostCreate(final Bundle savedInstanceState) {
 
         final App app = App.getInstance();
 
-        if (sharedPreferences.getBoolean(app.getString(R.string.update_app_key), false)
+        if (sharedPreferences.getBoolean(app.getString(R.string.update_app_key), true)
                 && sharedPreferences
                 .getBoolean(app.getString(R.string.update_check_consent_key), false)) {
             // Start the worker which is checking all conditions

app/src/main/java/org/schabi/newpipe/NewVersionWorker.kt

@@ -3,60 +3,48 @@ package org.schabi.newpipe
 import android.content.Context
 import android.content.Intent
 import android.util.Log
-import android.widget.Toast
 import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
 import androidx.core.app.PendingIntentCompat
-import androidx.core.content.ContextCompat
 import androidx.core.content.edit
 import androidx.core.net.toUri
 import androidx.preference.PreferenceManager
+import androidx.work.Data
 import androidx.work.OneTimeWorkRequestBuilder
 import androidx.work.WorkManager
 import androidx.work.Worker
 import androidx.work.WorkerParameters
 import androidx.work.workDataOf
-import com.grack.nanojson.JsonParser
-import com.grack.nanojson.JsonParserException
 import java.io.IOException
-import org.schabi.newpipe.extractor.downloader.Response
+import java.util.UUID
 import org.schabi.newpipe.extractor.exceptions.ReCaptchaException
+import org.schabi.newpipe.update.NewPipeMaterialUpdateRepository
+import org.schabi.newpipe.update.NewPipeMaterialUpdateRepository.VersionComparison
 import org.schabi.newpipe.util.ReleaseVersionUtil
 
 class NewVersionWorker(
     context: Context,
     workerParams: WorkerParameters
 ) : Worker(context, workerParams) {
 
-    /**
-     * Method to compare the current and latest available app version.
-     * If a newer version is available, we show the update notification.
-     *
-     * @param versionName    Name of new version
-     * @param apkLocationUrl Url with the new apk
-     * @param versionCode    Code of new version
-     */
-    private fun compareAppVersionAndShowNotification(
-        versionName: String,
-        apkLocationUrl: String?,
-        versionCode: Int
-    ) {
-        if (BuildConfig.VERSION_CODE >= versionCode) {
-            if (inputData.getBoolean(IS_MANUAL, false)) {
-                // Show toast stating that the app is up-to-date if the update check was manual.
-                ContextCompat.getMainExecutor(applicationContext).execute {
-                    Toast.makeText(
-                        applicationContext,
-                        R.string.app_update_unavailable_toast,
-                        Toast.LENGTH_SHORT
-                    ).show()
-                }
-            }
-            return
+    private data class UpdateCheckResult(
+        val release: NewPipeMaterialUpdateRepository.Release,
+        val installedVersion: String,
+        val comparison: VersionComparison
+    )
+
+    private fun handleUpdateCheckResult(result: UpdateCheckResult, isManual: Boolean) {
+        if (!isManual && result.comparison == VersionComparison.NEWER) {
+            showUpdateNotification(result.release, result.installedVersion)
         }
+    }
 
-        // A pending intent to open the apk location url in the browser.
-        val intent = Intent(Intent.ACTION_VIEW, apkLocationUrl?.toUri())
+    private fun showUpdateNotification(
+        release: NewPipeMaterialUpdateRepository.Release,
+        installedVersion: String
+    ) {
+        val releaseUrl = release.htmlUrl.ifBlank { NewPipeMaterialUpdateRepository.RELEASES_URL }
+        val intent = Intent(Intent.ACTION_VIEW, releaseUrl.toUri())
         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
         val pendingIntent = PendingIntentCompat.getActivity(
             applicationContext,
@@ -76,8 +64,9 @@ class NewVersionWorker(
             )
             .setContentText(
                 applicationContext.getString(
-                    R.string.app_update_available_notification_text,
-                    versionName
+                    R.string.app_update_available_notification_text_material,
+                    release.version,
+                    installedVersion
                 )
             )
 
@@ -88,99 +77,106 @@ class NewVersionWorker(
     }
 
     @Throws(IOException::class, ReCaptchaException::class)
-    private fun checkNewVersion() {
-        // Check if the current apk is a github one or not.
-        if (!ReleaseVersionUtil.isReleaseApk) {
-            return
-        }
+    private fun checkNewVersion(): UpdateCheckResult? {
+        val isManual = inputData.getBoolean(IS_MANUAL, false)
+        val prefs = PreferenceManager.getDefaultSharedPreferences(applicationContext)
 
-        if (!inputData.getBoolean(IS_MANUAL, false)) {
-            val prefs = PreferenceManager.getDefaultSharedPreferences(applicationContext)
-            // Check if the last request has happened a certain time ago
-            // to reduce the number of API requests.
+        if (!isManual) {
             val expiry = prefs.getLong(applicationContext.getString(R.string.update_expiry_key), 0)
             if (!ReleaseVersionUtil.isLastUpdateCheckExpired(expiry)) {
-                return
+                return null
             }
         }
 
-        // Make a network request to get latest NewPipe data.
-        val response = DownloaderImpl.getInstance().get(NEWPIPE_API_URL)
-        handleResponse(response)
-    }
+        val releases = NewPipeMaterialUpdateRepository.fetchReleases()
+        val release = NewPipeMaterialUpdateRepository.selectLatestCandidateRelease(releases)
 
-    private fun handleResponse(response: Response) {
-        val prefs = PreferenceManager.getDefaultSharedPreferences(applicationContext)
-        try {
-            // Store a timestamp which needs to be exceeded,
-            // before a new request to the API is made.
-            val newExpiry = ReleaseVersionUtil.coerceUpdateCheckExpiry(response.getHeader("expires"))
-            prefs.edit {
-                putLong(applicationContext.getString(R.string.update_expiry_key), newExpiry)
-            }
-        } catch (e: Exception) {
-            if (DEBUG) {
-                Log.w(TAG, "Could not extract and save new expiry date", e)
-            }
+        val newExpiry = ReleaseVersionUtil.coerceUpdateCheckExpiry(null)
+        prefs.edit {
+            putLong(applicationContext.getString(R.string.update_expiry_key), newExpiry)
+            putLong(
+                applicationContext.getString(R.string.latest_update_check_timestamp_key),
+                System.currentTimeMillis()
+            )
         }
 
-        // Parse the json from the response.
-        try {
-            val newpipeVersionInfo = JsonParser.`object`()
-                .from(response.responseBody()).getObject("flavors")
-                .getObject("newpipe")
-
-            val versionName = newpipeVersionInfo.getString("version")
-            val versionCode = newpipeVersionInfo.getInt("version_code")
-            val apkLocationUrl = newpipeVersionInfo.getString("apk")
-            compareAppVersionAndShowNotification(versionName, apkLocationUrl, versionCode)
-        } catch (e: JsonParserException) {
-            // Most likely something is wrong in data received from NEWPIPE_API_URL.
-            // Do not alarm user and fail silently.
-            if (DEBUG) {
-                Log.w(TAG, "Could not get NewPipe API: invalid json", e)
-            }
+        release ?: return null
+        val installedVersion = NewPipeMaterialUpdateRepository.installedVersionName()
+        val comparison = NewPipeMaterialUpdateRepository.compareInstalledToLatest(
+            installedVersion,
+            release.version
+        )
+
+        prefs.edit {
+            putString(
+                applicationContext.getString(R.string.latest_available_version_value_key),
+                release.version
+            )
+            putString(
+                applicationContext.getString(R.string.latest_available_release_url_key),
+                release.htmlUrl
+            )
+            putString(
+                applicationContext.getString(R.string.latest_available_changelog_key),
+                release.body
+            )
+        }
+
+        return UpdateCheckResult(release, installedVersion, comparison).also {
+            handleUpdateCheckResult(it, isManual)
         }
     }
 
     override fun doWork(): Result {
+        val isManual = inputData.getBoolean(IS_MANUAL, false)
         return try {
-            checkNewVersion()
-            Result.success()
+            val result = checkNewVersion()
+            if (isManual && result == null) {
+                Result.failure()
+            } else {
+                Result.success(result?.toOutputData() ?: Data.EMPTY)
+            }
         } catch (e: IOException) {
-            Log.w(TAG, "Could not fetch NewPipe API: probably network problem", e)
+            Log.w(TAG, "Could not fetch NewPipe Material GitHub releases: probably network problem", e)
             Result.failure()
         } catch (e: ReCaptchaException) {
             Log.e(TAG, "ReCaptchaException should never happen here.", e)
             Result.failure()
+        } catch (e: Exception) {
+            Log.w(TAG, "Could not check NewPipe Material GitHub releases", e)
+            Result.failure()
         }
     }
 
+    private fun UpdateCheckResult.toOutputData(): Data {
+        return workDataOf(
+            OUTPUT_COMPARISON to comparison.name,
+            OUTPUT_LATEST_VERSION to release.version,
+            OUTPUT_INSTALLED_VERSION to installedVersion,
+            OUTPUT_RELEASE_URL to release.htmlUrl
+        )
+    }
+
     companion object {
-        private val DEBUG = MainActivity.DEBUG
         private val TAG = NewVersionWorker::class.java.simpleName
-        private const val NEWPIPE_API_URL = "https://newpipe.net/api/data.json"
         private const val IS_MANUAL = "isManual"
+        const val OUTPUT_COMPARISON = "comparison"
+        const val OUTPUT_LATEST_VERSION = "latestVersion"
+        const val OUTPUT_INSTALLED_VERSION = "installedVersion"
+        const val OUTPUT_RELEASE_URL = "releaseUrl"
 
         /**
-         * Start a new worker which checks if all conditions for performing a version check are met,
-         * fetches the API endpoint [.NEWPIPE_API_URL] containing info about the latest NewPipe
-         * version and displays a notification about an available update if one is available.
-         * <br></br>
-         * Following conditions need to be met, before data is requested from the server:
-         *
-         *  *  The app is signed with the correct signing key (by TeamNewPipe / schabi).
-         * If the signing key differs from the one used upstream, the update cannot be installed.
-         *  * The user enabled searching for and notifying about updates in the settings.
-         *  * The app did not recently check for updates.
-         * We do not want to make unnecessary connections and DOS our servers.
+         * Start a worker which checks GitHub Releases for NewPipe Material updates.
+         * Manual checks bypass the stored expiry timestamp, while automatic checks respect it
+         * to avoid contacting GitHub on every app launch.
          */
         @JvmStatic
-        fun enqueueNewVersionCheckingWork(context: Context, isManual: Boolean) {
+        fun enqueueNewVersionCheckingWork(context: Context, isManual: Boolean): UUID {
             val workRequest = OneTimeWorkRequestBuilder<NewVersionWorker>()
                 .setInputData(workDataOf(IS_MANUAL to isManual))
                 .build()
             WorkManager.getInstance(context).enqueue(workRequest)
+            return workRequest.id
         }
     }
 }

app/src/main/java/org/schabi/newpipe/settings/MainSettingsFragment.java

@@ -9,7 +9,6 @@
 
 import org.schabi.newpipe.MainActivity;
 import org.schabi.newpipe.R;
-import org.schabi.newpipe.util.ReleaseVersionUtil;
 
 public class MainSettingsFragment extends BasePreferenceFragment {
     public static final boolean DEBUG = MainActivity.DEBUG;
@@ -22,14 +21,6 @@ public void onCreatePreferences(final Bundle savedInstanceState, final String ro
 
         setHasOptionsMenu(true); // Otherwise onCreateOptionsMenu is not called
 
-        // Check if the app is updatable
-        if (!ReleaseVersionUtil.INSTANCE.isReleaseApk()) {
-            getPreferenceScreen().removePreference(
-                    requirePreference(R.string.update_pref_screen_key));
-
-            defaultPreferences.edit().putBoolean(getString(R.string.update_app_key), false).apply();
-        }
-
         // Hide debug preferences in RELEASE build variant
         if (!DEBUG) {
             getPreferenceScreen().removePreference(