From 20a11fdad201dcf52fb4d0971feb73eec531233e Mon Sep 17 00:00:00 2001
From: Kshitij Gupta <kshitijgm@gmail.com>
Date: Sun, 14 Feb 2021 21:47:45 +0530
Subject: [PATCH] Updater: Add menu option to apply a local update package

Change-Id: Ida164a61920c54e007b023ebe8ef4f77f94855c2
---

diff --git a/AndroidManifest.xml b/AndroidManifest.xml
index 80ec87e..ccc0325 100644
--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@@ -1,4 +1,5 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
     package="com.statix.updater"
     android:versionCode="1">
 
@@ -10,7 +11,9 @@
     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
     <uses-permission android:name="android.permission.RECOVERY" />
     <uses-permission android:name="android.permission.WAKE_LOCK" />
-    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"
+        tools:ignore="ScopedStorage" />
 
     <application
         android:allowBackup="false"
diff --git a/res/drawable/ic_folder_close.xml b/res/drawable/ic_folder_close.xml
new file mode 100644
index 0000000..2b890b0
--- /dev/null
+++ b/res/drawable/ic_folder_close.xml
@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+  <path
+      android:fillColor="@color/theme_accent"
+      android:pathData="M10,4H4c-1.1,0 -1.99,0.9 -1.99,2L2,18c0,1.1 0.9,2 2,2h16c1.1,0 2,-0.9 2,-2V8c0,-1.1 -0.9,-2 -2,-2h-8l-2,-2z" />
+</vector>
diff --git a/res/layout/activity_updates.xml b/res/layout/activity_updates.xml
index d782064..a36ec51 100644
--- a/res/layout/activity_updates.xml
+++ b/res/layout/activity_updates.xml
@@ -19,15 +19,26 @@
 
     <ImageButton
         android:id="@+id/pref_btn"
-        android:layout_width="50dp"
-        android:layout_height="28dp"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
         android:layout_alignParentTop="true"
         android:layout_alignParentEnd="true"
-        android:layout_marginTop="20dp"
-        android:layout_marginEnd="5dp"
+        android:layout_marginTop="24dp"
+        android:layout_marginEnd="24dp"
         android:background="@android:color/transparent"
         app:srcCompat="@drawable/ic_settings" />
 
+    <ImageButton
+        android:id="@+id/menu_local_update"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_alignParentTop="true"
+        android:layout_marginTop="24dp"
+        android:layout_marginEnd="24dp"
+        android:layout_toStartOf="@+id/pref_btn"
+        android:background="@android:color/transparent"
+        app:srcCompat="@drawable/ic_folder_close" />
+
     <TextView
         android:id="@+id/textView"
         android:layout_width="wrap_content"
diff --git a/res/menu/menu_toolbar.xml b/res/menu/menu_toolbar.xml
index 0477670..f693f44 100644
--- a/res/menu/menu_toolbar.xml
+++ b/res/menu/menu_toolbar.xml
@@ -7,6 +7,11 @@
 <!--        android:title="@string/menu_refresh"-->
 <!--        app:showAsAction="ifRoom" />-->
     <item
+        android:id="@+id/menu_local_update"
+        android:title="@string/menu_local_update"
+        android:icon="@drawable/ic_folder_open"
+        app:showAsAction="always" />
+    <item
         android:id="@+id/menu_preferences"
         android:title="@string/menu_preferences"
         app:showAsAction="never" />
diff --git a/res/values/strings.xml b/res/values/strings.xml
index d9cbd1b..2bb1160 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -61,6 +61,7 @@
 
     <string name="menu_refresh">Refresh</string>
     <string name="menu_preferences">Preferences</string>
+    <string name="menu_local_update">Local update</string>
     <string name="menu_auto_updates_check">Auto updates check</string>
     <string name="menu_auto_updates_check_interval_daily">Once a day</string>
     <string name="menu_auto_updates_check_interval_weekly">Once a week</string>
diff --git a/src/com/statix/updater/UpdatesActivity.java b/src/com/statix/updater/UpdatesActivity.java
index 73d1618..3d78774 100644
--- a/src/com/statix/updater/UpdatesActivity.java
+++ b/src/com/statix/updater/UpdatesActivity.java
@@ -15,6 +15,7 @@
  */
 package com.statix.updater;
 
