html2apk 0.1.0

package/src/templates/cordova-plugin-html2apk-bridge/src/android/Html2ApkBridge.java

@@ -0,0 +1,375 @@
+package dev.html2apk.bridge;
+
+import android.Manifest;
+import android.app.Activity;
+import android.app.AlarmManager;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.net.Uri;
+import android.os.Build;
+import android.os.VibrationEffect;
+import android.os.Vibrator;
+import android.provider.Settings;
+import android.view.View;
+import android.widget.Toast;
+
+import androidx.core.app.NotificationCompat;
+import androidx.core.app.NotificationManagerCompat;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaInterface;
+import org.apache.cordova.CordovaPlugin;
+import org.apache.cordova.CordovaWebView;
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+public class Html2ApkBridge extends CordovaPlugin {
+    static final String CHANNEL_ID = "html2apk_default";
+    static final String EXTRA_NOTIFICATION_CLICKED = "html2apk_notification_clicked";
+    static final String EXTRA_NOTIFICATION_DETAIL = "html2apk_notification_detail";
+
+    private static final int REQUEST_POST_NOTIFICATIONS = 7311;
+
+    private CallbackContext notificationPermissionCallback;
+    private JSONObject initialNotification;
+
+    @Override
+    public void initialize(CordovaInterface cordova, CordovaWebView webView) {
+        super.initialize(cordova, webView);
+        handleNotificationIntent(cordova.getActivity().getIntent(), false);
+    }
+
+    @Override
+    public void onNewIntent(Intent intent) {
+        handleNotificationIntent(intent, true);
+    }
+
+    @Override
+    public boolean execute(String action, JSONArray args, CallbackContext callbackContext) {
+        try {
+            if ("notify".equals(action)) {
+                JSONObject options = args.optJSONObject(0);
+                showNotification(options == null ? new JSONObject() : options);
+                callbackContext.success();
+                return true;
+            }
+
+            if ("scheduleNotification".equals(action)) {
+                JSONObject options = args.optJSONObject(0);
+                scheduleNotification(options == null ? new JSONObject() : options);
+                callbackContext.success();
+                return true;
+            }
+
+            if ("vibrate".equals(action)) {
+                vibrate(args.optLong(0, 200));
+                callbackContext.success();
+                return true;
+            }
+
+            if ("toast".equals(action)) {
+                toast(args.optString(0, ""));
+                callbackContext.success();
+                return true;
+            }
+
+            if ("fullscreen".equals(action)) {
+                setFullscreen(args.optBoolean(0, true));
+                callbackContext.success();
+                return true;
+            }
+
+            if ("requestNotificationPermission".equals(action)) {
+                requestNotificationPermission(callbackContext);
+                return true;
+            }
+
+            if ("notificationPermissionStatus".equals(action)) {
+                callbackContext.success(notificationPermissionStatus());
+                return true;
+            }
+
+            if ("canScheduleExactAlarms".equals(action)) {
+                callbackContext.success(canScheduleExactAlarms() ? 1 : 0);
+                return true;
+            }
+
+            if ("openExactAlarmSettings".equals(action)) {
+                openExactAlarmSettings();
+                callbackContext.success();
+                return true;
+            }
+
+            if ("getInitialNotification".equals(action)) {
+                callbackContext.success(initialNotification == null ? new JSONObject() : initialNotification);
+                initialNotification = null;
+                return true;
+            }
+        } catch (Exception error) {
+            callbackContext.error(error.getMessage());
+            return true;
+        }
+
+        return false;
+    }
+
+    @Override
+    public void onRequestPermissionResult(int requestCode, String[] permissions, int[] grantResults) {
+        if (requestCode != REQUEST_POST_NOTIFICATIONS || notificationPermissionCallback == null) {
+            return;
+        }
+
+        boolean granted = grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED;
+        try {
+            JSONObject result = notificationPermissionStatus();
+            result.put("requested", true);
+            result.put("granted", granted);
+            notificationPermissionCallback.success(result);
+        } catch (Exception error) {
+            notificationPermissionCallback.error(error.getMessage());
+        } finally {
+            notificationPermissionCallback = null;
+        }
+    }
+
+    private Context context() {
+        return this.cordova.getActivity().getApplicationContext();
+    }
+
+    static void ensureNotificationChannel(Context context) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            NotificationChannel channel = new NotificationChannel(
+                CHANNEL_ID,
+                "html2apk",
+                NotificationManager.IMPORTANCE_DEFAULT
+            );
+            channel.setDescription("Default channel for html2apk notifications.");
+            NotificationManager manager = context.getSystemService(NotificationManager.class);
+            if (manager != null) {
+                manager.createNotificationChannel(channel);
+            }
+        }
+    }
+
+    private boolean hasNotificationPermission() {
+        return Build.VERSION.SDK_INT < 33
+            || context().checkSelfPermission(Manifest.permission.POST_NOTIFICATIONS) == PackageManager.PERMISSION_GRANTED;
+    }
+
+    private void requestNotificationPermission(CallbackContext callbackContext) throws Exception {
+        if (Build.VERSION.SDK_INT < 33 || hasNotificationPermission()) {
+            callbackContext.success(notificationPermissionStatus());
+            return;
+        }
+
+        notificationPermissionCallback = callbackContext;
+        cordova.requestPermission(this, REQUEST_POST_NOTIFICATIONS, Manifest.permission.POST_NOTIFICATIONS);
+    }
+
+    private JSONObject notificationPermissionStatus() throws Exception {
+        JSONObject result = new JSONObject();
+        result.put("required", Build.VERSION.SDK_INT >= 33);
+        result.put("granted", hasNotificationPermission());
+        result.put("permission", "android.permission.POST_NOTIFICATIONS");
+        return result;
+    }
+
+    private void showNotification(JSONObject options) throws Exception {
+        if (!hasNotificationPermission()) {
+            throw new Exception("POST_NOTIFICATIONS permission is not granted. Call solicitarPermissaoNotificacoes() first.");
+        }
+
+        ensureNotificationChannel(context());
+        int id = notificationId(options);
+        String title = title(options);
+        String text = text(options);
+
+        NotificationCompat.Builder builder = new NotificationCompat.Builder(context(), CHANNEL_ID)
+            .setSmallIcon(context().getApplicationInfo().icon)
+            .setContentTitle(title)
+            .setContentText(text)
+            .setStyle(new NotificationCompat.BigTextStyle().bigText(text))
+            .setAutoCancel(true)
+            .setContentIntent(createContentIntent(context(), id, detailPayload(options)))
+            .setPriority(NotificationCompat.PRIORITY_DEFAULT);
+
+        NotificationManagerCompat.from(context()).notify(id, builder.build());
+    }
+
+    private void scheduleNotification(JSONObject options) throws Exception {
+        long when = options.optLong("quando", options.optLong("when", System.currentTimeMillis() + 60000));
+        if (when < System.currentTimeMillis()) {
+            when = System.currentTimeMillis() + 1000;
+        }
+
+        int id = notificationId(options);
+        NotificationStore.save(context(), id, when, options);
+        NotificationReceiver.schedule(context(), id, when, options, canScheduleExactAlarms());
+    }
+
+    private boolean canScheduleExactAlarms() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
+            return true;
+        }
+
+        AlarmManager alarmManager = (AlarmManager) context().getSystemService(Context.ALARM_SERVICE);
+        return alarmManager != null && alarmManager.canScheduleExactAlarms();
+    }
+
+    private void openExactAlarmSettings() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
+            return;
+        }
+
+        Intent intent = new Intent(Settings.ACTION_REQUEST_SCHEDULE_EXACT_ALARM);
+        intent.setData(Uri.parse("package:" + context().getPackageName()));
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        context().startActivity(intent);
+    }
+
+    private void vibrate(long ms) {
+        Vibrator vibrator = (Vibrator) context().getSystemService(Context.VIBRATOR_SERVICE);
+        if (vibrator == null) {
+            return;
+        }
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            vibrator.vibrate(VibrationEffect.createOneShot(ms, VibrationEffect.DEFAULT_AMPLITUDE));
+        } else {
+            vibrator.vibrate(ms);
+        }
+    }
+
+    private void toast(final String message) {
+        this.cordova.getActivity().runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                Toast.makeText(context(), message, Toast.LENGTH_SHORT).show();
+            }
+        });
+    }
+
+    private void setFullscreen(final boolean enabled) {
+        this.cordova.getActivity().runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                View decor = cordova.getActivity().getWindow().getDecorView();
+                if (enabled) {
+                    decor.setSystemUiVisibility(
+                        View.SYSTEM_UI_FLAG_FULLSCREEN
+                            | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
+                            | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
+                            | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
+                            | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
+                            | View.SYSTEM_UI_FLAG_LAYOUT_STABLE
+                    );
+                } else {
+                    decor.setSystemUiVisibility(View.SYSTEM_UI_FLAG_VISIBLE);
+                }
+            }
+        });
+    }
+
+    private void handleNotificationIntent(Intent intent, boolean dispatchToJs) {
+        if (intent == null || !intent.getBooleanExtra(EXTRA_NOTIFICATION_CLICKED, false)) {
+            return;
+        }
+
+        JSONObject detail = parseDetail(intent.getStringExtra(EXTRA_NOTIFICATION_DETAIL));
+        initialNotification = detail;
+
+        if (dispatchToJs) {
+            dispatchNotificationClick(detail);
+        }
+
+        intent.removeExtra(EXTRA_NOTIFICATION_CLICKED);
+        intent.removeExtra(EXTRA_NOTIFICATION_DETAIL);
+    }
+
+    private void dispatchNotificationClick(JSONObject detail) {
+        if (detail == null || webView == null) {
+            return;
+        }
+
+        final String script = "(function(){var detail=" + detail.toString()
+            + ";window.dispatchEvent(new CustomEvent('html2apk:notification',{detail:detail}));"
+            + "if(window.Html2ApkNative&&typeof window.Html2ApkNative.__emitNotificationClick==='function'){"
+            + "window.Html2ApkNative.__emitNotificationClick(detail);}})();";
+
+        cordova.getActivity().runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                webView.getEngine().evaluateJavascript(script, null);
+            }
+        });
+    }
+
+    private JSONObject parseDetail(String raw) {
+        try {
+            if (raw == null || raw.length() == 0) {
+                return null;
+            }
+            return new JSONObject(raw);
+        } catch (Exception ignored) {
+            return null;
+        }
+    }
+
+    static PendingIntent createContentIntent(Context context, int id, JSONObject detail) {
+        Intent launchIntent = context.getPackageManager().getLaunchIntentForPackage(context.getPackageName());
+        if (launchIntent == null) {
+            launchIntent = new Intent();
+            launchIntent.setPackage(context.getPackageName());
+        }
+
+        launchIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_SINGLE_TOP | Intent.FLAG_ACTIVITY_CLEAR_TOP);
+        launchIntent.putExtra(EXTRA_NOTIFICATION_CLICKED, true);
+        launchIntent.putExtra(EXTRA_NOTIFICATION_DETAIL, detail == null ? "{}" : detail.toString());
+
+        return PendingIntent.getActivity(
+            context,
+            id,
+            launchIntent,
+            PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE
+        );
+    }
+
+    static JSONObject detailPayload(JSONObject options) throws Exception {
+        JSONObject detail = new JSONObject();
+        JSONObject click = options.optJSONObject("aoClicar");
+        if (click == null) {
+            click = options.optJSONObject("onClick");
+        }
+
+        detail.put("id", notificationId(options));
+        detail.put("title", title(options));
+        detail.put("titulo", title(options));
+        detail.put("text", text(options));
+        detail.put("texto", text(options));
+        detail.put("when", options.optLong("quando", options.optLong("when", System.currentTimeMillis())));
+        detail.put("clickedAt", System.currentTimeMillis());
+        detail.put("onClick", click == null ? new JSONObject().put("action", "open-app") : click);
+        detail.put("aoClicar", click == null ? new JSONObject().put("acao", "abrir-app") : click);
+        return detail;
+    }
+
+    static int notificationId(JSONObject options) {
+        int id = options.optInt("id", 0);
+        if (id != 0) {
+            return id;
+        }
+        return (int) (System.currentTimeMillis() & 0x0fffffff);
+    }
+
+    static String title(JSONObject options) {
+        return options.optString("titulo", options.optString("title", "Notificacao"));
+    }
+
+    static String text(JSONObject options) {
+        return options.optString("texto", options.optString("text", ""));
+    }
+}

