@@ -8,7 +8,9 @@
 
 import android.Manifest;
 import android.app.Activity;
+import android.content.Context;
 import android.content.Intent;
+import android.content.SharedPreferences;
 import android.content.pm.PackageManager;
 import android.os.Build;
 import android.os.Bundle;
@@ -17,6 +19,7 @@
 import androidx.annotation.Nullable;
 import androidx.annotation.RequiresApi;
 import androidx.annotation.VisibleForTesting;
+import androidx.core.app.ActivityCompat;
 import androidx.core.app.NotificationManagerCompat;
 import androidx.lifecycle.LiveData;
 import androidx.lifecycle.Observer;
@@ -373,6 +376,16 @@ private Task<Map<String, Object>> getInitialMessage() {
     return taskCompletionSource.getTask();
   }
 
+  // Wire values for Dart AuthorizationStatus (see convertToAuthorizationStatus).
+  private static final int AUTH_NOT_DETERMINED = -1;
+  private static final int AUTH_DENIED = 0;
+  private static final int AUTH_AUTHORIZED = 1;
+  private static final int AUTH_DENIED_PERMANENTLY = 3;
+
+  private static final String PERMISSIONS_PREFERENCES_FILE =
+      "io.flutter.plugins.firebase.messaging.permissions";
+  private static final String KEY_PERMISSION_REQUESTED = "notification_permission_requested";
+
   @RequiresApi(api = 33)
   private Task<Map<String, Integer>> requestPermissions() {
     TaskCompletionSource<Map<String, Integer>> taskCompletionSource = new TaskCompletionSource<>();
@@ -385,14 +398,24 @@ private Task<Map<String, Integer>> requestPermissions() {
             if (!areNotificationsEnabled) {
               permissionManager.requestPermissions(
                   mainActivity,
-                  (notificationsEnabled) -> {
-                    permissions.put("authorizationStatus", notificationsEnabled);
+                  (grantResult) -> {
+                    // Record that the OS has now asked the user, so a later
+                    // getNotificationSettings() can tell a permanent denial apart from
+                    // "never asked".
+                    markNotificationPermissionRequested();
+                    // After the OS dialog, resolve the full status (soft vs permanent deny)
+                    // instead of returning only the raw grant result.
+                    int status =
+                        grantResult == 1
+                            ? AUTH_AUTHORIZED
+                            : resolveNotificationAuthorizationStatus();
+                    permissions.put("authorizationStatus", status);
                     taskCompletionSource.setResult(permissions);
                   },
                   (String errorDescription) ->
                       taskCompletionSource.setException(new Exception(errorDescription)));
             } else {
-              permissions.put("authorizationStatus", 1);
+              permissions.put("authorizationStatus", AUTH_AUTHORIZED);
               taskCompletionSource.setResult(permissions);
             }
 
@@ -411,21 +434,74 @@ private Boolean checkPermissions() {
         == PackageManager.PERMISSION_GRANTED;
   }
 
+  private SharedPreferences getPermissionsPreferences() {
+    return ContextHolder.getApplicationContext()
+        .getSharedPreferences(PERMISSIONS_PREFERENCES_FILE, Context.MODE_PRIVATE);
+  }
+
+  private void markNotificationPermissionRequested() {
+    getPermissionsPreferences().edit().putBoolean(KEY_PERMISSION_REQUESTED, true).apply();
+  }
+
+  /**
+   * Resolves Android 13+ notification permission into Dart authorization codes.
+   *
+   * <p>A denied {@code POST_NOTIFICATIONS} is ambiguous: Android reports the same state for "never
+   * asked" and "permanently denied", and it exposes no public API for reading the underlying
+   * permission flags. {@link ActivityCompat#shouldShowRequestPermissionRationale} combined with a
+   * SharedPreferences record of whether we ever showed the prompt breaks the tie. This mirrors how
+   * {@code permission_handler} solves the same problem.
+   *
+   * <ul>
+   *   <li>granted → authorized (1)
+   *   <li>never asked → notDetermined (-1)
+   *   <li>soft deny (rationale can be shown) → denied (0)
+   *   <li>asked before, no rationale → deniedPermanently (3)
+   * </ul>
+   *
+   * <p>Known limitation: if another plugin requested {@code POST_NOTIFICATIONS} and the user denied
+   * it permanently, we have no record of the prompt and report notDetermined. Calling {@link
+   * #requestPermissions()} in that state is a no-op that resolves to the correct status.
+   */
+  @RequiresApi(api = 33)
+  private int resolveNotificationAuthorizationStatus() {
+    if (checkPermissions()) {
+      return AUTH_AUTHORIZED;
+    }
+
+    if (mainActivity != null
+        && ActivityCompat.shouldShowRequestPermissionRationale(
+            mainActivity, Manifest.permission.POST_NOTIFICATIONS)) {
+      // Denied at least once, but the OS will still show another prompt.
+      return AUTH_DENIED;
+    }
+
+    if (!getPermissionsPreferences().getBoolean(KEY_PERMISSION_REQUESTED, false)) {
+      return AUTH_NOT_DETERMINED;
+    }
+
+    // Asked before and no rationale is available. Without an Activity we cannot call
+    // shouldShowRequestPermissionRationale at all, so report the softer status and let
+    // callers retry once an Activity is attached.
+    return mainActivity == null ? AUTH_DENIED : AUTH_DENIED_PERMANENTLY;
+  }
+
   private Task<Map<String, Integer>> getPermissions() {
     TaskCompletionSource<Map<String, Integer>> taskCompletionSource = new TaskCompletionSource<>();
 
     cachedThreadPool.execute(
         () -> {
           try {
             final Map<String, Integer> permissions = new HashMap<>();
-            final boolean areNotificationsEnabled;
             if (Build.VERSION.SDK_INT >= 33) {
-              areNotificationsEnabled = checkPermissions();
+              permissions.put("authorizationStatus", resolveNotificationAuthorizationStatus());
             } else {
-              areNotificationsEnabled =
-                  NotificationManagerCompat.from(mainActivity).areNotificationsEnabled();
+              final boolean areNotificationsEnabled =
+                  NotificationManagerCompat.from(ContextHolder.getApplicationContext())
+                      .areNotificationsEnabled();
+              permissions.put(
+                  "authorizationStatus", areNotificationsEnabled ? AUTH_AUTHORIZED : AUTH_DENIED);
             }
-            permissions.put("authorizationStatus", areNotificationsEnabled ? 1 : 0);
             taskCompletionSource.setResult(permissions);
           } catch (Exception e) {
             taskCompletionSource.setException(e);