react-native-notify-kit 9.1.21 → 9.2.0

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);
+  }
+}

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

@@ -0,0 +1,350 @@
+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 static androidx.core.app.NotificationManagerCompat.IMPORTANCE_NONE;
+
+import android.app.NotificationChannel;
+import android.app.NotificationChannelGroup;
+import android.media.AudioAttributes;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import androidx.annotation.NonNull;
+import androidx.core.app.NotificationManagerCompat;
+import app.notifee.core.model.ChannelGroupModel;
+import app.notifee.core.model.ChannelModel;
+import app.notifee.core.utility.ColorUtils;
+import app.notifee.core.utility.ResourceUtils;
+import com.google.common.util.concurrent.ListenableFuture;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class ChannelManager {
+
+  private static String TAG = "ChannelManager";
+
+  static ListenableFuture<Void> createChannel(ChannelModel channelModel) {
+    return Notifee.getListeningExecutorService()
+        .submit(
+            () -> {
+              if (Build.VERSION.SDK_INT < 26) {
+                return null;
+              }
+
+              NotificationChannel channel =
+                  new NotificationChannel(
+                      channelModel.getId(), channelModel.getName(), channelModel.getImportance());
+
+              channel.setShowBadge(channelModel.getBadge());
+              channel.setBypassDnd(channelModel.getBypassDnd());
+              channel.setDescription(channelModel.getDescription());
+              channel.setGroup(channelModel.getGroupId());
+              channel.enableLights(channelModel.getLights());
+
+              if (channelModel.getLightColor() != null) {
+                channel.setLightColor(channelModel.getLightColor());
+              }
+
+              channel.setLockscreenVisibility(channelModel.getVisibility());
+              channel.enableVibration(channelModel.getVibration());
+
+              long[] vibrationPattern = channelModel.getVibrationPattern();
+              if (vibrationPattern.length > 0) {
+                channel.setVibrationPattern(vibrationPattern);
+              }
+
+              if (channelModel.getSound() != null) {
+                Uri soundUri = ResourceUtils.getSoundUri(channelModel.getSound());
+                if (soundUri != null) {
+                  AudioAttributes audioAttributes =
+                      new AudioAttributes.Builder()
+                          .setUsage(AudioAttributes.USAGE_NOTIFICATION)
+                          .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
+                          .build();
+                  channel.setSound(soundUri, audioAttributes);
+                } else {
+                  Logger.w(
+                      TAG,
+                      "Unable to retrieve sound for channel, sound was specified as: "
+                          + channel.getSound());
+                }
+              } else {
+                channel.setSound(null, null);
+              }
+
+              NotificationManagerCompat.from(ContextHolder.getApplicationContext())
+                  .createNotificationChannel(channel);
+
+              return null;
+            });
+  }
+
+  static ListenableFuture<Void> createChannels(List<ChannelModel> channelModels) {
+    return Notifee.getListeningExecutorService()
+        .submit(
+            () -> {
+              for (ChannelModel channelModel : channelModels) {
+                createChannel(channelModel).get();
+              }
+
+              return null;
+            });
+  }
+
+  static ListenableFuture<Void> createChannelGroup(ChannelGroupModel channelGroupModel) {
+    return Notifee.getListeningExecutorService()
+        .submit(
+            () -> {
+              if (Build.VERSION.SDK_INT < 26) {
+                return null;
+              }
+
+              NotificationChannelGroup notificationChannelGroup =
+                  new NotificationChannelGroup(
+                      channelGroupModel.getId(), channelGroupModel.getName());
+
+              if (Build.VERSION.SDK_INT >= 28 && channelGroupModel.getDescription() != null) {
+                notificationChannelGroup.setDescription(channelGroupModel.getDescription());
+              }
+
+              NotificationManagerCompat.from(ContextHolder.getApplicationContext())
+                  .createNotificationChannelGroup(notificationChannelGroup);
+
+              return null;
+            });
+  }
+
+  static ListenableFuture<Void> createChannelGroups(List<ChannelGroupModel> channelGroupModels) {
+    return Notifee.getListeningExecutorService()
+        .submit(
+            () -> {
+              if (Build.VERSION.SDK_INT < 26) {
+                return null;
+              }
+
+              for (ChannelGroupModel channelGroupModel : channelGroupModels) {
+                createChannelGroup(channelGroupModel).get();
+              }
+
+              return null;
+            });
+  }
+
+  static void deleteChannel(@NonNull String channelId) {
+    NotificationManagerCompat.from(ContextHolder.getApplicationContext())
+        .deleteNotificationChannel(channelId);
+  }
+
+  static void deleteChannelGroup(@NonNull String channelGroupId) {
+    NotificationManagerCompat.from(ContextHolder.getApplicationContext())
+        .deleteNotificationChannelGroup(channelGroupId);
+  }
+
+  static ListenableFuture<List<Bundle>> getChannels() {
+    return Notifee.getListeningExecutorService()
+        .submit(
+            () -> {
+              List<NotificationChannel> channels =
+                  NotificationManagerCompat.from(ContextHolder.getApplicationContext())
+                      .getNotificationChannels();
+
+              if (channels.size() == 0 || Build.VERSION.SDK_INT < 26) {
+                return Collections.emptyList();
+              }
+
+              ArrayList<Bundle> channelBundles = new ArrayList<>(channels.size());
+              for (NotificationChannel channel : channels) {
+                channelBundles.add(convertChannelToBundle(channel));
+              }
+
+              return channelBundles;
+            });
+  }
+
+  static ListenableFuture<Bundle> getChannel(String channelId) {
+    return Notifee.getListeningExecutorService()
+        .submit(
+            () -> {
+              NotificationChannel channel =
+                  NotificationManagerCompat.from(ContextHolder.getApplicationContext())
+                      .getNotificationChannel(channelId);
+
+              return convertChannelToBundle(channel);
+            });
+  }
+
+  static ListenableFuture<Boolean> isChannelBlocked(String channelId) {
+    return Notifee.getListeningExecutorService()
+        .submit(
+            () -> {
+              if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return false;
+
+              NotificationChannel channel =
+                  NotificationManagerCompat.from(ContextHolder.getApplicationContext())
+                      .getNotificationChannel(channelId);
+
+              if (channel == null) {
+                return false;
+              }
+
+              return IMPORTANCE_NONE == channel.getImportance();
+            });
+  }
+
+  static ListenableFuture<Boolean> isChannelCreated(String channelId) {
+    return Notifee.getListeningExecutorService()
+        .submit(
+            () -> {
+              if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return false;
+
+              NotificationChannel channel =
+                  NotificationManagerCompat.from(ContextHolder.getApplicationContext())
+                      .getNotificationChannel(channelId);
+
+              return channel != null;
+            });
+  }
+
+  static ListenableFuture<List<Bundle>> getChannelGroups() {
+    return Notifee.getListeningExecutorService()
+        .submit(
+            () -> {
+              List<NotificationChannelGroup> channelGroups =
+                  NotificationManagerCompat.from(ContextHolder.getApplicationContext())
+                      .getNotificationChannelGroups();
+
+              if (channelGroups.size() == 0 || Build.VERSION.SDK_INT < 26) {
+                return Collections.emptyList();
+              }
+
+              ArrayList<Bundle> channelGroupBundles = new ArrayList<>(channelGroups.size());
+              for (NotificationChannelGroup channelGroup : channelGroups) {
+                channelGroupBundles.add(convertChannelGroupToBundle(channelGroup));
+              }
+
+              return channelGroupBundles;
+            });
+  }
+
+  static ListenableFuture<Bundle> getChannelGroup(String channelGroupId) {
+    return Notifee.getListeningExecutorService()
+        .submit(
+            () -> {
+              NotificationChannelGroup channelGroup =
+                  NotificationManagerCompat.from(ContextHolder.getApplicationContext())
+                      .getNotificationChannelGroup(channelGroupId);
+
+              return convertChannelGroupToBundle(channelGroup);
+            });
+  }
+
+  private static Bundle convertChannelToBundle(NotificationChannel channel) {
+    if (channel == null || Build.VERSION.SDK_INT < 26) {
+      return null;
+    }
+
+    Bundle channelBundle = new Bundle();
+    channelBundle.putString("id", channel.getId());
+    channelBundle.putString("name", channel.getName().toString());
+    channelBundle.putBoolean("badge", channel.canShowBadge());
+    channelBundle.putBoolean("bypassDnd", channel.canBypassDnd());
+
+    // can be null, don't include if null
+    if (channel.getDescription() != null) {
+      channelBundle.putString("description", channel.getDescription());
+    }
+
+    // can be null, don't include if null
+    if (channel.getGroup() != null) {
+      channelBundle.putString("groupId", channel.getGroup());
+    }
+
+    channelBundle.putInt("importance", channel.getImportance());
+    channelBundle.putBoolean("lights", channel.shouldShowLights());
+    channelBundle.putBoolean("vibration", channel.shouldVibrate());
+    channelBundle.putBoolean("blocked", channel.getImportance() == IMPORTANCE_NONE);
+
+    // can be null, don't include if null
+    if (channel.getSound() != null) {
+      channelBundle.putString("soundURI", channel.getSound().toString());
+      // try to parse uri
+      String soundValue = ResourceUtils.getSoundName(channel.getSound());
+      if (soundValue != null) channelBundle.putString("sound", soundValue);
+    }
+
+    // optional, can be 0
+    if (channel.getLightColor() != 0) {
+      channelBundle.putString("lightColor", ColorUtils.getColorString(channel.getLightColor()));
+    }
+
+    // getVibrationPattern can be null
+    long[] vibrationPattern = channel.getVibrationPattern();
+
+    if (vibrationPattern != null && vibrationPattern.length > 0) {
+      try {
+        int[] convertedVibrationPattern = new int[vibrationPattern.length];
+        // cast to int array
+        for (int i = 0; i < vibrationPattern.length; i++) {
+          convertedVibrationPattern[i] = (int) vibrationPattern[i];
+        }
+
+        channelBundle.putIntArray("vibrationPattern", convertedVibrationPattern);
+      } catch (Exception e) {
+        Logger.e(TAG, "Unable to convert Vibration Pattern to Channel Bundle", e);
+      }
+    }
+
+    // Unless the user manually changes this in app settings, it is always -1000.
+    int visibility = channel.getLockscreenVisibility();
+    if (visibility != -1000) { // -1000 = not set
+      channelBundle.putInt("visibility", visibility);
+    }
+
+    return channelBundle;
+  }
+
+  private static Bundle convertChannelGroupToBundle(NotificationChannelGroup channelGroup) {
+    if (channelGroup == null || Build.VERSION.SDK_INT < 26) {
+      return null;
+    }
+
+    Bundle channelGroupBundle = new Bundle();
+    channelGroupBundle.putString("id", channelGroup.getId());
+    channelGroupBundle.putString("name", channelGroup.getName().toString());
+
+    List<NotificationChannel> notificationChannels = channelGroup.getChannels();
+    ArrayList<Bundle> channels = new ArrayList<>(notificationChannels.size());
+
+    for (NotificationChannel notificationChannel : notificationChannels) {
+      channels.add(convertChannelToBundle(notificationChannel));
+    }
+
+    channelGroupBundle.putParcelableArrayList("channels", channels);
+
+    if (Build.VERSION.SDK_INT >= 28) {
+      channelGroupBundle.putBoolean("blocked", channelGroup.isBlocked());
+      channelGroupBundle.putString("description", channelGroup.getDescription());
+    } else {
+      channelGroupBundle.putBoolean("blocked", false);
+    }
+
+    return channelGroupBundle;
+  }
+}

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

