html2apk 0.2.0 → 0.4.0

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

@@ -1,26 +1,49 @@
 package dev.html2apk.bridge;
 
 import android.Manifest;
+import android.app.Activity;
 import android.app.AlarmManager;
+import android.app.ActivityManager;
 import android.app.NotificationChannel;
 import android.app.NotificationManager;
 import android.app.PendingIntent;
+import android.content.ActivityNotFoundException;
+import android.content.BroadcastReceiver;
 import android.content.ClipData;
 import android.content.ClipboardManager;
 import android.content.Context;
 import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.SharedPreferences;
+import android.content.pm.ApplicationInfo;
 import android.content.pm.PackageManager;
+import android.database.Cursor;
+import android.hardware.camera2.CameraCharacteristics;
+import android.hardware.camera2.CameraManager;
+import android.graphics.Color;
+import android.media.MediaRecorder;
+import android.net.ConnectivityManager;
+import android.net.Network;
+import android.net.NetworkCapabilities;
 import android.net.Uri;
+import android.os.BatteryManager;
 import android.os.Build;
+import android.os.Debug;
+import android.os.Environment;
+import android.os.StatFs;
 import android.os.VibrationEffect;
 import android.os.Vibrator;
 import android.provider.Settings;
+import android.provider.OpenableColumns;
+import android.util.Base64;
 import android.view.View;
+import android.view.Window;
 import android.view.WindowManager;
 import android.widget.Toast;
 
 import androidx.core.app.NotificationCompat;
 import androidx.core.app.NotificationManagerCompat;
+import androidx.core.content.ContextCompat;
 
 import org.apache.cordova.CallbackContext;
 import org.apache.cordova.CordovaInterface;
@@ -29,40 +52,96 @@ import org.apache.cordova.CordovaWebView;
 import org.json.JSONArray;
 import org.json.JSONObject;
 
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.List;
+
 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 static final int REQUEST_CAMERA = 7312;
+    private static final int REQUEST_RECORD_AUDIO = 7313;
+    private static final int REQUEST_PICK_FILE = 7411;
+    private static final int REQUEST_SAVE_FILE = 7412;
+    private static final int REQUEST_PICK_FOLDER = 7413;
+    private static final String PREFS_NAME = "html2apk_bridge";
+    private static final String PREF_PERMISSION_PREFIX = "permission_requested_";
 
     private CallbackContext notificationPermissionCallback;
+    private CallbackContext cameraPermissionCallback;
+    private CallbackContext pendingNotificationCallback;
+    private CallbackContext pendingFlashlightCallback;
+    private CallbackContext microphonePermissionCallback;
+    private CallbackContext pendingMicStartCallback;
+    private CallbackContext filePickerCallback;
+    private CallbackContext saveFileCallback;
+    private CallbackContext folderPickerCallback;
+    private JSONObject pendingSaveFile;
+    private JSONObject pendingNotificationOptions;
     private JSONObject initialNotification;
+    private JSONObject initialLink;
+    private Boolean pendingFlashlightEnabled;
+    private boolean pendingNotificationSchedule;
+    private boolean pendingFlashlightToggle;
     private boolean overlaySettingsOpened;
+    private boolean torchEnabled;
+    private MediaRecorder micRecorder;
+    private File micRecordingFile;
+    private long micRecordingStartedAt;
+    private BroadcastReceiver systemReceiver;
 
     @Override
     public void initialize(CordovaInterface cordova, CordovaWebView webView) {
         super.initialize(cordova, webView);
         handleNotificationIntent(cordova.getActivity().getIntent(), false);
+        handleLinkIntent(cordova.getActivity().getIntent(), false);
+        registerSystemReceiver();
         startFloatingModeIfNeeded();
     }
 
     @Override
     public void onNewIntent(Intent intent) {
         handleNotificationIntent(intent, true);
+        handleLinkIntent(intent, true);
     }
 
     @Override
     public void onResume(boolean multitasking) {
         super.onResume(multitasking);
+        dispatchEvent("app:voltou", baseEvent("app:voltou"));
         startFloatingModeIfNeeded();
     }
 