package/src/templates/cordova-plugin-html2apk-bridge/src/android/NotificationReceiver.java

@@ -0,0 +1,112 @@
+package dev.html2apk.bridge;
+
+import android.Manifest;
+import android.app.AlarmManager;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.os.Build;
+
+import androidx.core.app.NotificationCompat;
+import androidx.core.app.NotificationManagerCompat;
+
+import org.json.JSONObject;
+
+public class NotificationReceiver extends BroadcastReceiver {
+    private static final String EXTRA_NOTIFICATION_ID = "html2apk_notification_id";
+    private static final String EXTRA_NOTIFICATION_OPTIONS = "html2apk_notification_options";
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        if (Build.VERSION.SDK_INT >= 33 && context.checkSelfPermission(Manifest.permission.POST_NOTIFICATIONS) != PackageManager.PERMISSION_GRANTED) {
+            return;
+        }
+
+        JSONObject options = parseOptions(intent);
+        int id = intent.getIntExtra(EXTRA_NOTIFICATION_ID, Html2ApkBridge.notificationId(options));
+        NotificationStore.remove(context, id);
+
+        Html2ApkBridge.ensureNotificationChannel(context);
+
+        String title = Html2ApkBridge.title(options);
+        String text = Html2ApkBridge.text(options);
+        JSONObject detail;
+        try {
+            detail = Html2ApkBridge.detailPayload(options);
+        } catch (Exception error) {
+            detail = new JSONObject();
+        }
+
+        NotificationCompat.Builder builder = new NotificationCompat.Builder(context, Html2ApkBridge.CHANNEL_ID)
+            .setSmallIcon(context.getApplicationInfo().icon)
+            .setContentTitle(title)
+            .setContentText(text)
+            .setStyle(new NotificationCompat.BigTextStyle().bigText(text))
+            .setAutoCancel(true)
+            .setContentIntent(Html2ApkBridge.createContentIntent(context, id, detail))
+            .setPriority(NotificationCompat.PRIORITY_DEFAULT);
+
+        NotificationManagerCompat.from(context).notify(id, builder.build());
+    }
+
+    static void schedule(Context context, int id, long when, JSONObject options, boolean exactAllowed) {
+        Intent intent = new Intent(context, NotificationReceiver.class);
+        intent.putExtra(EXTRA_NOTIFICATION_ID, id);
+        intent.putExtra(EXTRA_NOTIFICATION_OPTIONS, options.toString());
+
+        PendingIntent pendingIntent = PendingIntent.getBroadcast(
+            context,
+            id,
+            intent,
+            PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE
+        );
+
+        AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
+        if (alarmManager == null) {
+            return;
+        }
+
+        if (exactAllowed) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                alarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, when, pendingIntent);
+            } else {
+                alarmManager.setExact(AlarmManager.RTC_WAKEUP, when, pendingIntent);
+            }
+        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            alarmManager.setAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, when, pendingIntent);
+        } else {
+            alarmManager.set(AlarmManager.RTC_WAKEUP, when, pendingIntent);
+        }
+    }
+
+    static void cancel(Context context, int id) {
+        Intent intent = new Intent(context, NotificationReceiver.class);
+        PendingIntent pendingIntent = PendingIntent.getBroadcast(
+            context,
+            id,
+            intent,
+            PendingIntent.FLAG_NO_CREATE | PendingIntent.FLAG_IMMUTABLE
+        );
+
+        if (pendingIntent == null) {
+            return;
+        }
+
+        AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
+        if (alarmManager != null) {
+            alarmManager.cancel(pendingIntent);
+        }
+        pendingIntent.cancel();
+    }
+
+    private static JSONObject parseOptions(Intent intent) {
+        try {
+            return new JSONObject(intent.getStringExtra(EXTRA_NOTIFICATION_OPTIONS));
+        } catch (Exception ignored) {
+            return new JSONObject();
+        }
+    }
+}