@@ -0,0 +1,33 @@
+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.content.Context;
+
+public class ContextHolder {
+  private static Context applicationContext;
+
+  public static Context getApplicationContext() {
+    return applicationContext;
+  }
+
+  public static void setApplicationContext(Context applicationContext) {
+    Logger.d("context", "received application context");
+    ContextHolder.applicationContext = applicationContext;
+  }
+}

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

@@ -0,0 +1,63 @@
+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.
+ *
+ */
+
+public class EventBus {
+  private static final EventBus instance = new EventBus();
+  private org.greenrobot.eventbus.EventBus eventBus;
+
+  private EventBus() {
+    eventBus = org.greenrobot.eventbus.EventBus.builder().build();
+  }
+
+  public static EventBus getInstance() {
+    return instance;
+  }
+
+  public static void register(Object subscriber) {
+    getInstance().getDefault().register(subscriber);
+  }
+
+  public static void unregister(Object subscriber) {
+    getInstance().getDefault().unregister(subscriber);
+  }
+
+  public static <T> T getStickyEvent(Class<T> eventType) {
+    return getInstance().getDefault().getStickyEvent(eventType);
+  }
+
+  public static <T> T removeStickEvent(Class<T> eventType) {
+    return getInstance().getDefault().removeStickyEvent(eventType);
+  }
+
+  public static void post(Object event) {
+    getInstance().getDefault().post(event);
+  }
+
+  static void postSticky(Object event) {
+    getInstance().getDefault().postSticky(event);
+  }
+
+  static <T> T removeStickyEvent(Class<T> eventType) {
+    return getInstance().getDefault().removeStickyEvent(eventType);
+  }
+
+  private org.greenrobot.eventbus.EventBus getDefault() {
+    return eventBus;
+  }
+}

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