+import android.annotation.SuppressLint;
 import android.content.BroadcastReceiver;
 import android.content.ComponentName;
 import android.content.Context;
@@ -67,7 +68,10 @@
 import com.statix.updater.model.UpdateInfo;
 
 import java.io.File;
+import java.io.FileOutputStream;
 import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.UUID;
@@ -75,6 +79,7 @@
 public class UpdatesActivity extends UpdatesListActivity {
 
     private static final String TAG = "UpdatesActivity";
+    private static final int ACTIVITY_CHOOSE_FILE = 9999;
     private UpdaterService mUpdaterService;
     private BroadcastReceiver mBroadcastReceiver;
 
@@ -164,6 +169,7 @@
         return super.onCreateOptionsMenu(menu);
     }
 
+    @SuppressLint("NonConstantResourceId")
     @Override
     public boolean onOptionsItemSelected(MenuItem item) {
         switch (item.getItemId()) {
@@ -171,6 +177,10 @@
                 showPreferencesDialog();
                 return true;
             }
+            case R.id.menu_local_update: {
+                showLocalUpdateDialog();
+                return true;
+            }
         }
         return super.onOptionsItemSelected(item);
     }
@@ -325,7 +335,7 @@
         final SharedPreferences preferences =
                 PreferenceManager.getDefaultSharedPreferences(this);
         long lastCheck = preferences.getLong(Constants.PREF_LAST_UPDATE_CHECK, -1) / 1000;
-        String lastCheckString = getString(R.string.header_last_updates_check,
+        @SuppressLint("StringFormatMatches") String lastCheckString = getString(R.string.header_last_updates_check,
                 StringGenerator.getDateLocalized(this, DateFormat.LONG, lastCheck),
                 StringGenerator.getTimeLocalized(this, lastCheck));
         TextView headerLastCheck = (TextView) findViewById(R.id.header_last_check);
@@ -451,4 +461,67 @@
                 })
                 .show();
     }
+    private void showLocalUpdateDialog() {
+        Intent chooseFile;
+        Intent intent;
+        chooseFile = new Intent(Intent.ACTION_GET_CONTENT);
+        chooseFile.addCategory(Intent.CATEGORY_OPENABLE);
+        chooseFile.setType("*/*");
+        intent = Intent.createChooser(chooseFile, "Choose a file");
+        startActivityForResult(intent, ACTIVITY_CHOOSE_FILE);
+    }
+
+    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+        super.onActivityResult(requestCode, resultCode, data);
+        if (resultCode != RESULT_OK) return;
+        if (requestCode == ACTIVITY_CHOOSE_FILE) {
+            Uri uri = data.getData();
+            Utils.cleanupDownloadsDir(this);
+            File downloadPath = new File(Utils.getDownloadPath(this), "update.zip");
+            boolean fileCopySuccess = false;
+            try {
+                copy(uri, downloadPath);
+                fileCopySuccess = true;
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            if (fileCopySuccess) {
+                UpdateInfo update = Utils.updateInfoFromFileForced(downloadPath);
+                mUpdaterService.getUpdaterController().addUpdate(update);
+                mUpdaterService.getUpdaterController().onUpdateDownloaded(update.getDownloadId());
+            }
+        }
+    }
+
+    private void startInstallIfLocalUpdate(String downloadId) {
+        UpdateInfo update = UpdaterController.getInstance().getUpdate(downloadId);
+        if (update.getType().equals("local_update")) {
+            final boolean canInstall = Utils.canInstall(update);
+            if (canInstall) {
+                Utils.getInstallDialog(update.getDownloadId(), this).show();
+            } else {
+                showSnackbar(R.string.snack_update_not_installable,
+                        Snackbar.LENGTH_LONG);
+            }
+        }
+    }
+
+    private void copy(Uri src, File dst) throws IOException {
+        InputStream in = this.getContentResolver().openInputStream(src);
+        try {
+            OutputStream out = new FileOutputStream(dst);
+            try {
+                // Transfer bytes from in to out
+                byte[] buf = new byte[1024];
+                int len;
+                while ((len = in.read(buf)) > 0) {
+                    out.write(buf, 0, len);
+                }
+            } finally {
+                out.close();
+            }
+        } finally {
+            in.close();
+        }
+    }
 }