package/src/templates/cordova-plugin-html2apk-bridge/src/android/NotificationStore.java

@@ -0,0 +1,91 @@
+package dev.html2apk.bridge;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+public final class NotificationStore {
+    private static final String PREFS = "html2apk_notifications";
+    private static final String KEY_ITEMS = "items";
+
+    private NotificationStore() {}
+
+    static void save(Context context, int id, long when, JSONObject options) throws Exception {
+        JSONArray items = all(context);
+        JSONArray next = new JSONArray();
+
+        for (int index = 0; index < items.length(); index += 1) {
+            JSONObject item = items.optJSONObject(index);
+            if (item != null && item.optInt("id") != id) {
+                next.put(item);
+            }
+        }
+
+        JSONObject item = new JSONObject();
+        item.put("id", id);
+        item.put("when", when);
+        item.put("options", options);
+        next.put(item);
+        write(context, next);
+    }
+
+    static void remove(Context context, int id) {
+        try {
+            JSONArray items = all(context);
+            JSONArray next = new JSONArray();
+
+            for (int index = 0; index < items.length(); index += 1) {
+                JSONObject item = items.optJSONObject(index);
+                if (item != null && item.optInt("id") != id) {
+                    next.put(item);
+                }
+            }
+
+            write(context, next);
+        } catch (Exception ignored) {
+        }
+    }
+
+    static void rescheduleAll(Context context, boolean exactAllowed) {
+        try {
+            long now = System.currentTimeMillis();
+            JSONArray items = all(context);
+            JSONArray futureItems = new JSONArray();
+
+            for (int index = 0; index < items.length(); index += 1) {
+                JSONObject item = items.optJSONObject(index);
+                if (item == null) {
+                    continue;
+                }
+
+                int id = item.optInt("id");
+                long when = item.optLong("when");
+                JSONObject options = item.optJSONObject("options");
+                if (options == null || when <= now) {
+                    continue;
+                }
+
+                NotificationReceiver.schedule(context, id, when, options, exactAllowed);
+                futureItems.put(item);
+            }
+
+            write(context, futureItems);
+        } catch (Exception ignored) {
+        }
+    }
+
+    private static JSONArray all(Context context) throws Exception {
+        String raw = prefs(context).getString(KEY_ITEMS, "[]");
+        return new JSONArray(raw);
+    }
+
+    private static void write(Context context, JSONArray items) {
+        prefs(context).edit().putString(KEY_ITEMS, items.toString()).apply();
+    }
+
+    private static SharedPreferences prefs(Context context) {
+        return context.getSharedPreferences(PREFS, Context.MODE_PRIVATE);
+    }
+}

