@ammarahmed/notifee-react-native 7.3.1 → 7.4.2

package/android/build.gradle

@@ -1,4 +1,6 @@
 import java.nio.file.Paths
+import org.gradle.internal.jvm.Jvm
+
 
 buildscript {
   // The Android Gradle plugin is only required when opening the android folder stand-alone.
@@ -20,6 +22,8 @@ plugins {
   id "io.invertase.gradle.build" version "1.5"
 }
 
+apply plugin: 'com.android.library'
+
 // https://github.com/facebook/react-native/blob/a70354df12ef71aec08583cca4f1fed5fb77d874/ReactAndroid/build.gradle#L168-L201
 def findNodeModulePath(baseDir, packageName) {
   def basePath = baseDir.toPath().normalize()
@@ -35,7 +39,7 @@ def findNodeModulePath(baseDir, packageName) {
   return null
 }
 
-def notifeeDir = findNodeModulePath(projectDir, "@ammarahmed/notifee-react-native") ?: "$rootDir/../node_modules/@ammarahmed/notifee-react-native"
+def notifeeDir = findNodeModulePath(projectDir, "@ammarahm-ed/notifee-react-native") ?: "$rootDir/../node_modules/@ammarahm-ed/notifee-react-native"
 println ":${project.name} @notifee/react-native found at $notifeeDir"
 
 if (project.hasProperty('reactNativeProjects')) {
@@ -64,7 +68,15 @@ project.ext {
 android {
   defaultConfig {
     multiDexEnabled true
+    javaCompileOptions {
+      annotationProcessorOptions {
+        arguments = ["room.schemaLocation":
+                             "$projectDir/schemas".toString(),
+                             eventBusIndex: 'app.notifee.core.EventBusIndex']
+      }
+    }
   }
+
   lintOptions {
     disable 'GradleCompatible'
     abortOnError false
@@ -88,29 +100,35 @@ repositories {
 }
 
 dependencies {
-  if (findProject(':notifee_core')) {
-    implementation findProject(':notifee_core')
-  } else {
-    implementation(group: 'app.notifee', name:'core', version: '+')
-  }
-  implementation 'androidx.concurrent:concurrent-futures:1.1.0' // https://developer.android.com/jetpack/androidx/releases/concurrent
-  implementation 'com.google.android.gms:play-services-tasks:18.0.1' // https://developers.google.com/android/guides/releases
-  implementation 'androidx.work:work-runtime:2.7.1' // https://developer.android.com/jetpack/androidx/releases/work
-  implementation 'org.greenrobot:eventbus:3.2.0' // https://github.com/greenrobot/EventBus/releases
-
   // needed to enforce version and avoid clashes
   // https://github.com/square/okhttp/blob/master/docs/changelog_3x.md
   implementation 'com.squareup.okhttp3:okhttp:3.12.13' // okhttp must stay on 3.12.x to support minSdkVersion < 21
+
+  implementation 'androidx.annotation:annotation:1.3.0' // https://developer.android.com/jetpack/androidx/releases/annotation
+  implementation "com.squareup.okhttp3:okhttp:3.12.12" // okhttp must stay on 3.12.x to support minSdkVersion < 21
+  implementation 'androidx.concurrent:concurrent-futures:1.1.0' // https://developer.android.com/jetpack/androidx/releases/concurrent
+  implementation 'androidx.work:work-runtime:2.7.1' // https://developer.android.com/jetpack/androidx/releases/work
+  implementation 'com.facebook.fresco:fresco:2.6.0' // https://github.com/facebook/fresco/releases
+
+  implementation("com.google.guava:guava:31.1-android") // https://github.com/google/guava
+  implementation 'androidx.core:core:1.6.0'
+
+  def room_version = '2.4.3' // https://developer.android.com/jetpack/androidx/releases/room
+  implementation "androidx.room:room-runtime:$room_version"
+  annotationProcessor "androidx.room:room-compiler:$room_version"
+
+  def eventbus_version = '3.2.0' // https://github.com/greenrobot/EventBus/releases
+  api "org.greenrobot:eventbus:$eventbus_version"
+  annotationProcessor "org.greenrobot:eventbus-annotation-processor:$eventbus_version"
+
+  testImplementation 'junit:junit:4.13.2' // https://github.com/junit-team/junit4/releases
+  androidTestImplementation 'androidx.test.ext:junit:1.1.3' // https://developer.android.com/jetpack/androidx/releases/test
+  androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0' // see above
+  androidTestImplementation "androidx.room:room-testing:$room_version"
+  androidTestImplementation "androidx.test:monitor:1.4.0"
 }
 
 ReactNative.shared.applyPackageVersion()
 ReactNative.shared.applyDefaultExcludes()
 ReactNative.module.applyAndroidVersions()
 ReactNative.module.applyReactNativeDependency("api")
-rootProject.allprojects {
-  repositories {
-    maven {
-      url "$notifeeDir/android/libs"
-    }
-  }
-}

package/android/schemas/app.notifee.core.database.NotifeeCoreDatabase/1.json

@@ -0,0 +1,46 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 1,
+    "identityHash": "f3fdf2a542ef241fa353c4b3be121211",
+    "entities": [
+      {
+        "tableName": "work_data",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `notification` BLOB, `trigger` BLOB, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "notification",
+            "columnName": "notification",
+            "affinity": "BLOB",
+            "notNull": false
+          },
+          {
+            "fieldPath": "trigger",
+            "columnName": "trigger",
+            "affinity": "BLOB",
+            "notNull": false
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "id"
+          ],
+          "autoGenerate": false
+        },
+        "indices": [],
+        "foreignKeys": []
+      }
+    ],
+    "views": [],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'f3fdf2a542ef241fa353c4b3be121211')"
+    ]
+  }
+}

