OneSignalNotifications.java

package com.onesignal.flutter;

import androidx.annotation.NonNull;
import com.onesignal.OneSignal;
import com.onesignal.debug.internal.logging.Logging;
import com.onesignal.notifications.INotification;
import com.onesignal.notifications.INotificationClickEvent;
import com.onesignal.notifications.INotificationClickListener;
import com.onesignal.notifications.INotificationLifecycleListener;
import com.onesignal.notifications.INotificationWillDisplayEvent;
import com.onesignal.notifications.IPermissionObserver;
import io.flutter.plugin.common.BinaryMessenger;
import io.flutter.plugin.common.MethodCall;
import io.flutter.plugin.common.MethodChannel;
import io.flutter.plugin.common.MethodChannel.MethodCallHandler;
import io.flutter.plugin.common.MethodChannel.Result;
import java.util.HashMap;
import java.util.Map;
import kotlin.coroutines.Continuation;
import kotlin.coroutines.CoroutineContext;
import kotlinx.coroutines.Dispatchers;
import org.json.JSONException;
import org.json.JSONObject;

public class OneSignalNotifications extends FlutterMessengerResponder
        implements MethodCallHandler, INotificationClickListener, INotificationLifecycleListener, IPermissionObserver {
    private static OneSignalNotifications sharedInstance;

    private final HashMap<String, INotificationWillDisplayEvent> notificationOnWillDisplayEventCache = new HashMap<>();
    private final HashMap<String, INotificationWillDisplayEvent> preventedDefaultCache = new HashMap<>();

    // #1138: tracks if Dart requested clicks, so we can queue (not drop) them
    // while the channel is detached across engine/activity lifecycles.
    private boolean clickListenerRequested = false;

    public static OneSignalNotifications getSharedInstance() {
        if (sharedInstance == null) {
            sharedInstance = new OneSignalNotifications();
        }
        return sharedInstance;
    }

    private OneSignalNotifications() {}

    /**
     * A helper class to encapsulate invoking the suspending function [requestPermission] in Java.
     * To support API level < 24, the SDK cannot use the OneSignal-defined [Continue.with] helper method.
     */
    private class RequestPermissionContinuation implements Continuation<Boolean> {

        private final MethodChannel.Result result;

        public RequestPermissionContinuation(MethodChannel.Result result) {
            this.result = result;
        }

        @NonNull
        @Override
        public CoroutineContext getContext() {
            return (CoroutineContext) Dispatchers.getMain();
        }

        @Override
        public void resumeWith(@NonNull Object o) {
            if (o instanceof kotlin.Result.Failure) {
                Throwable e = ((kotlin.Result.Failure) o).exception;
                replyError(
                        result,
                        "OneSignal",
                        "requestPermission failed with error: " + e.getMessage() + "\n" + e.getStackTrace(),
                        null);
            } else {
                replySuccess(result, o);
            }
        }
    }

    static void registerWith(BinaryMessenger messenger) {
        OneSignalNotifications controller = getSharedInstance();
        controller.bindChannelIfUnbound(messenger, "OneSignal#notifications", controller);
    }

    @Override
    public void onMethodCall(MethodCall call, Result result) {
        if (call.method.contentEquals("OneSignal#permission"))
            replySuccess(result, OneSignal.getNotifications().getPermission());
        else if (call.method.contentEquals("OneSignal#canRequest"))
            replySuccess(result, OneSignal.getNotifications().getCanRequestPermission());
        else if (call.method.contentEquals("OneSignal#requestPermission")) this.requestPermission(call, result);
        else if (call.method.contentEquals("OneSignal#removeNotification")) this.removeNotification(call, result);
        else if (call.method.contentEquals("OneSignal#removeGroupedNotifications"))
            this.removeGroupedNotifications(call, result);
        else if (call.method.contentEquals("OneSignal#clearAll")) this.clearAll(call, result);
        else if (call.method.contentEquals("OneSignal#displayNotification")) this.displayNotification(call, result);
        else if (call.method.contentEquals("OneSignal#preventDefault")) this.preventDefault(call, result);
        else if (call.method.contentEquals("OneSignal#lifecycleInit")) this.lifecycleInit(result);
        else if (call.method.contentEquals("OneSignal#proceedWithWillDisplay"))
            this.proceedWithWillDisplay(call, result);
        else if (call.method.contentEquals("OneSignal#addNativeClickListener")) this.registerClickListener();
        else replyNotImplemented(result);
    }

    private void requestPermission(MethodCall call, Result result) {
        boolean fallback = (boolean) call.argument("fallbackToSettings");
        // if permission already exists, return early as the method call will not resolve
        if (OneSignal.getNotifications().getPermission()) {
            replySuccess(result, true);
            return;
        }

        OneSignal.getNotifications().requestPermission(fallback, new RequestPermissionContinuation(result));
    }

    private void removeNotification(MethodCall call, Result result) {
        int notificationId = call.argument("notificationId");
        OneSignal.getNotifications().removeNotification(notificationId);

        replySuccess(result, null);
    }

    private void removeGroupedNotifications(MethodCall call, Result result) {
        String notificationGroup = call.argument("notificationGroup");
        OneSignal.getNotifications().removeGroupedNotifications(notificationGroup);

        replySuccess(result, null);
    }

    private void clearAll(MethodCall call, Result result) {
        OneSignal.getNotifications().clearAllNotifications();
        replySuccess(result, null);
    }

    /// Our bridge layer needs to preventDefault() so that the Flutter listener has time to preventDefault() before the
    // notification is displayed
    /// This function is called after all of the flutter listeners have responded to the willDisplay event.
    /// If any of them have called preventDefault() we will not call display(). Otherwise we will display.
    private void proceedWithWillDisplay(MethodCall call, Result result) {
        String notificationId = call.argument("notificationId");
        INotificationWillDisplayEvent event = notificationOnWillDisplayEventCache.get(notificationId);
        if (event == null) {
            Logging.error(
                    "Could not find onWillDisplayNotification event for notification with id: " + notificationId, null);
            return;
        }
        if (this.preventedDefaultCache.containsKey(notificationId)) {
            replySuccess(result, null);
            return;
        }
        event.getNotification().display();
        replySuccess(result, null);
    }

    private void displayNotification(MethodCall call, Result result) {
        String notificationId = call.argument("notificationId");
        INotificationWillDisplayEvent event = notificationOnWillDisplayEventCache.get(notificationId);
        if (event == null) {
            Logging.error(
                    "Could not find onWillDisplayNotification event for notification with id: " + notificationId, null);
            return;
        }
        event.getNotification().display();
        replySuccess(result, null);
    }

    private void preventDefault(MethodCall call, Result result) {
        String notificationId = call.argument("notificationId");
        INotificationWillDisplayEvent event = notificationOnWillDisplayEventCache.get(notificationId);
        if (event == null) {
            Logging.error(
                    "Could not find onWillDisplayNotification event for notification with id: " + notificationId, null);
            return;
        }
        event.preventDefault();
        this.preventedDefaultCache.put(notificationId, event);
        replySuccess(result, null);
    }

    @Override
    public void onClick(INotificationClickEvent event) {
        try {
            invokeMethodOnUiThread(
                    "OneSignal#onClickNotification", OneSignalSerializer.convertNotificationClickEventToMap(event));
        } catch (JSONException e) {
            e.getStackTrace();
            Logging.error(
                    "Encountered an error attempting to convert INotificationClickEvent object to hash map:"
                            + e.toString(),
                    null);
        }
    }

    @SuppressWarnings("unchecked")
    private JSONObject getJsonFromMap(Map<String, Object> map) throws JSONException {
        JSONObject jsonData = new JSONObject();
        for (String key : map.keySet()) {
            Object value = map.get(key);
            if (value instanceof Map<?, ?>) {
                value = getJsonFromMap((Map<String, Object>) value);
            }
            jsonData.put(key, value);
        }
        return jsonData;
    }

    @Override
    public void onWillDisplay(INotificationWillDisplayEvent event) {
        INotification notification = event.getNotification();
        notificationOnWillDisplayEventCache.put(notification.getNotificationId(), event);
        /// Our bridge layer needs to preventDefault() so that the Flutter listener has time to preventDefault() before
        // the notification is displayed
        event.preventDefault();
        try {
            invokeMethodOnUiThread(
                    "OneSignal#onWillDisplayNotification",
                    OneSignalSerializer.convertNotificationWillDisplayEventToMap(event));
        } catch (JSONException e) {
            e.getStackTrace();
            Logging.error(
                    "Encountered an error attempting to convert INotificationWillDisplayEvent object to hash map:"
                            + e.toString(),
                    null);
        }
    }

    @Override
    public void onNotificationPermissionChange(boolean permission) {
        HashMap<String, Object> hash = new HashMap<>();
        hash.put("permission", permission);
        invokeMethodOnUiThread("OneSignal#onNotificationPermissionDidChange", hash);
    }

    void onDetachedFromEngine(BinaryMessenger detachingMessenger) {
        // #1138: ignore a FlutterFire background engine detaching — removing the
        // listener bound to the live UI engine would drop the next click (the UI
        // engine fires no activity event, so nothing re-adds it).
        if (detachingMessenger != null && detachingMessenger != this.messenger) {
            return;
        }
        // #1149: engine can be torn down before Dart calls initialize().
        if (!OneSignal.isInitialized()) {
            return;
        }
        // Unsubscribe so clicks get queued by the native SDK, not dropped.
        OneSignal.getNotifications().removeClickListener(this);
    }

    /**
     * Same as {@link #onDetachedFromEngine} but for when the engine survives and
     * only the host activity is destroyed (e.g. back-pressed out of MainActivity).
     */
    void onDetachedFromActivity() {
        if (!OneSignal.isInitialized()) {
            return;
        }
        OneSignal.getNotifications().removeClickListener(this);
    }

    /**
     * #1138: rebind the shared channel to the UI engine on (re)attach and drain
     * any clicks the native SDK queued while detached.
     */
    void onAttachedToActivity(BinaryMessenger activityMessenger) {
        // Rebind the shared channel so callbacks hit the now-foreground engine.
        rebindChannelToEngine(activityMessenger, "OneSignal#notifications", this);
        // Re-add the listener so the native SDK drains any clicks queued while
        // detached. Works for fresh, FCM-background, and pre-warmed cached engines
        // alike: a pre-warmed engine's Dart already ran main() and won't re-call
        // OneSignal#addNativeClickListener, so the rebind alone wouldn't restore it.
        // Draining before this engine's Dart listeners exist is safe — the Dart
        // bridge buffers clicks that arrive with no listeners and flushes them once
        // addClickListener runs.
        if (!clickListenerRequested || !OneSignal.isInitialized()) {
            return;
        }
        OneSignal.getNotifications().removeClickListener(this);
        OneSignal.getNotifications().addClickListener(this);
    }

    private void lifecycleInit(Result result) {
        OneSignal.getNotifications().removeForegroundLifecycleListener(this);
        OneSignal.getNotifications().addForegroundLifecycleListener(this);
        OneSignal.getNotifications().removePermissionObserver(this);
        OneSignal.getNotifications().addPermissionObserver(this);
        notificationOnWillDisplayEventCache.clear();
        preventedDefaultCache.clear();
        replySuccess(result, null);
    }

    private void registerClickListener() {
        clickListenerRequested = true;
        OneSignal.getNotifications().removeClickListener(this);
        OneSignal.getNotifications().addClickListener(this);
    }
}