diff --git a/src/com/statix/updater/UpdatesListAdapter.java b/src/com/statix/updater/UpdatesListAdapter.java
index 67d43cf..06ccdbe 100644
--- a/src/com/statix/updater/UpdatesListAdapter.java
+++ b/src/com/statix/updater/UpdatesListAdapter.java
@@ -15,6 +15,7 @@
  */
 package com.statix.updater;
 
+import android.annotation.SuppressLint;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
@@ -63,10 +64,6 @@
 
     private static final String TAG = "UpdateListAdapter";
 
-    private static final int BATTERY_PLUGGED_ANY = BatteryManager.BATTERY_PLUGGED_AC
-            | BatteryManager.BATTERY_PLUGGED_USB
-            | BatteryManager.BATTERY_PLUGGED_WIRELESS;
-
     private final float mAlphaDisabledValue;
 
     private List<String> mDownloadIds;
@@ -368,7 +365,7 @@
                 final boolean canInstall = Utils.canInstall(update);
                 clickListener = enabled ? view -> {
                     if (canInstall) {
-                        getInstallDialog(downloadId).show();
+                        Utils.getInstallDialog(downloadId, mActivity).show();
                     } else {
                         mActivity.showSnackbar(R.string.snack_update_not_installable,
                                 Snackbar.LENGTH_LONG);
@@ -436,43 +433,6 @@
         };
     }
 
-    private AlertDialog.Builder getInstallDialog(final String downloadId) {
-        if (!isBatteryLevelOk()) {
-            Resources resources = mActivity.getResources();
-            String message = resources.getString(R.string.dialog_battery_low_message_pct,
-                    resources.getInteger(R.integer.battery_ok_percentage_discharging),
-                    resources.getInteger(R.integer.battery_ok_percentage_charging));
-        return new AlertDialog.Builder(mActivity, R.style.AlertDialogTheme)
-                    .setTitle(R.string.dialog_battery_low_title)
-                    .setMessage(message)
-                    .setPositiveButton(android.R.string.ok, null);
-        }
-        UpdateInfo update = mUpdaterController.getUpdate(downloadId);
-        int resId;
-        try {
-            if (Utils.isABUpdate(update.getFile())) {
-                resId = R.string.apply_update_dialog_message_ab;
-            } else {
-                resId = R.string.apply_update_dialog_message;
-            }
-        } catch (IOException e) {
-            Log.e(TAG, "Could not determine the type of the update");
-            return null;
-        }
-
-        String buildDate = StringGenerator.getDateLocalizedUTC(mActivity,
-                DateFormat.MEDIUM, update.getTimestamp());
-        String buildInfoText = mActivity.getString(R.string.list_build_version_date,
-                BuildInfoUtils.getBuildVersion(), buildDate);
-        return new AlertDialog.Builder(mActivity, R.style.AlertDialogTheme)
-                .setTitle(R.string.apply_update_dialog_title)
-                .setMessage(mActivity.getString(resId, buildInfoText,
-                        mActivity.getString(android.R.string.ok)))
-                .setPositiveButton(android.R.string.ok,
-                        (dialog, which) -> Utils.triggerUpdate(mActivity, downloadId))
-                .setNegativeButton(android.R.string.cancel, null);
-    }
-
     private AlertDialog.Builder getCancelInstallationDialog() {
         return new AlertDialog.Builder(mActivity, R.style.AlertDialogTheme)
                 .setMessage(R.string.cancel_installation_dialog_message)
@@ -485,6 +445,7 @@
                 .setNegativeButton(android.R.string.cancel, null);
     }
 
+    @SuppressLint("RestrictedApi")
     private void startActionMode(final UpdateInfo update, final boolean canDelete, View anchor) {
         mSelectedDownload = update.getDownloadId();
         notifyItemChanged(update.getDownloadId());
@@ -518,18 +479,16 @@
         helper.show();
     }
 