+    @Override
+    public void onPause(boolean multitasking) {
+        dispatchEvent("app:pausado", baseEvent("app:pausado"));
+        dispatchEvent("app:background", baseEvent("app:background"));
+        super.onPause(multitasking);
+    }
+
+    @Override
+    public void onDestroy() {
+        stopMicRecorderSilently();
+        unregisterSystemReceiver();
+        dispatchEvent("app:fechado", baseEvent("app:fechado"));
+        super.onDestroy();
+    }
+
     @Override
     public boolean execute(String action, JSONArray args, CallbackContext callbackContext) {
         try {
             if ("notify".equals(action)) {
                 JSONObject options = args.optJSONObject(0);
+                if (requestNotificationPermissionForAction(options == null ? new JSONObject() : options, false, callbackContext)) {
+                    return true;
+                }
                 showNotification(options == null ? new JSONObject() : options);
                 callbackContext.success();
                 return true;
@@ -70,7 +149,15 @@ public class Html2ApkBridge extends CordovaPlugin {
 
             if ("scheduleNotification".equals(action)) {
                 JSONObject options = args.optJSONObject(0);
-                scheduleNotification(options == null ? new JSONObject() : options);
+                if (requestNotificationPermissionForAction(options == null ? new JSONObject() : options, true, callbackContext)) {
+                    return true;
+                }
+                callbackContext.success(scheduleNotification(options == null ? new JSONObject() : options));
+                return true;
+            }
+
+            if ("cancelNotification".equals(action)) {
+                cancelNotification(args.opt(0));
                 callbackContext.success();
                 return true;
             }
@@ -105,24 +192,153 @@ public class Html2ApkBridge extends CordovaPlugin {
                 return true;
             }
 
+            if ("setSystemBarsColor".equals(action)) {
+                callbackContext.success(setSystemBarsColor(args.opt(0)));
+                return true;
+            }
+
+            if ("flashlight".equals(action)) {
+                setFlashlightWithPermission(args.optBoolean(0, true), false, callbackContext);
+                return true;
+            }
+
+            if ("toggleFlashlight".equals(action)) {
+                setFlashlightWithPermission(false, true, callbackContext);
+                return true;
+            }
+
+            if ("flashlightStatus".equals(action)) {
+                callbackContext.success(flashlightStatus());
+                return true;
+            }
+
+            if ("requestCameraPermission".equals(action)) {
+                requestCameraPermission(callbackContext);
+                return true;
+            }
+
+            if ("requestMicrophonePermission".equals(action)) {
+                requestMicrophonePermission(callbackContext);
+                return true;
+            }
+
+            if ("microphoneStatus".equals(action)) {
+                callbackContext.success(microphoneStatus());
+                return true;
+            }
+
+            if ("startMic".equals(action)) {
+                startMicRecording(callbackContext);
+                return true;
+            }
+
+            if ("stopMic".equals(action)) {
+                callbackContext.success(stopMicRecording());
+                return true;
+            }
+
             if ("copyText".equals(action)) {
                 copyText(args.optString(0, ""));
                 callbackContext.success();
                 return true;
             }
 
+            if ("readText".equals(action)) {
+                callbackContext.success(readText());
+                return true;
+            }
+
             if ("shareText".equals(action)) {
                 shareText(args.optString(0, ""));
                 callbackContext.success();
                 return true;
             }
 
+            if ("share".equals(action)) {
+                share(args.optJSONObject(0));
+                callbackContext.success();
+                return true;
+            }
+
             if ("openUrl".equals(action)) {
                 openUrl(args.optString(0, ""));
                 callbackContext.success();
                 return true;
             }
 
+            if ("dial".equals(action)) {
+                dial(args.optString(0, ""));
+                callbackContext.success();
+                return true;
+            }
+
+            if ("openMap".equals(action)) {
+                openMap(args.optString(0, ""));
+                callbackContext.success();
+                return true;
+            }
+
+            if ("openWhatsapp".equals(action)) {
+                openWhatsapp(args.optString(0, ""), args.optString(1, ""));
+                callbackContext.success();
+                return true;
+            }
+
+            if ("pickFile".equals(action)) {
+                pickFile(args.optJSONObject(0), callbackContext);
+                return true;
+            }
+
+            if ("pickFolder".equals(action)) {
+                pickFolder(callbackContext);
+                return true;
+            }
+
+            if ("saveFile".equals(action)) {
+                saveFile(args.optJSONObject(0), callbackContext);
+                return true;
+            }
+
+            if ("deviceInfo".equals(action)) {
+                callbackContext.success(deviceInfo());
+                return true;
+            }
+
+            if ("networkInfo".equals(action)) {
+                callbackContext.success(networkInfo());
+                return true;
+            }
+
+            if ("batteryInfo".equals(action)) {
+                callbackContext.success(batteryInfo());
+                return true;
+            }
+
+            if ("memoryInfo".equals(action)) {
+                callbackContext.success(memoryInfo());
+                return true;
+            }
+
+            if ("storageInfo".equals(action)) {
+                callbackContext.success(storageInfo());
+                return true;
+            }
+
+            if ("performanceInfo".equals(action)) {
+                callbackContext.success(performanceInfo());
+                return true;
+            }
+
+            if ("openAppsMemory".equals(action)) {
+                callbackContext.success(openAppsMemoryInfo());
+                return true;
+            }
+
+            if ("permissionStatus".equals(action)) {
+                callbackContext.success(permissionStatus(args.optJSONArray(0)));
+                return true;
+            }
+
             if ("requestNotificationPermission".equals(action)) {
                 requestNotificationPermission(callbackContext);
                 return true;
@@ -140,7 +356,14 @@ public class Html2ApkBridge extends CordovaPlugin {
 
             if ("openExactAlarmSettings".equals(action)) {
                 openExactAlarmSettings();
-                callbackContext.success();
+                JSONObject result = new JSONObject();
+                result.put("permission", "android.permission.SCHEDULE_EXACT_ALARM");
+                result.put("required", Build.VERSION.SDK_INT >= Build.VERSION_CODES.S);
+                result.put("granted", canScheduleExactAlarms());
+                result.put("permissionGranted", canScheduleExactAlarms());
+                result.put("requiresSettings", Build.VERSION.SDK_INT >= Build.VERSION_CODES.S && !canScheduleExactAlarms());
+                result.put("settingsOpened", Build.VERSION.SDK_INT >= Build.VERSION_CODES.S && !canScheduleExactAlarms());
+                callbackContext.success(result);
                 return true;
             }
 
@@ -151,11 +374,22 @@ public class Html2ApkBridge extends CordovaPlugin {
 
             if ("requestOverlayPermission".equals(action) || "openOverlaySettings".equals(action)) {
                 openOverlaySettings();
-                callbackContext.success(overlayPermissionStatus());
+                JSONObject result = overlayPermissionStatus();
+                result.put("requested", true);
+                result.put("settingsOpened", result.optBoolean("requiresSettings"));
+                callbackContext.success(result);
                 return true;
             }
 
             if ("startFloatingIcon".equals(action)) {
+                if (!canDrawOverlays()) {
+                    openOverlaySettings();
+                    JSONObject result = overlayPermissionStatus();
+                    result.put("requested", true);
+                    result.put("requiresSettings", true);
+                    callbackContext.success(result);
+                    return true;
+                }
                 startFloatingIcon();
                 callbackContext.success(overlayPermissionStatus());
                 return true;
@@ -172,6 +406,12 @@ public class Html2ApkBridge extends CordovaPlugin {
                 initialNotification = null;
                 return true;
             }
+
+            if ("getInitialLink".equals(action)) {
+                callbackContext.success(initialLink == null ? new JSONObject() : initialLink);
+                initialLink = null;
+                return true;
+            }
         } catch (Exception error) {
             callbackContext.error(error.getMessage());
             return true;
@@ -182,13 +422,142 @@ public class Html2ApkBridge extends CordovaPlugin {
 
     @Override
     public void onRequestPermissionResult(int requestCode, String[] permissions, int[] grantResults) {
-        if (requestCode != REQUEST_POST_NOTIFICATIONS || notificationPermissionCallback == null) {
+        if (requestCode == REQUEST_CAMERA) {
+            boolean granted = grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED;
+            if (pendingFlashlightCallback != null) {
+                CallbackContext callback = pendingFlashlightCallback;
+                Boolean enabled = pendingFlashlightEnabled;
+                boolean toggle = pendingFlashlightToggle;
+                pendingFlashlightCallback = null;
+                pendingFlashlightEnabled = null;
+                pendingFlashlightToggle = false;
+
+                try {
+                    if (!granted) {
+                        JSONObject result = shouldOpenSettingsForRuntimePermission(Manifest.permission.CAMERA)
+                            ? openSettingsForRuntimePermission(Manifest.permission.CAMERA, true, true)
+                            : flashlightStatus();
+                        result.put("requested", true);
+                        result.put("granted", false);
+                        callback.success(result);
+                        return;
+                    }
+
+                    setFlashlight(toggle ? !torchEnabled : Boolean.TRUE.equals(enabled));
+                    JSONObject result = flashlightStatus();
+                    result.put("requested", true);
+                    result.put("granted", true);
+                    callback.success(result);
+                } catch (Exception error) {
+                    callback.error(error.getMessage());
+                }
+                return;
+            }
+
+            if (cameraPermissionCallback == null) {
+                return;
+            }
+
+            try {
+                JSONObject result = granted
+                    ? runtimePermissionResult(Manifest.permission.CAMERA, true, true, true)
+                    : (
+                        shouldOpenSettingsForRuntimePermission(Manifest.permission.CAMERA)
+                            ? openSettingsForRuntimePermission(Manifest.permission.CAMERA, true, true)
+                            : runtimePermissionResult(Manifest.permission.CAMERA, true, true, false)
+                    );
+                cameraPermissionCallback.success(result);
+            } catch (Exception error) {
+                cameraPermissionCallback.error(error.getMessage());
+            } finally {
+                cameraPermissionCallback = null;
+            }
+            return;
+        }
+
+        if (requestCode == REQUEST_RECORD_AUDIO) {
+            boolean granted = grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED;
+            CallbackContext callback = pendingMicStartCallback != null ? pendingMicStartCallback : microphonePermissionCallback;
+            boolean shouldStartRecording = pendingMicStartCallback != null;
+            pendingMicStartCallback = null;
+            microphonePermissionCallback = null;
+
+            if (callback == null) {
+                return;
+            }
+
+            try {
+                if (shouldStartRecording && granted) {
+                    startMicRecorder(callback);
+                } else {
+                    JSONObject result = granted
+                        ? microphoneStatus()
+                        : (
+                            shouldOpenSettingsForRuntimePermission(Manifest.permission.RECORD_AUDIO)
+                                ? openSettingsForRuntimePermission(Manifest.permission.RECORD_AUDIO, true, true)
+                                : microphoneStatus()
+                        );
+                    result.put("requested", true);
+                    result.put("granted", granted);
+                    callback.success(result);
+                }
+            } catch (Exception error) {
+                callback.error(error.getMessage());
+            }
+            return;
+        }
+
+        if (requestCode != REQUEST_POST_NOTIFICATIONS) {
             return;
         }
 
         boolean granted = grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED;
+        if (pendingNotificationCallback != null) {
+            CallbackContext callback = pendingNotificationCallback;
+            JSONObject options = pendingNotificationOptions == null ? new JSONObject() : pendingNotificationOptions;
+            boolean schedule = pendingNotificationSchedule;
+            pendingNotificationCallback = null;
+            pendingNotificationOptions = null;
+            pendingNotificationSchedule = false;
+
+            try {
+                if (!granted) {
+                    JSONObject result = shouldOpenSettingsForRuntimePermission(Manifest.permission.POST_NOTIFICATIONS)
+                        ? openSettingsForRuntimePermission(Manifest.permission.POST_NOTIFICATIONS, true, true)
+                        : notificationPermissionStatus();
+                    result.put("requested", true);
+                    result.put("granted", false);
+                    callback.success(result);
+                    return;
+                }
+
+                if (schedule) {
+                    JSONObject result = scheduleNotification(options);
+                    result.put("requested", true);
+                    result.put("granted", true);
+                    callback.success(result);
+                } else {
+                    showNotification(options);
+                    callback.success();
+                }
+            } catch (Exception error) {
+                callback.error(error.getMessage());
+            }
+            return;
+        }
+
+        if (notificationPermissionCallback == null) {
+            return;
+        }
+
         try {
-            JSONObject result = notificationPermissionStatus();
+            JSONObject result = granted
+                ? notificationPermissionStatus()
+                : (
+                    shouldOpenSettingsForRuntimePermission(Manifest.permission.POST_NOTIFICATIONS)
+                        ? openSettingsForRuntimePermission(Manifest.permission.POST_NOTIFICATIONS, true, true)
+                        : notificationPermissionStatus()
+                );
             result.put("requested", true);
             result.put("granted", granted);
             notificationPermissionCallback.success(result);
@@ -199,10 +568,99 @@ public class Html2ApkBridge extends CordovaPlugin {
         }
     }
 
+    @Override
+    public void onActivityResult(int requestCode, int resultCode, Intent intent) {
+        if (requestCode == REQUEST_PICK_FILE) {
+            handlePickFileResult(resultCode, intent);
+            return;
+        }
+
+        if (requestCode == REQUEST_SAVE_FILE) {
+            handleSaveFileResult(resultCode, intent);
+            return;
+        }
+
+        if (requestCode == REQUEST_PICK_FOLDER) {
+            handlePickFolderResult(resultCode, intent);
+        }
+    }
+
     private Context context() {
         return this.cordova.getActivity().getApplicationContext();
     }
 
+    private SharedPreferences preferencesStore() {
+        return context().getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
+    }
+
+    private boolean wasRuntimePermissionRequested(String permission) {
+        return preferencesStore().getBoolean(PREF_PERMISSION_PREFIX + permission, false);
+    }
+
+    private void rememberRuntimePermissionRequest(String permission) {
+        preferencesStore().edit().putBoolean(PREF_PERMISSION_PREFIX + permission, true).apply();
+    }
+
+    private boolean shouldOpenSettingsForRuntimePermission(String permission) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M || !wasRuntimePermissionRequested(permission)) {
+            return false;
+        }
+
+        return !cordova.getActivity().shouldShowRequestPermissionRationale(permission);
+    }
+
+    private JSONObject runtimePermissionResult(String permission, boolean required, boolean requested, boolean granted) throws Exception {
+        JSONObject result = new JSONObject();
+        result.put("permission", permission);
+        result.put("required", required);
+        result.put("requested", requested);
+        result.put("granted", granted);
+        result.put("permissionGranted", granted);
+        result.put("requiresSettings", required && !granted && shouldOpenSettingsForRuntimePermission(permission));
+        result.put("settingsOpened", false);
+        return result;
+    }
+
+    private JSONObject openSettingsForRuntimePermission(String permission, boolean required, boolean requested) throws Exception {
+        JSONObject result = runtimePermissionResult(permission, required, requested, false);
+        openPermissionSettings(permission);
+        result.put("requiresSettings", true);
+        result.put("settingsOpened", true);
+        result.put("settingsScreen", Manifest.permission.POST_NOTIFICATIONS.equals(permission) ? "notifications" : "app");
+        result.put("telaConfiguracao", result.optString("settingsScreen"));
+        return result;
+    }
+
+    private void openPermissionSettings(String permission) {
+        if (Manifest.permission.POST_NOTIFICATIONS.equals(permission)) {
+            openNotificationSettings();
+            return;
+        }
+
+        openAppSettings();
+    }
+
+    private void openAppSettings() {
+        Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
+        intent.setData(Uri.parse("package:" + context().getPackageName()));
+        cordova.getActivity().startActivity(intent);
+    }
+
+    private void openNotificationSettings() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+            openAppSettings();
+            return;
+        }
+
+        Intent intent = new Intent(Settings.ACTION_APP_NOTIFICATION_SETTINGS);
+        intent.putExtra(Settings.EXTRA_APP_PACKAGE, context().getPackageName());
+        try {
+            cordova.getActivity().startActivity(intent);
+        } catch (ActivityNotFoundException error) {
+            openAppSettings();
+        }
+    }
+
     private boolean isFloatingMode() {
         return "floating".equals(preferences.getString("Html2ApkMode", ""));
     }
@@ -238,17 +696,24 @@ public class Html2ApkBridge extends CordovaPlugin {
         result.put("required", Build.VERSION.SDK_INT >= Build.VERSION_CODES.M);
         result.put("granted", canDrawOverlays());
         result.put("permission", "android.permission.SYSTEM_ALERT_WINDOW");
+        result.put("permissionGranted", canDrawOverlays());
+        result.put("requiresSettings", Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && !canDrawOverlays());
+        result.put("settingsOpened", false);
         return result;
     }
 
     private void openOverlaySettings() {
-        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M || canDrawOverlays()) {
             return;
         }
 
         Intent intent = new Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION);
         intent.setData(Uri.parse("package:" + context().getPackageName()));
-        cordova.getActivity().startActivity(intent);
+        try {
+            cordova.getActivity().startActivity(intent);
+        } catch (ActivityNotFoundException error) {
+            openAppSettings();
+        }
     }
 
     private void startFloatingIcon() throws Exception {
@@ -292,21 +757,42 @@ public class Html2ApkBridge extends CordovaPlugin {
             return;
         }
 
+        if (shouldOpenSettingsForRuntimePermission(Manifest.permission.POST_NOTIFICATIONS)) {
+            callbackContext.success(openSettingsForRuntimePermission(Manifest.permission.POST_NOTIFICATIONS, true, false));
+            return;
+        }
+
         notificationPermissionCallback = callbackContext;
+        rememberRuntimePermissionRequest(Manifest.permission.POST_NOTIFICATIONS);
         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;
+        boolean required = Build.VERSION.SDK_INT >= 33;
+        return runtimePermissionResult(Manifest.permission.POST_NOTIFICATIONS, required, false, hasNotificationPermission());
+    }
+
+    private boolean requestNotificationPermissionForAction(JSONObject options, boolean schedule, CallbackContext callbackContext) throws Exception {
+        if (hasNotificationPermission()) {
+            return false;
+        }
+
+        if (shouldOpenSettingsForRuntimePermission(Manifest.permission.POST_NOTIFICATIONS)) {
+            callbackContext.success(openSettingsForRuntimePermission(Manifest.permission.POST_NOTIFICATIONS, true, false));
+            return true;
+        }
+
+        pendingNotificationOptions = options;
+        pendingNotificationSchedule = schedule;
+        pendingNotificationCallback = callbackContext;
+        rememberRuntimePermissionRequest(Manifest.permission.POST_NOTIFICATIONS);
+        cordova.requestPermission(this, REQUEST_POST_NOTIFICATIONS, Manifest.permission.POST_NOTIFICATIONS);
+        return true;
     }
 
     private void showNotification(JSONObject options) throws Exception {
         if (!hasNotificationPermission()) {
-            throw new Exception("POST_NOTIFICATIONS permission is not granted. Call solicitarPermissaoNotificacoes() first.");
+            throw new Exception("POST_NOTIFICATIONS permission is not granted.");
         }
 
         ensureNotificationChannel(context());
@@ -323,38 +809,83 @@ public class Html2ApkBridge extends CordovaPlugin {
             .setContentIntent(createContentIntent(context(), id, detailPayload(options)))
             .setPriority(NotificationCompat.PRIORITY_DEFAULT);
 
+        addNotificationActions(builder, context(), id, options);
         NotificationManagerCompat.from(context()).notify(id, builder.build());
+        dispatchEvent("notificacao:recebida", detailPayload(options));
     }
 
-    private void scheduleNotification(JSONObject options) throws Exception {
+    private JSONObject 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);
+        options.put("id", id);
+        options.put("quando", when);
+        options.put("when", when);
+        boolean exactRequested = wantsExactAlarm(options);
+        boolean exactAllowed = canScheduleExactAlarms();
+        boolean settingsOpened = false;
+        if (exactRequested && !exactAllowed) {
+            openExactAlarmSettings();
+            settingsOpened = true;
+        }
         NotificationStore.save(context(), id, when, options);
-        NotificationReceiver.schedule(context(), id, when, options, canScheduleExactAlarms());
+        NotificationReceiver.schedule(context(), id, when, options, exactAllowed);
+
+        JSONObject result = new JSONObject();
+        result.put("id", id);
+        result.put("when", when);
+        result.put("quando", when);
+        result.put("repeating", repeatInterval(options) > 0);
+        result.put("loop", loopNotifications(options).length() > 0);
+        result.put("exactRequested", exactRequested);
+        result.put("exatoSolicitado", exactRequested);
+        result.put("exactAllowed", exactAllowed);
+        result.put("exatoPermitido", exactAllowed);
+        result.put("requiresSettings", exactRequested && !exactAllowed);
+        result.put("settingsOpened", settingsOpened);
+        return result;
     }
 
-    private boolean canScheduleExactAlarms() {
-        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
-            return true;
+    private boolean wantsExactAlarm(JSONObject options) {
+        return options.optBoolean("exato",
+            options.optBoolean("exact",
+                options.optBoolean("alarmeExato",
+                    options.optBoolean("exactAlarm",
+                        options.optBoolean("preciso",
+                            options.optBoolean("precise", false))))));
+    }
+
+    private void cancelNotification(Object input) throws Exception {
+        int id = notificationIdFromObject(input);
+        if (id == 0) {
+            throw new Exception("Notification id is required.");
         }
 
-        AlarmManager alarmManager = (AlarmManager) context().getSystemService(Context.ALARM_SERVICE);
-        return alarmManager != null && alarmManager.canScheduleExactAlarms();
+        NotificationReceiver.cancel(context(), id);
+        NotificationStore.remove(context(), id);
+        NotificationManagerCompat.from(context()).cancel(id);
+    }
+
+    private boolean canScheduleExactAlarms() {
+        return canScheduleExactAlarms(context());
     }
 
     private void openExactAlarmSettings() {
-        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S || canScheduleExactAlarms()) {
             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);
+        try {
+            context().startActivity(intent);
+        } catch (ActivityNotFoundException error) {
+            openAppSettings();
+        }
     }
 
     private void vibrate(long ms) {
@@ -428,6 +959,83 @@ public class Html2ApkBridge extends CordovaPlugin {
         });
     }
 
+    private JSONObject setSystemBarsColor(Object input) throws Exception {
+        final JSONObject options = normalizeSystemBarsOptions(input);
+        final String statusColor = options.optString("statusBarColor", options.optString("color", options.optString("cor", "#126fff")));
+        final String navigationColor = options.optString("navigationBarColor", options.optString("navigationColor", statusColor));
+        final boolean darkStatusIcons = options.optBoolean("darkIcons", isLightColor(statusColor));
+        final boolean darkNavigationIcons = options.optBoolean("darkNavigationIcons", isLightColor(navigationColor));
+        final int statusBarColor = Color.parseColor(statusColor);
+        final int navigationBarColor = Color.parseColor(navigationColor);
+
+        this.cordova.getActivity().runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                Window window = cordova.getActivity().getWindow();
+                window.setStatusBarColor(statusBarColor);
+                window.setNavigationBarColor(navigationBarColor);
+                applySystemBarIconContrast(window, darkStatusIcons, darkNavigationIcons);
+            }
+        });
+
+        JSONObject result = new JSONObject();
+        result.put("statusBarColor", statusColor);
+        result.put("navigationBarColor", navigationColor);
+        result.put("darkIcons", darkStatusIcons);
+        result.put("darkNavigationIcons", darkNavigationIcons);
+        result.put("applied", true);
+        return result;
+    }
+
+    private JSONObject normalizeSystemBarsOptions(Object input) throws Exception {
+        if (input instanceof JSONObject) {
+            return (JSONObject) input;
+        }
+
+        JSONObject options = new JSONObject();
+        String color = input == null ? "#126fff" : String.valueOf(input);
+        options.put("color", color);
+        options.put("statusBarColor", color);
+        options.put("navigationBarColor", color);
+        return options;
+    }
+
+    private boolean isLightColor(String color) {
+        try {
+            int parsed = Color.parseColor(color);
+            int red = Color.red(parsed);
+            int green = Color.green(parsed);
+            int blue = Color.blue(parsed);
+            double luminance = (0.2126 * red) + (0.7152 * green) + (0.0722 * blue);
+            return luminance > 158;
+        } catch (Exception ignored) {
+            return false;
+        }
+    }
+
+    private void applySystemBarIconContrast(Window window, boolean darkStatusIcons, boolean darkNavigationIcons) {
+        View decor = window.getDecorView();
+        int flags = decor.getSystemUiVisibility();
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            if (darkStatusIcons) {
+                flags |= View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR;
+            } else {
+                flags &= ~View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR;
+            }
+        }
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            if (darkNavigationIcons) {
+                flags |= View.SYSTEM_UI_FLAG_LIGHT_NAVIGATION_BAR;
+            } else {
+                flags &= ~View.SYSTEM_UI_FLAG_LIGHT_NAVIGATION_BAR;
+            }
+        }
+
+        decor.setSystemUiVisibility(flags);
+    }
+
     private void copyText(String text) {
         ClipboardManager clipboard = (ClipboardManager) context().getSystemService(Context.CLIPBOARD_SERVICE);
         if (clipboard != null) {
@@ -451,33 +1059,926 @@ public class Html2ApkBridge extends CordovaPlugin {
         cordova.getActivity().startActivity(intent);
     }
 
-    private void handleNotificationIntent(Intent intent, boolean dispatchToJs) {
-        if (intent == null || !intent.getBooleanExtra(EXTRA_NOTIFICATION_CLICKED, false)) {
+    private boolean hasCameraPermission() {
+        return ContextCompat.checkSelfPermission(context(), Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED;
+    }
+
+    private void requestCameraPermission(CallbackContext callbackContext) throws Exception {
+        if (hasCameraPermission()) {
+            callbackContext.success(runtimePermissionResult(Manifest.permission.CAMERA, true, false, true));
             return;
         }
 
-        JSONObject detail = parseDetail(intent.getStringExtra(EXTRA_NOTIFICATION_DETAIL));
-        initialNotification = detail;
-
-        if (dispatchToJs) {
-            dispatchNotificationClick(detail);
+        if (shouldOpenSettingsForRuntimePermission(Manifest.permission.CAMERA)) {
+            callbackContext.success(openSettingsForRuntimePermission(Manifest.permission.CAMERA, true, false));
+            return;
         }
 
-        intent.removeExtra(EXTRA_NOTIFICATION_CLICKED);
-        intent.removeExtra(EXTRA_NOTIFICATION_DETAIL);
+        cameraPermissionCallback = callbackContext;
+        rememberRuntimePermissionRequest(Manifest.permission.CAMERA);
+        cordova.requestPermission(this, REQUEST_CAMERA, Manifest.permission.CAMERA);
     }
 
-    private void dispatchNotificationClick(JSONObject detail) {
-        if (detail == null || webView == null) {
+    private boolean hasMicrophonePermission() {
+        return ContextCompat.checkSelfPermission(context(), Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED;
+    }
+
+    private void requestMicrophonePermission(CallbackContext callbackContext) throws Exception {
+        if (hasMicrophonePermission()) {
+            JSONObject result = microphoneStatus();
+            result.put("requested", false);
+            result.put("granted", true);
+            callbackContext.success(result);
             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);}})();";
+        if (shouldOpenSettingsForRuntimePermission(Manifest.permission.RECORD_AUDIO)) {
+            callbackContext.success(openSettingsForRuntimePermission(Manifest.permission.RECORD_AUDIO, true, false));
+            return;
+        }
 
-        cordova.getActivity().runOnUiThread(new Runnable() {
+        microphonePermissionCallback = callbackContext;
+        rememberRuntimePermissionRequest(Manifest.permission.RECORD_AUDIO);
+        cordova.requestPermission(this, REQUEST_RECORD_AUDIO, Manifest.permission.RECORD_AUDIO);
+    }
+
+    private JSONObject microphoneStatus() throws Exception {
+        JSONObject result = new JSONObject();
+        result.put("permission", "android.permission.RECORD_AUDIO");
+        result.put("required", true);
+        result.put("granted", hasMicrophonePermission());
+        result.put("permissionGranted", hasMicrophonePermission());
+        result.put("requiresSettings", !hasMicrophonePermission() && shouldOpenSettingsForRuntimePermission(Manifest.permission.RECORD_AUDIO));
+        result.put("settingsOpened", false);
+        result.put("recording", micRecorder != null);
+        result.put("gravando", micRecorder != null);
+        if (micRecorder != null) {
+            result.put("startedAt", micRecordingStartedAt);
+            result.put("iniciadoEm", micRecordingStartedAt);
+            result.put("durationMs", System.currentTimeMillis() - micRecordingStartedAt);
+            result.put("duracaoMs", System.currentTimeMillis() - micRecordingStartedAt);
+        }
+        return result;
+    }
+
+    private void startMicRecording(CallbackContext callbackContext) throws Exception {
+        if (micRecorder != null) {
+            JSONObject result = microphoneStatus();
+            result.put("alreadyRecording", true);
+            result.put("jaGravando", true);
+            callbackContext.success(result);
+            return;
+        }
+
+        if (!hasMicrophonePermission()) {
+            if (shouldOpenSettingsForRuntimePermission(Manifest.permission.RECORD_AUDIO)) {
+                callbackContext.success(openSettingsForRuntimePermission(Manifest.permission.RECORD_AUDIO, true, false));
+                return;
+            }
+
+            pendingMicStartCallback = callbackContext;
+            rememberRuntimePermissionRequest(Manifest.permission.RECORD_AUDIO);
+            cordova.requestPermission(this, REQUEST_RECORD_AUDIO, Manifest.permission.RECORD_AUDIO);
+            return;
+        }
+
+        startMicRecorder(callbackContext);
+    }
+
+    private void startMicRecorder(CallbackContext callbackContext) throws Exception {
+        File audioDir = new File(context().getCacheDir(), "html2apk-audio");
+        if (!audioDir.exists() && !audioDir.mkdirs()) {
+            throw new Exception("Could not create audio cache directory.");
+        }
+
+        File audioFile = File.createTempFile("mic-", ".m4a", audioDir);
+        MediaRecorder recorder = new MediaRecorder();
+        try {
+            recorder.setAudioSource(MediaRecorder.AudioSource.MIC);
+            recorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4);
+            recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AAC);
+            recorder.setAudioEncodingBitRate(128000);
+            recorder.setAudioSamplingRate(44100);
+            recorder.setOutputFile(audioFile.getAbsolutePath());
+            recorder.prepare();
+            recorder.start();
+        } catch (Exception error) {
+            try {
+                recorder.release();
+            } catch (Exception ignored) {
+            }
+            audioFile.delete();
+            throw error;
+        }
+
+        micRecordingFile = audioFile;
+        micRecordingStartedAt = System.currentTimeMillis();
+        micRecorder = recorder;
+
+        JSONObject result = microphoneStatus();
+        result.put("mimeType", "audio/mp4");
+        result.put("extension", "m4a");
+        result.put("extensao", "m4a");
+        result.put("fileName", micRecordingFile.getName());
+        result.put("nomeArquivo", micRecordingFile.getName());
+        callbackContext.success(result);
+    }
+
+    private JSONObject stopMicRecording() throws Exception {
+        if (micRecorder == null || micRecordingFile == null) {
+            throw new Exception("Microphone is not recording. Call ouvirMic() first.");
+        }
+
+        MediaRecorder recorder = micRecorder;
+        File audioFile = micRecordingFile;
+        long startedAt = micRecordingStartedAt;
+        long endedAt;
+        Exception stopError = null;
+
+        micRecorder = null;
+        micRecordingFile = null;
+        micRecordingStartedAt = 0;
+
+        try {
+            recorder.stop();
+        } catch (RuntimeException error) {
+            stopError = new Exception("Could not finalize audio recording. Wait a little longer before calling pararMic().");
+        } finally {
+            try {
+                recorder.reset();
+            } catch (Exception ignored) {
+            }
+            try {
+                recorder.release();
+            } catch (Exception ignored) {
+            }
+        }
+
+        if (stopError != null) {
+            audioFile.delete();
+            throw stopError;
+        }
+
+        endedAt = System.currentTimeMillis();
+        byte[] audioBytes = readFileBytes(audioFile);
+        String base64 = Base64.encodeToString(audioBytes, Base64.NO_WRAP);
+        audioFile.delete();
+
+        JSONObject result = new JSONObject();
+        result.put("base64", base64);
+        result.put("mimeType", "audio/mp4");
+        result.put("extension", "m4a");
+        result.put("extensao", "m4a");
+        result.put("size", audioBytes.length);
+        result.put("tamanho", audioBytes.length);
+        result.put("startedAt", startedAt);
+        result.put("iniciadoEm", startedAt);
+        result.put("endedAt", endedAt);
+        result.put("finalizadoEm", endedAt);
+        result.put("durationMs", endedAt - startedAt);
+        result.put("duracaoMs", endedAt - startedAt);
+        result.put("recording", false);
+        result.put("gravando", false);
+        return result;
+    }
+
+    private byte[] readFileBytes(File file) throws Exception {
+        InputStream inputStream = new FileInputStream(file);
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        try {
+            byte[] buffer = new byte[8192];
+            int read;
+            while ((read = inputStream.read(buffer)) != -1) {
+                outputStream.write(buffer, 0, read);
+            }
+            return outputStream.toByteArray();
+        } finally {
+            inputStream.close();
+            outputStream.close();
+        }
+    }
+
+    private void stopMicRecorderSilently() {
+        if (micRecorder == null) {
+            return;
+        }
+
+        MediaRecorder recorder = micRecorder;
+        File audioFile = micRecordingFile;
+        micRecorder = null;
+        micRecordingFile = null;
+        micRecordingStartedAt = 0;
+
+        try {
+            recorder.stop();
+        } catch (Exception ignored) {
+        }
+        try {
+            recorder.reset();
+        } catch (Exception ignored) {
+        }
+        try {
+            recorder.release();
+        } catch (Exception ignored) {
+        }
+        if (audioFile != null) {
+            audioFile.delete();
+        }
+    }
+
+    private String torchCameraId() throws Exception {
+        CameraManager manager = (CameraManager) context().getSystemService(Context.CAMERA_SERVICE);
+        if (manager == null) {
+            throw new Exception("Camera service is not available.");
+        }
+
+        for (String cameraId : manager.getCameraIdList()) {
+            CameraCharacteristics characteristics = manager.getCameraCharacteristics(cameraId);
+            Boolean flashAvailable = characteristics.get(CameraCharacteristics.FLASH_INFO_AVAILABLE);
+            if (Boolean.TRUE.equals(flashAvailable)) {
+                return cameraId;
+            }
+        }
+
+        throw new Exception("This device does not expose a flashlight.");
+    }
+
+    private void setFlashlight(boolean enabled) throws Exception {
+        if (!hasCameraPermission()) {
+            throw new Exception("CAMERA permission is not granted.");
+        }
+
+        CameraManager manager = (CameraManager) context().getSystemService(Context.CAMERA_SERVICE);
+        if (manager == null) {
+            throw new Exception("Camera service is not available.");
+        }
+
+        manager.setTorchMode(torchCameraId(), enabled);
+        torchEnabled = enabled;
+    }
+
+    private void setFlashlightWithPermission(boolean enabled, boolean toggle, CallbackContext callbackContext) throws Exception {
+        if (!hasCameraPermission()) {
+            if (shouldOpenSettingsForRuntimePermission(Manifest.permission.CAMERA)) {
+                callbackContext.success(openSettingsForRuntimePermission(Manifest.permission.CAMERA, true, false));
+                return;
+            }
+
+            pendingFlashlightCallback = callbackContext;
+            pendingFlashlightEnabled = enabled;
+            pendingFlashlightToggle = toggle;
+            rememberRuntimePermissionRequest(Manifest.permission.CAMERA);
+            cordova.requestPermission(this, REQUEST_CAMERA, Manifest.permission.CAMERA);
+            return;
+        }
+
+        setFlashlight(toggle ? !torchEnabled : enabled);
+        callbackContext.success(flashlightStatus());
+    }
+
+    private JSONObject flashlightStatus() throws Exception {
+        JSONObject result = new JSONObject();
+        result.put("available", context().getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA_FLASH));
+        result.put("enabled", torchEnabled);
+        result.put("permission", "android.permission.CAMERA");
+        result.put("permissionGranted", hasCameraPermission());
+        result.put("requiresSettings", !hasCameraPermission() && shouldOpenSettingsForRuntimePermission(Manifest.permission.CAMERA));
+        result.put("settingsOpened", false);
+        return result;
+    }
+
+    private String readText() {
+        ClipboardManager clipboard = (ClipboardManager) context().getSystemService(Context.CLIPBOARD_SERVICE);
+        if (clipboard == null || !clipboard.hasPrimaryClip() || clipboard.getPrimaryClip() == null) {
+            return "";
+        }
+
+        ClipData clip = clipboard.getPrimaryClip();
+        if (clip.getItemCount() == 0 || clip.getItemAt(0) == null) {
+            return "";
+        }
+
+        CharSequence text = clip.getItemAt(0).coerceToText(context());
+        return text == null ? "" : text.toString();
+    }
+
+    private void share(JSONObject options) {
+        JSONObject safeOptions = options == null ? new JSONObject() : options;
+        String text = safeOptions.optString("texto", safeOptions.optString("text", ""));
+        String url = safeOptions.optString("url", "");
+        String title = safeOptions.optString("titulo", safeOptions.optString("title", "Compartilhar"));
+        StringBuilder content = new StringBuilder();
+        if (text.length() > 0) {
+            content.append(text);
+        }
+        if (url.length() > 0) {
+            if (content.length() > 0) {
+                content.append("\n");
+            }
+            content.append(url);
+        }
+
+        Intent intent = new Intent(Intent.ACTION_SEND);
+        intent.setType(safeOptions.optString("mimeType", "text/plain"));
+        intent.putExtra(Intent.EXTRA_TEXT, content.toString());
+        intent.putExtra(Intent.EXTRA_TITLE, title);
+        cordova.getActivity().startActivity(Intent.createChooser(intent, title));
+    }
+
+    private void dial(String phone) throws Exception {
+        String cleaned = phone == null ? "" : phone.trim();
+        if (cleaned.length() == 0) {
+            throw new Exception("Phone number is required.");
+        }
+
+        Intent intent = new Intent(Intent.ACTION_DIAL, Uri.parse("tel:" + Uri.encode(cleaned)));
+        cordova.getActivity().startActivity(intent);
+    }
+
+    private void openMap(String query) throws Exception {
+        String cleaned = query == null ? "" : query.trim();
+        if (cleaned.length() == 0) {
+            throw new Exception("Map query is required.");
+        }
+
+        Uri uri = cleaned.startsWith("geo:") || cleaned.startsWith("http")
+            ? Uri.parse(cleaned)
+            : Uri.parse("geo:0,0?q=" + Uri.encode(cleaned));
+        Intent intent = new Intent(Intent.ACTION_VIEW, uri);
+        cordova.getActivity().startActivity(intent);
+    }
+
+    private void openWhatsapp(String phone, String message) throws Exception {
+        String digits = phone == null ? "" : phone.replaceAll("[^0-9]", "");
+        if (digits.length() == 0) {
+            throw new Exception("WhatsApp phone number is required.");
+        }
+
+        String url = "https://wa.me/" + digits;
+        if (message != null && message.trim().length() > 0) {
+            url += "?text=" + Uri.encode(message.trim());
+        }
+        openUrl(url);
+    }
+
+    private void pickFile(JSONObject options, CallbackContext callbackContext) {
+        JSONObject safeOptions = options == null ? new JSONObject() : options;
+        String kind = safeOptions.optString("tipo", safeOptions.optString("kind", "file"));
+        boolean multiple = safeOptions.optBoolean("multiplo", safeOptions.optBoolean("multiple", false));
+        String mimeType = mimeTypeForPicker(kind, safeOptions);
+
+        Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT);
+        intent.addCategory(Intent.CATEGORY_OPENABLE);
+        intent.setType(mimeType);
+        intent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, multiple);
+
+        filePickerCallback = callbackContext;
+        cordova.startActivityForResult(this, intent, REQUEST_PICK_FILE);
+    }
+
+    private String mimeTypeForPicker(String kind, JSONObject options) {
+        String type = options.optString("mimeType", options.optString("tipoMime", ""));
+        if (type.length() > 0) {
+            return type;
+        }
+
+        JSONArray types = options.optJSONArray("tipos");
+        if (types == null) {
+            types = options.optJSONArray("types");
+        }
+        if (types != null && types.length() == 1) {
+            return types.optString(0, "*/*");
+        }
+
+        if ("image".equals(kind)) {
+            return "image/*";
+        }
+        if ("video".equals(kind)) {
+            return "video/*";
+        }
+        if ("media".equals(kind)) {
+            return "image/*";
+        }
+        return "*/*";
+    }
+
+    private void pickFolder(CallbackContext callbackContext) {
+        Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT_TREE);
+        folderPickerCallback = callbackContext;
+        cordova.startActivityForResult(this, intent, REQUEST_PICK_FOLDER);
+    }
+
+    private void saveFile(JSONObject options, CallbackContext callbackContext) throws Exception {
+        JSONObject safeOptions = options == null ? new JSONObject() : options;
+        String name = safeOptions.optString("nome", safeOptions.optString("name", "arquivo.txt"));
+        String mimeType = safeOptions.optString("mimeType", "text/plain");
+
+        pendingSaveFile = safeOptions;
+        saveFileCallback = callbackContext;
+
+        Intent intent = new Intent(Intent.ACTION_CREATE_DOCUMENT);
+        intent.addCategory(Intent.CATEGORY_OPENABLE);
+        intent.setType(mimeType);
+        intent.putExtra(Intent.EXTRA_TITLE, name);
+        cordova.startActivityForResult(this, intent, REQUEST_SAVE_FILE);
+    }
+
+    private void handlePickFileResult(int resultCode, Intent intent) {
+        CallbackContext callback = filePickerCallback;
+        filePickerCallback = null;
+        if (callback == null) {
+            return;
+        }
+        if (resultCode != Activity.RESULT_OK || intent == null) {
+            callback.success(new JSONArray());
+            return;
+        }
+
+        try {
+            JSONArray items = new JSONArray();
+            if (intent.getClipData() != null) {
+                ClipData clipData = intent.getClipData();
+                for (int index = 0; index < clipData.getItemCount(); index += 1) {
+                    items.put(fileInfo(clipData.getItemAt(index).getUri()));
+                }
+            } else if (intent.getData() != null) {
+                items.put(fileInfo(intent.getData()));
+            }
+            callback.success(items);
+        } catch (Exception error) {
+            callback.error(error.getMessage());
+        }
+    }
+
+    private void handlePickFolderResult(int resultCode, Intent intent) {
+        CallbackContext callback = folderPickerCallback;
+        folderPickerCallback = null;
+        if (callback == null) {
+            return;
+        }
+        if (resultCode != Activity.RESULT_OK || intent == null || intent.getData() == null) {
+            callback.success(new JSONObject());
+            return;
+        }
+
+        try {
+            JSONObject result = new JSONObject();
+            result.put("uri", intent.getData().toString());
+            callback.success(result);
+        } catch (Exception error) {
+            callback.error(error.getMessage());
+        }
+    }
+
+    private void handleSaveFileResult(int resultCode, Intent intent) {
+        CallbackContext callback = saveFileCallback;
+        JSONObject options = pendingSaveFile;
+        saveFileCallback = null;
+        pendingSaveFile = null;
+        if (callback == null) {
+            return;
+        }
+        if (resultCode != Activity.RESULT_OK || intent == null || intent.getData() == null) {
+            callback.success(new JSONObject());
+            return;
+        }
+
+        try {
+            Uri uri = intent.getData();
+            writePickedFile(uri, options == null ? new JSONObject() : options);
+            JSONObject result = fileInfo(uri);
+            result.put("saved", true);
+            callback.success(result);
+        } catch (Exception error) {
+            callback.error(error.getMessage());
+        }
+    }
+
+    private JSONObject fileInfo(Uri uri) throws Exception {
+        JSONObject result = new JSONObject();
+        result.put("uri", uri.toString());
+        result.put("mimeType", context().getContentResolver().getType(uri));
+
+        Cursor cursor = context().getContentResolver().query(uri, null, null, null, null);
+        if (cursor != null) {
+            try {
+                int nameIndex = cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME);
+                int sizeIndex = cursor.getColumnIndex(OpenableColumns.SIZE);
+                if (cursor.moveToFirst()) {
+                    if (nameIndex >= 0) {
+                        result.put("name", cursor.getString(nameIndex));
+                        result.put("nome", cursor.getString(nameIndex));
+                    }
+                    if (sizeIndex >= 0) {
+                        result.put("size", cursor.getLong(sizeIndex));
+                        result.put("tamanho", cursor.getLong(sizeIndex));
+                    }
+                }
+            } finally {
+                cursor.close();
+            }
+        }
+        return result;
+    }
+
+    private void writePickedFile(Uri uri, JSONObject options) throws Exception {
+        OutputStream outputStream = context().getContentResolver().openOutputStream(uri);
+        if (outputStream == null) {
+            throw new Exception("Could not open output stream.");
+        }
+
+        try {
+            InputStream inputStream;
+            String base64 = options.optString("base64", "");
+            if (base64.length() > 0) {
+                inputStream = new ByteArrayInputStream(Base64.decode(base64, Base64.DEFAULT));
+            } else {
+                String content = options.optString("conteudo", options.optString("content", ""));
+                inputStream = new ByteArrayInputStream(content.getBytes("UTF-8"));
+            }
+
+            byte[] buffer = new byte[8192];
+            int read;
+            while ((read = inputStream.read(buffer)) != -1) {
+                outputStream.write(buffer, 0, read);
+            }
+            inputStream.close();
+        } finally {
+            outputStream.close();
+        }
+    }
+
+    private JSONObject deviceInfo() throws Exception {
+        JSONObject result = new JSONObject();
+        result.put("manufacturer", Build.MANUFACTURER);
+        result.put("fabricante", Build.MANUFACTURER);
+        result.put("model", Build.MODEL);
+        result.put("modelo", Build.MODEL);
+        result.put("brand", Build.BRAND);
+        result.put("androidVersion", Build.VERSION.RELEASE);
+        result.put("sdkInt", Build.VERSION.SDK_INT);
+        result.put("packageName", context().getPackageName());
+        return result;
+    }
+
+    private JSONObject networkInfo() throws Exception {
+        JSONObject result = new JSONObject();
+        ConnectivityManager manager = (ConnectivityManager) context().getSystemService(Context.CONNECTIVITY_SERVICE);
+        boolean connected = false;
+        String type = "unknown";
+
+        if (manager != null) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                Network network = manager.getActiveNetwork();
+                NetworkCapabilities capabilities = network == null ? null : manager.getNetworkCapabilities(network);
+                connected = capabilities != null && capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET);
+                if (capabilities != null && capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
+                    type = "wifi";
+                } else if (capabilities != null && capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
+                    type = "cellular";
+                } else if (capabilities != null && capabilities.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET)) {
+                    type = "ethernet";
+                }
+            } else if (manager.getActiveNetworkInfo() != null) {
+                connected = manager.getActiveNetworkInfo().isConnected();
+                type = manager.getActiveNetworkInfo().getTypeName().toLowerCase();
+            }
+        }
+
+        result.put("online", connected);
+        result.put("connected", connected);
+        result.put("tipo", type);
+        result.put("type", type);
+        return result;
+    }
+
+    private JSONObject batteryInfo() throws Exception {
+        Intent intent = context().registerReceiver(null, new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
+        JSONObject result = new JSONObject();
+        if (intent == null) {
+            result.put("level", -1);
+            result.put("nivel", -1);
+            result.put("charging", false);
+            return result;
+        }
+
+        int level = intent.getIntExtra(BatteryManager.EXTRA_LEVEL, -1);
+        int scale = intent.getIntExtra(BatteryManager.EXTRA_SCALE, 100);
+        int status = intent.getIntExtra(BatteryManager.EXTRA_STATUS, -1);
+        boolean charging = status == BatteryManager.BATTERY_STATUS_CHARGING
+            || status == BatteryManager.BATTERY_STATUS_FULL;
+        double percent = scale <= 0 ? -1 : (level * 100.0 / scale);
+
+        result.put("level", percent);
+        result.put("nivel", percent);
+        result.put("charging", charging);
+        result.put("carregando", charging);
+        return result;
+    }
+
+    private JSONObject memoryInfo() throws Exception {
+        ActivityManager manager = (ActivityManager) context().getSystemService(Context.ACTIVITY_SERVICE);
+        ActivityManager.MemoryInfo info = new ActivityManager.MemoryInfo();
+        if (manager != null) {
+            manager.getMemoryInfo(info);
+        }
+
+        Runtime runtime = Runtime.getRuntime();
+        JSONObject result = new JSONObject();
+        result.put("availableBytes", info.availMem);
+        result.put("totalBytes", Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN ? info.totalMem : -1);
+        result.put("lowMemory", info.lowMemory);
+        result.put("thresholdBytes", info.threshold);
+        result.put("appUsedBytes", runtime.totalMemory() - runtime.freeMemory());
+        result.put("appMaxBytes", runtime.maxMemory());
+        return result;
+    }
+
+    private JSONObject storageInfo() throws Exception {
+        JSONObject result = new JSONObject();
+        result.put("internal", statFsInfo(Environment.getDataDirectory()));
+        result.put("cache", statFsInfo(context().getCacheDir()));
+        if (context().getExternalFilesDir(null) != null) {
+            result.put("appExternal", statFsInfo(context().getExternalFilesDir(null)));
+        }
+        return result;
+    }
+
+    private JSONObject statFsInfo(java.io.File file) throws Exception {
+        StatFs statFs = new StatFs(file.getAbsolutePath());
+        long blockSize = statFs.getBlockSizeLong();
+        long total = statFs.getBlockCountLong() * blockSize;
+        long available = statFs.getAvailableBlocksLong() * blockSize;
+        JSONObject result = new JSONObject();
+        result.put("path", file.getAbsolutePath());
+        result.put("totalBytes", total);
+        result.put("availableBytes", available);
+        result.put("usedBytes", total - available);
+        return result;
+    }
+
+    private JSONObject performanceInfo() throws Exception {
+        JSONObject result = new JSONObject();
+        result.put("timestamp", System.currentTimeMillis());
+        result.put("memory", memoryInfo());
+        result.put("storage", storageInfo());
+        result.put("battery", batteryInfo());
+        result.put("network", networkInfo());
+        return result;
+    }
+
+    private JSONObject openAppsMemoryInfo() throws Exception {
+        ActivityManager manager = (ActivityManager) context().getSystemService(Context.ACTIVITY_SERVICE);
+        JSONArray apps = new JSONArray();
+        JSONObject byName = new JSONObject();
+        JSONObject result = new JSONObject();
+
+        result.put("timestamp", System.currentTimeMillis());
+        result.put("limited", true);
+        result.put("observacao", "Android moderno limita a lista de apps de terceiros por privacidade; o retorno mostra apenas processos visiveis para este app.");
+        result.put("note", "Modern Android limits third-party app process visibility for privacy; this returns only processes visible to this app.");
+
+        if (manager == null) {
+            result.put("apps", apps);
+            result.put("porNome", byName);
+            result.put("byName", byName);
+            return result;
+        }
+
+        List<ActivityManager.RunningAppProcessInfo> processes = manager.getRunningAppProcesses();
+        if (processes == null) {
+            result.put("apps", apps);
+            result.put("porNome", byName);
+            result.put("byName", byName);
+            return result;
+        }
+
+        for (ActivityManager.RunningAppProcessInfo process : processes) {
+            Debug.MemoryInfo[] memoryInfos = manager.getProcessMemoryInfo(new int[] { process.pid });
+            Debug.MemoryInfo memory = memoryInfos != null && memoryInfos.length > 0 ? memoryInfos[0] : null;
+            long pssKb = memory == null ? 0 : memory.getTotalPss();
+            long ramBytes = pssKb * 1024L;
+            String packageName = process.pkgList != null && process.pkgList.length > 0 ? process.pkgList[0] : process.processName;
+            String name = appLabel(packageName, process.processName);
+
+            JSONObject item = new JSONObject();
+            item.put("name", name);
+            item.put("nome", name);
+            item.put("packageName", packageName);
+            item.put("pacote", packageName);
+            item.put("processName", process.processName);
+            item.put("pid", process.pid);
+            item.put("importance", process.importance);
+            item.put("importanceName", importanceName(process.importance));
+            item.put("ramBytes", ramBytes);
+            item.put("ramMb", Math.round((ramBytes / 1024.0 / 1024.0) * 100.0) / 100.0);
+            item.put("pssKb", pssKb);
+            if (memory != null) {
+                item.put("privateDirtyKb", memory.getTotalPrivateDirty());
+                item.put("sharedDirtyKb", memory.getTotalSharedDirty());
+            }
+
+            JSONArray packages = new JSONArray();
+            if (process.pkgList != null) {
+                for (String packageItem : process.pkgList) {
+                    packages.put(packageItem);
+                }
+            }
+            item.put("packages", packages);
+            item.put("pacotes", packages);
+            apps.put(item);
+
+            JSONObject summary = new JSONObject();
+            summary.put("ramBytes", ramBytes);
+            summary.put("ramMb", Math.round((ramBytes / 1024.0 / 1024.0) * 100.0) / 100.0);
+            summary.put("packageName", packageName);
+            summary.put("processName", process.processName);
+            byName.put(name, summary);
+        }
+
+        result.put("apps", apps);
+        result.put("porNome", byName);
+        result.put("byName", byName);
+        return result;
+    }
+
+    private String appLabel(String packageName, String fallback) {
+        try {
+            PackageManager packageManager = context().getPackageManager();
+            ApplicationInfo info = packageManager.getApplicationInfo(packageName, 0);
+            CharSequence label = packageManager.getApplicationLabel(info);
+            return label == null ? fallback : label.toString();
+        } catch (Exception ignored) {
+            return fallback == null ? packageName : fallback;
+        }
+    }
+
+    private String importanceName(int importance) {
+        if (importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND) {
+            return "foreground";
+        }
+        if (importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_VISIBLE) {
+            return "visible";
+        }
+        if (importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_SERVICE) {
+            return "service";
+        }
+        if (importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_CACHED) {
+            return "cached";
+        }
+        return "other";
+    }
+
+    private JSONObject permissionStatus(JSONArray requested) throws Exception {
+        JSONArray permissions = requested == null ? new JSONArray() : requested;
+        JSONObject result = new JSONObject();
+        for (int index = 0; index < permissions.length(); index += 1) {
+            String permission = androidPermissionName(permissions.optString(index, ""));
+            if (permission.length() == 0) {
+                continue;
+            }
+            result.put(permission, ContextCompat.checkSelfPermission(context(), permission) == PackageManager.PERMISSION_GRANTED);
+        }
+        return result;
+    }
+
+    private String androidPermissionName(String permission) {
+        String value = permission == null ? "" : permission.trim();
+        if (value.length() == 0 || value.indexOf('.') >= 0) {
+            return value;
+        }
+        return "android.permission." + value;
+    }
+
+    private JSONObject baseEvent(String type) {
+        JSONObject detail = new JSONObject();
+        try {
+            detail.put("type", type);
+            detail.put("tipo", type);
+            detail.put("timestamp", System.currentTimeMillis());
+        } catch (Exception ignored) {
+        }
+        return detail;
+    }
+
+    private void registerSystemReceiver() {
+        if (systemReceiver != null) {
+            return;
+        }
+
+        systemReceiver = new BroadcastReceiver() {
+            @Override
+            public void onReceive(Context context, Intent intent) {
+                if (intent == null || intent.getAction() == null) {
+                    return;
+                }
+
+                try {
+                    if (Intent.ACTION_BATTERY_CHANGED.equals(intent.getAction())) {
+                        dispatchEvent("bateria:mudou", batteryInfo());
+                    } else if (ConnectivityManager.CONNECTIVITY_ACTION.equals(intent.getAction())) {
+                        dispatchEvent("rede:mudou", networkInfo());
+                    }
+                } catch (Exception ignored) {
+                }
+            }
+        };
+
+        IntentFilter filter = new IntentFilter();
+        filter.addAction(Intent.ACTION_BATTERY_CHANGED);
+        filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
+        ContextCompat.registerReceiver(context(), systemReceiver, filter, ContextCompat.RECEIVER_NOT_EXPORTED);
+    }
+
+    private void unregisterSystemReceiver() {
+        if (systemReceiver == null) {
+            return;
+        }
+
+        try {
+            context().unregisterReceiver(systemReceiver);
+        } catch (Exception ignored) {
+        }
+        systemReceiver = null;
+    }
+
+    private void handleLinkIntent(Intent intent, boolean dispatchToJs) {
+        if (intent == null || intent.getData() == null) {
+            return;
+        }
+
+        JSONObject detail = new JSONObject();
+        try {
+            Uri uri = intent.getData();
+            detail.put("url", uri.toString());
+            detail.put("scheme", uri.getScheme());
+            detail.put("host", uri.getHost());
+            detail.put("path", uri.getPath());
+            detail.put("query", uri.getQuery());
+            detail.put("timestamp", System.currentTimeMillis());
+        } catch (Exception ignored) {
+        }
+
+        initialLink = detail;
+        if (dispatchToJs) {
+            dispatchEvent("link:aberto", detail);
+        }
+    }
+
+    private void dispatchEvent(String type, JSONObject detail) {
+        if (webView == null) {
+            return;
+        }
+
+        JSONObject payload = detail == null ? baseEvent(type) : detail;
+        try {
+            payload.put("type", type);
+            payload.put("tipo", type);
+            if (!payload.has("timestamp")) {
+                payload.put("timestamp", System.currentTimeMillis());
+            }
+        } catch (Exception ignored) {
+        }
+
+        final String script = "(function(){var detail=" + payload.toString()
+            + ";window.dispatchEvent(new CustomEvent('html2apk:event',{detail:detail}));"
+            + "window.dispatchEvent(new CustomEvent('html2apk:'+detail.type,{detail:detail}));})();";
+
+        cordova.getActivity().runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                webView.getEngine().evaluateJavascript(script, null);
+            }
+        });
+    }
+
+    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;
+        }
+
+        dispatchEvent("notificacao:clicada", detail);
+
+        final String script = "(function(){var detail=" + detail.toString()
+            + ";window.dispatchEvent(new CustomEvent('html2apk:notification',{detail:detail}));})();";
+
+        cordova.getActivity().runOnUiThread(new Runnable() {
             @Override
             public void run() {
                 webView.getEngine().evaluateJavascript(script, null);
@@ -515,6 +2016,206 @@ public class Html2ApkBridge extends CordovaPlugin {
         );
     }
 
+    static boolean canScheduleExactAlarms(Context context) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
+            return true;
+        }
+
+        AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
+        return alarmManager != null && alarmManager.canScheduleExactAlarms();
+    }
+
+    static JSONArray loopNotifications(JSONObject options) {
+        JSONArray notifications = options.optJSONArray("notificacoes");
+        if (notifications == null) {
+            notifications = options.optJSONArray("notifications");
+        }
+        if (notifications == null) {
+            notifications = options.optJSONArray("items");
+        }
+        return notifications == null ? new JSONArray() : notifications;
+    }
+
+    static JSONObject notificationDisplayOptions(JSONObject options) throws Exception {
+        JSONArray notifications = loopNotifications(options);
+        if (notifications.length() == 0) {
+            return options;
+        }
+
+        int index = Math.max(0, options.optInt("loopIndex", options.optInt("indiceLoop", 0)));
+        JSONObject current = notifications.optJSONObject(index % notifications.length());
+        JSONObject displayOptions = new JSONObject(options.toString());
+        if (current != null) {
+            JSONArray names = current.names();
+            if (names != null) {
+                for (int nameIndex = 0; nameIndex < names.length(); nameIndex += 1) {
+                    String name = names.optString(nameIndex);
+                    displayOptions.put(name, current.opt(name));
+                }
+            }
+        }
+
+        displayOptions.put("id", notificationId(options));
+        displayOptions.put("loopIndex", index);
+        displayOptions.put("indiceLoop", index);
+        displayOptions.put("loopTotal", notifications.length());
+        displayOptions.put("totalLoop", notifications.length());
+        return displayOptions;
+    }
+
+    static long repeatInterval(JSONObject options) {
+        long interval = intervalFromObject(options.opt("intervalo"));
+        if (interval <= 0) {
+            interval = intervalFromObject(options.opt("interval"));
+        }
+        if (interval <= 0) {
+            interval = intervalFromObject(options.opt("aCada"));
+        }
+        if (interval <= 0) {
+            interval = intervalFromObject(options.opt("every"));
+        }
+        if (interval <= 0) {
+            interval = intervalFromObject(options.opt("repetir"));
+        }
+        if (interval <= 0) {
+            interval = intervalFromObject(options.opt("repeat"));
+        }
+        return interval;
+    }
+
+    static long nextRepeatTime(JSONObject options, long after) {
+        long interval = repeatInterval(options);
+        if (interval <= 0) {
+            return 0;
+        }
+
+        long next = options.optLong("when", options.optLong("quando", after)) + interval;
+        while (next <= after) {
+            next += interval;
+        }
+        return next;
+    }
+
+    static JSONObject nextRepeatOptions(JSONObject options, long nextWhen) throws Exception {
+        JSONObject next = new JSONObject(options.toString());
+        JSONArray notifications = loopNotifications(options);
+        int nextIndex = Math.max(0, options.optInt("loopIndex", options.optInt("indiceLoop", 0))) + 1;
+        int runCount = Math.max(0, options.optInt("_runCount", options.optInt("runCount", 0))) + 1;
+
+        next.put("when", nextWhen);
+        next.put("quando", nextWhen);
+        next.put("loopIndex", notifications.length() == 0 ? nextIndex : nextIndex % notifications.length());
+        next.put("indiceLoop", notifications.length() == 0 ? nextIndex : nextIndex % notifications.length());
+        next.put("_runCount", runCount);
+        next.put("runCount", runCount);
+        return next;
+    }
+
+    static boolean shouldStopRepeating(JSONObject options, long nextWhen) {
+        long until = options.optLong("ate", options.optLong("until", 0));
+        if (until > 0 && nextWhen > until) {
+            return true;
+        }
+
+        int maxRuns = options.optInt("vezes", options.optInt("times", options.optInt("count", options.optInt("limit", 0))));
+        int runCount = Math.max(0, options.optInt("_runCount", options.optInt("runCount", 0))) + 1;
+        return maxRuns > 0 && runCount >= maxRuns;
+    }
+
+    static void rescheduleRepeatingNotification(Context context, int id, JSONObject options, boolean exactAllowed) {
+        try {
+            long nextWhen = nextRepeatTime(options, System.currentTimeMillis());
+            if (nextWhen <= 0 || shouldStopRepeating(options, nextWhen)) {
+                NotificationStore.remove(context, id);
+                return;
+            }
+
+            JSONObject nextOptions = nextRepeatOptions(options, nextWhen);
+            nextOptions.put("id", id);
+            NotificationStore.save(context, id, nextWhen, nextOptions);
+            NotificationReceiver.schedule(context, id, nextWhen, nextOptions, exactAllowed);
+        } catch (Exception ignored) {
+        }
+    }
+
+    private static long intervalFromObject(Object value) {
+        if (value == null || value == JSONObject.NULL) {
+            return 0;
+        }
+        if (value instanceof Number) {
+            return Math.max(0, ((Number) value).longValue());
+        }
+        if (value instanceof JSONObject) {
+            JSONObject object = (JSONObject) value;
+            long nested = intervalFromObject(object.opt("intervalo"));
+            if (nested <= 0) {
+                nested = intervalFromObject(object.opt("interval"));
+            }
+            if (nested <= 0) {
+                nested = intervalFromObject(object.opt("aCada"));
+            }
+            if (nested <= 0) {
+                nested = intervalFromObject(object.opt("every"));
+            }
+            return nested;
+        }
+        if (value instanceof Boolean) {
+            return 0;
+        }
+
+        return parseIntervalString(String.valueOf(value));
+    }
+
+    private static long parseIntervalString(String value) {
+        String text = value == null ? "" : value.trim().toLowerCase();
+        if (text.length() == 0) {
+            return 0;
+        }
+
+        int unitStart = text.length();
+        for (int index = 0; index < text.length(); index += 1) {
+            char character = text.charAt(index);
+            if (!(Character.isDigit(character) || character == '.')) {
+                unitStart = index;
+                break;
+            }
+        }
+
+        try {
+            double amount = Double.parseDouble(text.substring(0, unitStart).trim());
+            String unit = text.substring(unitStart).trim();
+            if ("s".equals(unit) || "seg".equals(unit)) {
+                return Math.round(amount * 1000);
+            }
+            if ("m".equals(unit) || "min".equals(unit)) {
+                return Math.round(amount * 60 * 1000);
+            }
+            if ("h".equals(unit) || "hr".equals(unit)) {
+                return Math.round(amount * 60 * 60 * 1000);
+            }
+            if ("d".equals(unit) || "dia".equals(unit) || "dias".equals(unit)) {
+                return Math.round(amount * 24 * 60 * 60 * 1000);
+            }
+            return Math.round(amount);
+        } catch (Exception ignored) {
+            return 0;
+        }
+    }
+
+    private static int notificationIdFromObject(Object input) {
+        if (input instanceof Number) {
+            return ((Number) input).intValue();
+        }
+        if (input instanceof JSONObject) {
+            return notificationId((JSONObject) input);
+        }
+        try {
+            return Integer.parseInt(String.valueOf(input));
+        } catch (Exception ignored) {
+            return 0;
+        }
+    }
+
     static JSONObject detailPayload(JSONObject options) throws Exception {
         JSONObject detail = new JSONObject();
         JSONObject click = options.optJSONObject("aoClicar");
@@ -534,6 +2235,37 @@ public class Html2ApkBridge extends CordovaPlugin {
         return detail;
     }
 
+    static void addNotificationActions(NotificationCompat.Builder builder, Context context, int notificationId, JSONObject options) {
+        JSONArray actions = options.optJSONArray("acoes");
+        if (actions == null) {
+            actions = options.optJSONArray("actions");
+        }
+        if (actions == null) {
+            return;
+        }
+
+        for (int index = 0; index < actions.length(); index += 1) {
+            JSONObject action = actions.optJSONObject(index);
+            if (action == null) {
+                continue;
+            }
+
+            try {
+                String title = action.optString("titulo", action.optString("title", action.optString("id", "Abrir")));
+                JSONObject detail = detailPayload(options);
+                detail.put("notificationAction", action.optString("id", String.valueOf(index)));
+                detail.put("acaoNotificacao", action.optString("id", String.valueOf(index)));
+                detail.put("action", action);
+                builder.addAction(
+                    context.getApplicationInfo().icon,
+                    title,
+                    createContentIntent(context, notificationId * 100 + index + 1, detail)
+                );
+            } catch (Exception ignored) {
+            }
+        }
+    }
+
     static int notificationId(JSONObject options) {
         int id = options.optInt("id", 0);
         if (id != 0) {