@@ -0,0 +1,82 @@
+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.content.Context;
+import app.notifee.core.event.BlockStateEvent;
+import app.notifee.core.event.ForegroundServiceEvent;
+import app.notifee.core.event.LogEvent;
+import app.notifee.core.event.NotificationEvent;
+import app.notifee.core.interfaces.EventListener;
+import java.util.HashSet;
+import java.util.Set;
+import org.greenrobot.eventbus.Subscribe;
+import org.greenrobot.eventbus.ThreadMode;
+
+@KeepForSdk
+public class EventSubscriber {
+  private static final EventSubscriber mInstance = new EventSubscriber();
+  private final Set<EventListener> mListeners = new HashSet<>();
+
+  private EventSubscriber() {
+    EventBus.register(this);
+  }
+
+  @KeepForSdk
+  public static void register(EventListener listener) {
+    mInstance.mListeners.add(listener);
+  }
+
+  @KeepForSdk
+  public static void unregister(EventListener listener) {
+    mInstance.mListeners.remove(listener);
+  }
+
+  @KeepForSdk
+  public static Context getContext() {
+    return ContextHolder.getApplicationContext();
+  }
+
+  @Subscribe(threadMode = ThreadMode.MAIN)
+  public void onNotificationEvent(NotificationEvent notificationEvent) {
+    for (EventListener eventListener : mListeners) {
+      eventListener.onNotificationEvent(notificationEvent);
+    }
+  }
+
+  @Subscribe(threadMode = ThreadMode.MAIN)
+  public void onLogEvent(LogEvent logEvent) {
+    for (EventListener eventListener : mListeners) {
+      eventListener.onLogEvent(logEvent);
+    }
+  }
+
+  @Subscribe(threadMode = ThreadMode.MAIN)
+  public void onBlockStateEvent(BlockStateEvent blockStateEvent) {
+    for (EventListener eventListener : mListeners) {
+      eventListener.onBlockStateEvent(blockStateEvent);
+    }
+  }
+
+  @Subscribe(threadMode = ThreadMode.MAIN)
+  public void onForegroundServiceEvent(ForegroundServiceEvent foregroundServiceEvent) {
+    for (EventListener eventListener : mListeners) {
+      eventListener.onForegroundServiceEvent(foregroundServiceEvent);
+    }
+  }
+}