package/android/schemas/app.notifee.core.database.NotifeeCoreDatabase/2.json

@@ -0,0 +1,53 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 2,
+    "identityHash": "24b2477514809255df232947ce7928c4",
+    "entities": [
+      {
+        "tableName": "work_data",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `notification` BLOB, `trigger` BLOB, `with_alarm_manager` INTEGER NOT NULL DEFAULT 0, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "notification",
+            "columnName": "notification",
+            "affinity": "BLOB",
+            "notNull": false
+          },
+          {
+            "fieldPath": "trigger",
+            "columnName": "trigger",
+            "affinity": "BLOB",
+            "notNull": false
+          },
+          {
+            "fieldPath": "withAlarmManager",
+            "columnName": "with_alarm_manager",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "0"
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "id"
+          ],
+          "autoGenerate": false
+        },
+        "indices": [],
+        "foreignKeys": []
+      }
+    ],
+    "views": [],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '24b2477514809255df232947ce7928c4')"
+    ]
+  }
+}

package/android/src/main/java/app/notifee/core/AlarmPermissionBroadcastReceiver.java

@@ -0,0 +1,19 @@
+package app.notifee.core;
+
+import static android.app.AlarmManager.ACTION_SCHEDULE_EXACT_ALARM_PERMISSION_STATE_CHANGED;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.util.Log;
+
+public class AlarmPermissionBroadcastReceiver extends BroadcastReceiver {
+  @Override
+  public void onReceive(Context context, Intent intent) {
+
+    if (intent.getAction().equals(ACTION_SCHEDULE_EXACT_ALARM_PERMISSION_STATE_CHANGED)) {
+      Log.i("AlarmPermissionReceiver", "Received alarm permission state changed event");
+      new NotifeeAlarmManager().rescheduleNotifications();
+    }
+  }
+}

package/android/src/main/java/app/notifee/core/BlockStateBroadcastReceiver.java

