Feat/notify on new version (#78)

* recieved broadcast in java file

* notifed outside app and completed update process from local signed 1.0.8 to online 1.0.9.1

* refactor: better naming and clear update watcher

* working scheduler

* production back to 7 days

* refactor: moved reuasable methods and provided release notes- worked when tested with ConnectivityReceiver

* don't fetch release notes twice

* revert: open fix in new pr

* feat: enhance notification eligibility checks and handle posting failures

* remove tests

* fix: right way to check for permission

Author: Fector101

app_src/android/DEV.md

@@ -8,8 +8,8 @@ So if new assets added it doesn't add new files
 ```shell
 adb shell
 run-as org.wally.waller
-ls -l files
 cd files
+ls -l
 ```
 How to see WAKE INTENT
 ```shell
@@ -129,11 +129,15 @@ python3 -m http.server 8000
 keytool -genkey -v -keystore my-release-key.jks -alias key-stuff -keyalg RSA -keysize 2048 -validity 10000 -storepass 12345 -keypass 12345 -dname "CN=Fabian, OU=Mobile, O=FabianCorp, L=New York, ST=NY, C=US"
 
 
+
+```shell
+sudo apt install zipalign apksigner
 buildozer -v android release
 zipalign -v -p 4 bin/waller-1.0.6-arm64-v8a_armeabi-v7a-release-unsigned.apk bin/waller-aligned.apk
 apksigner sign --ks my-release-key.jks --ks-key-alias key-stuff --ks-pass pass:123456789 --key-pass pass:123456789 --out bin/waller-signed.apk bin/waller-aligned.apk
 apksigner verify --verbose bin/waller-signed.apk
 adb install -r bin/waller-signed.apk
+```
 
 ## On GitHub Actions
 Create my-release-key.jks Locally by running

app_src/android/p4a/hook.py

@@ -50,7 +50,14 @@ def generate_receivers(package_: str = None) -> str:
         Receiver(
             name="BootReceiver",
             actions=["android.intent.action.BOOT_COMPLETED"]
-        )
+        ),
+        Receiver(
+            name="ConnectivityReceiver",
+            actions=[
+                "android.net.conn.CONNECTIVITY_CHANGE",
+                "android.net.wifi.WIFI_STATE_CHANGED",
+            ],
+        ),
 
     ]
 

app_src/android/src/ConnectivityReceiver.java

@@ -0,0 +1,24 @@
+package org.wally.waller;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.util.Log;
+
+public class ConnectivityReceiver extends BroadcastReceiver {
+
+    private static final String TAG = "ConnectivityReceiver";
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        Log.d(TAG, "onReceive called, action=" + intent.getAction());
+
+        if (UpdateNotifier.isCooldownActive(context)) {
+            Log.d(TAG, "Cooldown active, skipping");
+            return;
+        }
+
+        Log.d(TAG, "Cooldown passed, checking for update in background");
+        new Thread(() -> UpdateNotifier.checkAndNotify(context)).start();
+    }
+}

app_src/android/src/UpdateCheckWorker.java

@@ -0,0 +1,37 @@
+package org.wally.waller;
+
+import android.content.Context;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.work.Worker;
+import androidx.work.WorkerParameters;
+
+public class UpdateCheckWorker extends Worker {
+
+    private static final String TAG = "UpdateCheckWorker";
+
+    public UpdateCheckWorker(@NonNull Context context, @NonNull WorkerParameters params) {
+        super(context, params);
+    }
+
+    @NonNull
+    @Override
+    public Result doWork() {
+        Log.d(TAG, "doWork called");
+
+        Context ctx = getApplicationContext();
+
+        if (!UpdateNotifier.isNetworkAvailable(ctx)) {
+            Log.d(TAG, "No network, retrying later");
+            return Result.retry();
+        }
+
+        if (UpdateNotifier.isCooldownActive(ctx)) {
+            Log.d(TAG, "Cooldown active, skipping");
+            return Result.success();
+        }
+
+        return UpdateNotifier.checkAndNotify(ctx) ? Result.retry() : Result.success();
+    }
+}

app_src/android/src/UpdateNotifier.java

@@ -0,0 +1,244 @@
+package org.wally.waller;
+
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.net.ConnectivityManager;
+import android.net.NetworkInfo;
+import android.os.Build;
+import android.util.Log;
+
+import androidx.core.app.NotificationCompat;
+
+import org.json.JSONObject;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.net.HttpURLConnection;
+import java.net.URL;
+
+public class UpdateNotifier {
+
+    private static final String TAG = "UpdateNotifier";
+    private static final String PREFS_NAME = "update_checker_prefs";
+    private static final String KEY_LAST_NOTIFIED = "last_notified_timestamp";
+    private static final long SEVEN_DAYS_MS = 7L * 24 * 60 * 60 * 1000;
+    private static final String CHANNEL_ID = "update_channel";
+    private static final String CHANNEL_NAME = "App Updates";
+    private static final int NOTIFICATION_ID = 999;
+    private static final String API_URL = "https://api.github.com/repos/Fector101/wallpaper-carousel/releases/latest";
+
+    public static boolean isCooldownActive(Context context) {
+        SharedPreferences prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
+        long lastNotified = prefs.getLong(KEY_LAST_NOTIFIED, 0);
+        long now = System.currentTimeMillis();
+        Log.d(TAG, "elapsed=" + (now - lastNotified) + "ms, cooldown=" + SEVEN_DAYS_MS + "ms");
+        return now - lastNotified < SEVEN_DAYS_MS;
+    }
+
+    public static boolean isNetworkAvailable(Context context) {
+        try {
+            ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
+            if (cm == null) return false;
+            NetworkInfo info = cm.getActiveNetworkInfo();
+            return info != null && info.isConnected();
+        } catch (Exception e) {
+            Log.e(TAG, "Error checking network", e);
+            return false;
+        }
+    }
+
+    /**
+     * Full check: version compare + notes fetch + notification.
+     * Returns true if the check should be retried later (fetch failed), false otherwise.
+     */
+    public static boolean checkAndNotify(Context context) {
+        try {
+            String currentVersion = getCurrentVersion(context);
+            Log.d(TAG, "Current version: " + currentVersion);
+
+            String latestVersion = fetchLatestVersion();
+            if (latestVersion == null) {
+                Log.e(TAG, "Failed to fetch latest version");
+                return true;
+            }
+            Log.d(TAG, "Latest version: " + latestVersion);
+
+            if (latestVersion.equals(currentVersion)) {
+                Log.d(TAG, "Already on latest version");
+                return false;
+            }
+
+            Log.d(TAG, "New version available: " + latestVersion);
+            String releaseNotes = fetchReleaseNotes(latestVersion);
+            boolean posted = sendNotification(context, latestVersion, releaseNotes);
+            if (!posted) {
+                Log.w(TAG, "Notification not eligible to post, cooldown timestamp NOT saved");
+                return true;
+            }
+
+            context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+                    .edit().putLong(KEY_LAST_NOTIFIED, System.currentTimeMillis()).apply();
+            Log.d(TAG, "Timestamp saved, notification sent");
+
+        } catch (Exception e) {
+            Log.e(TAG, "Update check failed", e);
+            return true;
+        }
+        return false;
+    }
+
+    public static String getCurrentVersion(Context context) {
+        try {
+            PackageInfo pInfo = context.getPackageManager().getPackageInfo(context.getPackageName(), 0);
+            return pInfo.versionName;
+        } catch (PackageManager.NameNotFoundException e) {
+            Log.e(TAG, "Could not get package version", e);
+            return "";
+        }
+    }
+
+    private static String fetchLatestVersion() {
+        try {
+            URL url = new URL(API_URL);
+            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
+            conn.setRequestMethod("GET");
+            conn.setRequestProperty("Accept", "application/vnd.github.v3+json");
+            conn.setConnectTimeout(10000);
+            conn.setReadTimeout(10000);
+
+            int responseCode = conn.getResponseCode();
+            if (responseCode != 200) {
+                Log.e(TAG, "HTTP " + responseCode);
+                return null;
+            }
+
+            BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
+            StringBuilder sb = new StringBuilder();
+            String line;
+            while ((line = reader.readLine()) != null) {
+                sb.append(line);
+            }
+            reader.close();
+            conn.disconnect();
+
+            JSONObject json = new JSONObject(sb.toString());
+            String tag = json.getString("tag_name");
+            return tag.startsWith("v") ? tag.substring(1) : tag;
+
+        } catch (Exception e) {
+            Log.e(TAG, "Failed to fetch latest version", e);
+            return null;
+        }
+    }
+
+    private static String fetchReleaseNotes(String version) {
+        try {
+            String fileUrl = "https://github.com/Fector101/wallpaper-carousel/releases/download/v"
+                    + version + "/update-note-v" + version + ".txt";
+            URL url = new URL(fileUrl);
+            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
+            conn.setRequestMethod("GET");
+            conn.setConnectTimeout(10000);
+            conn.setReadTimeout(10000);
+
+            int responseCode = conn.getResponseCode();
+            if (responseCode != 200) {
+                Log.e(TAG, "Release notes HTTP " + responseCode);
+                return null;
+            }
+
+            BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
+            StringBuilder sb = new StringBuilder();
+            String line;
+            while ((line = reader.readLine()) != null) {
+                sb.append(line);
+                sb.append("\n");
+            }
+            reader.close();
+            conn.disconnect();
+            return sb.toString().trim();
+
+        } catch (Exception e) {
+            Log.e(TAG, "Failed to fetch release notes", e);
+            return null;
+        }
+    }
+
+    private static boolean canPostNotification(Context context) {
+        try {
+            NotificationManager nm = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+            if (nm == null) {
+                Log.w(TAG, "NotificationManager unavailable, cannot post");
+                return false;
+            }
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                if (context.checkSelfPermission(android.Manifest.permission.POST_NOTIFICATIONS)
+                        != android.content.pm.PackageManager.PERMISSION_GRANTED) {
+                    Log.w(TAG, "POST_NOTIFICATIONS permission not granted");
+                    return false;
+                }
+            } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+                if (!nm.areNotificationsEnabled()) {
+                    Log.w(TAG, "Notifications disabled for app");
+                    return false;
+                }
+            }
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                NotificationChannel channel = new NotificationChannel(
+                        CHANNEL_ID, CHANNEL_NAME, NotificationManager.IMPORTANCE_HIGH);
+                channel.setDescription("Notifications for app updates");
+                nm.createNotificationChannel(channel);
+
+                NotificationChannel created = nm.getNotificationChannel(CHANNEL_ID);
+                if (created == null || created.getImportance() == NotificationManager.IMPORTANCE_NONE) {
+                    Log.w(TAG, "Update channel disabled, cannot post");
+                    return false;
+                }
+            }
+            return true;
+        } catch (Exception e) {
+            Log.e(TAG, "Notification eligibility check failed", e);
+            return false;
+        }
+    }
+
+    private static boolean sendNotification(Context context, String version, String releaseNotes) {
+        if (!canPostNotification(context)) {
+            return false;
+        }
+
+        NotificationManager nm = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+        if (nm == null) return false;
+
+        Intent launchIntent = context.getPackageManager().getLaunchIntentForPackage(context.getPackageName());
+        if (launchIntent == null) return false;
+        launchIntent.putExtra("action", "open_update");
+        launchIntent.putExtra("version", version);
+        launchIntent.putExtra("release_notes", releaseNotes);
+        launchIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP);
+
+        PendingIntent pendingIntent = PendingIntent.getActivity(
+                context, NOTIFICATION_ID, launchIntent,
+                PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE);
+
+        NotificationCompat.Builder builder = new NotificationCompat.Builder(context, CHANNEL_ID)
+                .setSmallIcon(android.R.drawable.stat_notify_sync)
+                .setContentTitle("New version available")
+                .setContentText("v" + version + " is ready. Tap to update.")
+                .setPriority(NotificationCompat.PRIORITY_HIGH)
+                .setContentIntent(pendingIntent)
+                .setAutoCancel(true);
+
+        nm.notify(NOTIFICATION_ID, builder.build());
+        Log.d(TAG, "Notification sent for v" + version);
+        return true;
+    }
+}

app_src/android/src/WorkScheduler.java

@@ -0,0 +1,40 @@
+package org.wally.waller;
+
+import android.content.Context;
+
+import androidx.work.Constraints;
+import androidx.work.ExistingPeriodicWorkPolicy;
+import androidx.work.NetworkType;
+import androidx.work.PeriodicWorkRequest;
+import androidx.work.WorkManager;
+
+import java.util.concurrent.TimeUnit;
+
+public class WorkScheduler {
+
+    public static final String WORK_TAG = "update_check_work";
+
+    public static void scheduleUpdateCheck(Context context) {
+        Constraints constraints = new Constraints.Builder()
+                .setRequiredNetworkType(NetworkType.CONNECTED)
+                .build();
+
+        // PeriodicWorkRequest workRequest = new PeriodicWorkRequest.Builder(
+        //         UpdateCheckWorker.class, 15, TimeUnit.MINUTES) // For testing purposes, using a shorter interval
+        //         .setConstraints(constraints)
+        //         .addTag(WORK_TAG)
+        //         .build();
+
+        PeriodicWorkRequest workRequest = new PeriodicWorkRequest.Builder(
+                UpdateCheckWorker.class, 7, TimeUnit.DAYS)
+                .setConstraints(constraints)
+                .addTag(WORK_TAG)
+                .build();
+
+        WorkManager.getInstance(context)
+                .enqueueUniquePeriodicWork(
+                        WORK_TAG,
+                        ExistingPeriodicWorkPolicy.KEEP,
+                        workRequest);
+    }
+}