-    private boolean isBatteryLevelOk() {
-        Intent intent = mActivity.registerReceiver(null,
-                new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
-        if (!intent.getBooleanExtra(BatteryManager.EXTRA_PRESENT, false)) {
-            return true;
+    private void exportUpdate(UpdateInfo update) {
+        File dest = new File(Utils.getExportPath(mActivity), update.getName());
+        if (dest.exists()) {
+            dest = Utils.appendSequentialNumber(dest);
         }
-        int percent = Math.round(100.f * intent.getIntExtra(BatteryManager.EXTRA_LEVEL, 100) /
-                intent.getIntExtra(BatteryManager.EXTRA_SCALE, 100));
-        int plugged = intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, 0);
-        int required = (plugged & BATTERY_PLUGGED_ANY) != 0 ?
-                mActivity.getResources().getInteger(R.integer.battery_ok_percentage_charging) :
-                mActivity.getResources().getInteger(R.integer.battery_ok_percentage_discharging);
-        return percent >= required;
+        Intent intent = new Intent(mActivity, ExportUpdateService.class);
+        intent.setAction(ExportUpdateService.ACTION_START_EXPORTING);
+        intent.putExtra(ExportUpdateService.EXTRA_SOURCE_FILE, update.getFile());
+        intent.putExtra(ExportUpdateService.EXTRA_DEST_FILE, dest);
+        mActivity.startService(intent);
     }
+
 }
diff --git a/src/com/statix/updater/controller/UpdaterController.java b/src/com/statix/updater/controller/UpdaterController.java
index 905b5e6..846ea71 100644
--- a/src/com/statix/updater/controller/UpdaterController.java
+++ b/src/com/statix/updater/controller/UpdaterController.java
@@ -15,6 +15,7 @@
  */
 package com.statix.updater.controller;
 
+import android.annotation.SuppressLint;
 import android.content.Context;
 import android.content.Intent;
 import android.database.sqlite.SQLiteDatabase;
@@ -76,6 +77,7 @@
         return sUpdaterController;
     }
 
+    @SuppressLint("InvalidWakeLockTag")
     private UpdaterController(Context context) {
         mBroadcastManager = LocalBroadcastManager.getInstance(context);
         mUpdatesDbHelper = new UpdatesDbHelper(context);
@@ -186,12 +188,7 @@
             @Override
             public void onSuccess(File destination) {
                 Log.d(TAG, "Download complete");
-                Update update = mDownloads.get(downloadId).mUpdate;
-                update.setStatus(UpdateStatus.VERIFYING);
-                removeDownloadClient(mDownloads.get(downloadId));
-                verifyUpdateAsync(downloadId);
-                notifyUpdateChange(downloadId);
-                tryReleaseWakelock();
+                onUpdateDownloaded(downloadId);
             }
 
             @Override
@@ -211,6 +208,15 @@
         };
     }
 