@@ -0,0 +1,164 @@
+package app.notifee.core;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import android.app.NotificationManager;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build;
+import android.os.Bundle;
+import androidx.annotation.Keep;
+import androidx.concurrent.futures.CallbackToFutureAdapter;
+import androidx.work.Data;
+import androidx.work.ExistingWorkPolicy;
+import androidx.work.ListenableWorker.Result;
+import androidx.work.OneTimeWorkRequest;
+import androidx.work.WorkManager;
+import app.notifee.core.event.BlockStateEvent;
+import app.notifee.core.interfaces.MethodCallResult;
+import app.notifee.core.utility.ObjectUtils;
+import java.util.concurrent.TimeUnit;
+
+public class BlockStateBroadcastReceiver extends BroadcastReceiver {
+  private static final String TAG = "BlockState";
+  private static final String KEY_TYPE = "type";
+  private static final String KEY_BLOCKED = "blocked";
+  private static final String KEY_CHANNEL_GROUP = "channelOrGroupId";
+
+  @Keep
+  public BlockStateBroadcastReceiver() {}
+
+  static void doWork(Data workData, CallbackToFutureAdapter.Completer<Result> completer) {
+    Logger.v(TAG, "starting background work");
+
+    final boolean blocked = workData.getBoolean(KEY_BLOCKED, false);
+    final int type = workData.getInt(KEY_TYPE, BlockStateEvent.TYPE_APP_BLOCKED);
+    final ObjectUtils.TypedCallback<Bundle> sendEventCallback =
+        bundle -> {
+          final MethodCallResult<Void> methodCallResult =
+              (e, aVoid) -> {
+                if (e != null) {
+                  Logger.e(TAG, "background work failed with error: ", e);
+                  completer.set(Result.failure());
+                } else {
+                  Logger.v(TAG, "background work completed successfully");
+                  completer.set(Result.success());
+                }
+              };
+
+          BlockStateEvent blockStateEvent =
+              new BlockStateEvent(type, bundle, blocked, methodCallResult);
+
+          EventBus.post(blockStateEvent);
+        };
+
+    if (type == BlockStateEvent.TYPE_APP_BLOCKED) {
+      sendEventCallback.call(null);
+      return;
+    }
+
+    MethodCallResult<Bundle> methodCallResult =
+        (e, aBundle) -> {
+          if (e != null) {
+            Logger.e(TAG, "Failed getting channel or channel group bundle, received error: ", e);
+            completer.set(Result.success());
+          } else {
+            sendEventCallback.call(aBundle);
+          }
+        };
+
+    String channelOrGroupId = workData.getString(KEY_CHANNEL_GROUP);
+    if (type == BlockStateEvent.TYPE_CHANNEL_BLOCKED) {
+      Notifee.getInstance().getChannel(channelOrGroupId, methodCallResult);
+    } else if (type == BlockStateEvent.TYPE_CHANNEL_GROUP_BLOCKED) {
+      Notifee.getInstance().getChannelGroup(channelOrGroupId, methodCallResult);
+    } else {
+      Logger.e(TAG, "unknown block state work type");
+      completer.set(Result.success());
+    }
+  }
+
+  @Override
+  public void onReceive(Context context, Intent intent) {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.P) {
+      return;
+    }
+
+    String action = intent.getAction();
+    if (action == null) {
+      return;
+    }
+
+    // To prevent a race condition
+    // See https://github.com/notifee/react-native-notifee/issues/237
+    if (ContextHolder.getApplicationContext() == null) {
+      ContextHolder.setApplicationContext(context.getApplicationContext());
+    }
+
+    String uniqueWorkId = action;
+    Data.Builder workDataBuilder = new Data.Builder();
+    workDataBuilder.putString(Worker.KEY_WORK_TYPE, Worker.WORK_TYPE_BLOCK_STATE_RECEIVER);
+
+    switch (action) {
+      case NotificationManager.ACTION_APP_BLOCK_STATE_CHANGED:
+        workDataBuilder.putInt(KEY_TYPE, BlockStateEvent.TYPE_APP_BLOCKED);
+        break;
+      case NotificationManager.ACTION_NOTIFICATION_CHANNEL_BLOCK_STATE_CHANGED:
+        workDataBuilder.putInt(KEY_TYPE, BlockStateEvent.TYPE_CHANNEL_BLOCKED);
+        String channelId = intent.getStringExtra(NotificationManager.EXTRA_NOTIFICATION_CHANNEL_ID);
+        workDataBuilder.putString(KEY_CHANNEL_GROUP, channelId);
+        uniqueWorkId += "." + channelId;
+        break;
+      case NotificationManager.ACTION_NOTIFICATION_CHANNEL_GROUP_BLOCK_STATE_CHANGED:
+        workDataBuilder.putInt(KEY_TYPE, BlockStateEvent.TYPE_CHANNEL_GROUP_BLOCKED);
+        String channelGroupId =
+            intent.getStringExtra(NotificationManager.EXTRA_NOTIFICATION_CHANNEL_GROUP_ID);
+        workDataBuilder.putString(KEY_CHANNEL_GROUP, channelGroupId);
+        uniqueWorkId += "." + channelGroupId;
+        break;
+      default:
+        Logger.d(TAG, "unknown intent action received, ignoring.");
+        return;
+    }
+
+    workDataBuilder.putBoolean(
+        KEY_BLOCKED, intent.getBooleanExtra(NotificationManager.EXTRA_BLOCKED_STATE, false));
+
+    // a second delay to debounce events coming from a user spam toggling block states
+    OneTimeWorkRequest.Builder builder =
+        new OneTimeWorkRequest.Builder(Worker.class)
+            .setInitialDelay(1, TimeUnit.SECONDS)
+            .setInputData(workDataBuilder.build());
+
+    // On-going issue with WorkManager.getInstance(context)
+    // https://issuetracker.google.com/issues/135858602
+    try {
+      WorkManager.getInstance(ContextHolder.getApplicationContext())
+          .enqueueUniqueWork(uniqueWorkId, ExistingWorkPolicy.REPLACE, builder.build());
+    } catch (IllegalStateException e) {
+      Logger.e(TAG, "Error while calling WorkManager.getInstance", e);
+
+      if (ContextHolder.getApplicationContext() == null) {
+        Logger.e(TAG, "Application Context is null");
+      }
+    }
+
+    Logger.v(TAG, "scheduled new background work with id " + uniqueWorkId);
+  }
+}