package/src/templates/cordova-plugin-html2apk-bridge/www/html2apk-bridge.js

@@ -0,0 +1,129 @@
+"use strict";
+
+var exec = require("cordova/exec");
+
+var notificationListeners = [];
+var initialNotification = null;
+
+function call(action, args) {
+  return new Promise(function (resolve, reject) {
+    exec(resolve, reject, "Html2ApkBridge", action, args || []);
+  });
+}
+
+function normalizeNotificationOptions(messageOrOptions) {
+  if (typeof messageOrOptions === "string") {
+    return {
+      title: "Notificacao",
+      text: messageOrOptions,
+      onClick: {
+        action: "open-app"
+      }
+    };
+  }
+
+  var options = messageOrOptions || {};
+  if (!options.onClick && !options.aoClicar) {
+    options.onClick = {
+      action: "open-app"
+    };
+  }
+  return options;
+}
+
+function emitNotificationClick(detail) {
+  initialNotification = detail || null;
+
+  notificationListeners.slice().forEach(function (listener) {
+    try {
+      listener(initialNotification);
+    } catch (error) {
+      setTimeout(function () {
+        throw error;
+      }, 0);
+    }
+  });
+}
+
+var api = {
+  notificar: function (messageOrOptions) {
+    return call("notify", [normalizeNotificationOptions(messageOrOptions)]);
+  },
+  agendarNotificacao: function (options) {
+    return call("scheduleNotification", [normalizeNotificationOptions(options || {})]);
+  },
+  vibrar: function (ms) {
+    return call("vibrate", [Number(ms) || 200]);
+  },
+  toast: function (message) {
+    return call("toast", [String(message || "")]);
+  },
+  fullscreen: function (enabled) {
+    return call("fullscreen", [Boolean(enabled)]);
+  },
+  solicitarPermissaoNotificacoes: function () {
+    return call("requestNotificationPermission");
+  },
+  statusPermissaoNotificacoes: function () {
+    return call("notificationPermissionStatus");
+  },
+  podeAgendarNotificacaoExata: function () {
+    return call("canScheduleExactAlarms");
+  },
+  abrirConfiguracaoAlarmeExato: function () {
+    return call("openExactAlarmSettings");
+  },
+  obterNotificacaoInicial: function () {
+    return call("getInitialNotification").then(function (notification) {
+      initialNotification = notification && notification.id ? notification : null;
+      return initialNotification;
+    });
+  },
+  aoClicarNotificacao: function (listener) {
+    if (typeof listener !== "function") {
+      throw new TypeError("listener must be a function");
+    }
+
+    notificationListeners.push(listener);
+    if (initialNotification) {
+      listener(initialNotification);
+    }
+
+    return function unsubscribe() {
+      notificationListeners = notificationListeners.filter(function (item) {
+        return item !== listener;
+      });
+    };
+  },
+  __emitNotificationClick: function (detail) {
+    emitNotificationClick(detail);
+  }
+};
+
+if (typeof window !== "undefined") {
+  window.notificar = api.notificar;
+  window.agendarNotificacao = api.agendarNotificacao;
+  window.vibrar = api.vibrar;
+  window.toast = api.toast;
+  window.fullscreen = api.fullscreen;
+  window.solicitarPermissaoNotificacoes = api.solicitarPermissaoNotificacoes;
+  window.statusPermissaoNotificacoes = api.statusPermissaoNotificacoes;
+  window.podeAgendarNotificacaoExata = api.podeAgendarNotificacaoExata;
+  window.abrirConfiguracaoAlarmeExato = api.abrirConfiguracaoAlarmeExato;
+  window.obterNotificacaoInicial = api.obterNotificacaoInicial;
+  window.aoClicarNotificacao = api.aoClicarNotificacao;
+
+  window.addEventListener("html2apk:notification", function (event) {
+    emitNotificationClick(event.detail);
+  });
+
+  document.addEventListener("deviceready", function () {
+    api.obterNotificacaoInicial().then(function (notification) {
+      if (notification) {
+        emitNotificationClick(notification);
+      }
+    });
+  }, false);
+}
+
+module.exports = api;