+    public void onUpdateDownloaded(String downloadId) {
+        Update update = mDownloads.get(downloadId).mUpdate;
+        update.setStatus(UpdateStatus.VERIFYING);
+        removeDownloadClient(mDownloads.get(downloadId));
+        verifyUpdateAsync(downloadId);
+        notifyUpdateChange(downloadId);
+        tryReleaseWakelock();
+    }
+
     private DownloadClient.ProgressListener getProgressListener(final String downloadId) {
         return new DownloadClient.ProgressListener() {
             private long mLastUpdate = 0;
diff --git a/src/com/statix/updater/misc/Utils.java b/src/com/statix/updater/misc/Utils.java
index b92c866..f58f7fa 100644
--- a/src/com/statix/updater/misc/Utils.java
+++ b/src/com/statix/updater/misc/Utils.java
@@ -15,15 +15,19 @@
  */
 package com.statix.updater.misc;
 
+import android.app.Activity;
 import android.app.AlarmManager;
 import android.content.ClipData;
 import android.content.ClipboardManager;
 import android.content.Context;
 import android.content.Intent;
+import android.content.IntentFilter;
 import android.content.SharedPreferences;
 import android.content.pm.PackageManager;
+import android.content.res.Resources;
 import android.net.ConnectivityManager;
 import android.net.NetworkInfo;
+import android.os.BatteryManager;
 import android.os.Environment;
 import android.os.SystemProperties;
 import android.os.storage.StorageManager;
@@ -31,11 +35,14 @@
 import android.util.Log;
 import android.widget.Toast;
 
+import androidx.appcompat.app.AlertDialog;
+
 import org.json.JSONArray;
 import org.json.JSONException;
 import org.json.JSONObject;
 import com.statix.updater.R;
 import com.statix.updater.UpdatesDbHelper;
+import com.statix.updater.controller.UpdaterController;
 import com.statix.updater.controller.UpdaterService;
 import com.statix.updater.model.Update;
 import com.statix.updater.model.UpdateBaseInfo;
@@ -45,11 +52,14 @@
 import java.io.File;
 import java.io.FileReader;
 import java.io.IOException;
+import java.nio.file.Files;
+import java.text.DateFormat;
 import java.util.ArrayList;
 import java.util.Enumeration;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Locale;
+import java.util.Random;
 import java.util.Set;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipFile;
@@ -58,8 +68,11 @@
 
     private static final String TAG = "Utils";
 
-    private Utils() {
-    }
+    private Utils() {}
+
+    public static final int BATTERY_PLUGGED_ANY = BatteryManager.BATTERY_PLUGGED_AC
+            | BatteryManager.BATTERY_PLUGGED_USB
+            | BatteryManager.BATTERY_PLUGGED_WIRELESS;
 
     public static File getDownloadPath(Context context) {
         return new File(context.getString(R.string.download_path));
@@ -381,4 +394,84 @@
     public static boolean isRecoveryUpdateExecPresent() {
         return new File(Constants.UPDATE_RECOVERY_EXEC).exists();
     }
+
+
+    public static AlertDialog.Builder getInstallDialog(final String downloadId, Activity activity) {
+        if (!isBatteryLevelOk(activity)) {
+            Resources resources = activity.getResources();
+            String message = resources.getString(R.string.dialog_battery_low_message_pct,
+                    resources.getInteger(R.integer.battery_ok_percentage_discharging),
+                    resources.getInteger(R.integer.battery_ok_percentage_charging));
+            return new AlertDialog.Builder(activity)
+                    .setTitle(R.string.dialog_battery_low_title)
+                    .setMessage(message)
+                    .setPositiveButton(android.R.string.ok, null);
+        }
+        UpdateInfo update = UpdaterController.getInstance().getUpdate(downloadId);
+        int resId;
+        try {
+            if (Utils.isABUpdate(update.getFile())) {
+                resId = R.string.apply_update_dialog_message_ab;
+            } else {
+                resId = R.string.apply_update_dialog_message;
+            }
+        } catch (IOException e) {
+            Log.e(TAG, "Could not determine the type of the update");
+            return null;
+        }
+
+        String buildDate = StringGenerator.getDateLocalizedUTC(activity,
+                DateFormat.MEDIUM, update.getTimestamp());
+        String buildInfoText = activity.getString(R.string.list_build_version_date,
+                BuildInfoUtils.getBuildVersion(), buildDate);
+        return new AlertDialog.Builder(activity)
+                .setTitle(R.string.apply_update_dialog_title)
+                .setMessage(activity.getString(resId, buildInfoText,
+                        activity.getString(android.R.string.ok)))
+                .setPositiveButton(android.R.string.ok,
+                        (dialog, which) -> Utils.triggerUpdate(activity, downloadId))
+                .setNegativeButton(android.R.string.cancel, null);
+    }
+
+    private static boolean isBatteryLevelOk(Activity activity) {
+        Intent intent = activity.registerReceiver(null,
+                new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
+        if (!intent.getBooleanExtra(BatteryManager.EXTRA_PRESENT, false)) {
+            return true;
+        }
+        int percent = Math.round(100.f * intent.getIntExtra(BatteryManager.EXTRA_LEVEL, 100) /
+                intent.getIntExtra(BatteryManager.EXTRA_SCALE, 100));
+        int plugged = intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, 0);
+        int required = (plugged & BATTERY_PLUGGED_ANY) != 0 ?
+                activity.getResources().getInteger(R.integer.battery_ok_percentage_charging) :
+                activity.getResources().getInteger(R.integer.battery_ok_percentage_discharging);
+        return percent >= required;
+    }
+
+    public static UpdateInfo updateInfoFromFileForced(File f) {
+        Update update = new Update();
+        update.setTimestamp(System.currentTimeMillis());
+        update.setName(f.getName());
+        update.setFile(f);
+        update.setDownloadId(getRandomHexString(32));
+        update.setType("local_update");
+        try {
+            update.setFileSize(Files.size(f.toPath()));
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        update.setDownloadUrl("manual");
+        update.setVersion("manual");
+        return update;
+    }
+
+    private static String getRandomHexString(int numchars){
+        Random r = new Random();
+        StringBuffer sb = new StringBuffer();
+        while(sb.length() < numchars){
+            sb.append(Integer.toHexString(r.nextInt()));
+        }
+
+        return sb.toString().substring(0, numchars);
+    }
 }
