From dc38a16fde6be4ef960a139e9621e1fb5b3c9a9c Mon Sep 17 00:00:00 2001 From: pinpong Date: Fri, 6 Nov 2026 09:36:11 +0700 Subject: [PATCH] fix(android): start the permission request on the main thread (#92) --- CHANGELOG.md | 6 ++ .../io/invertase/notifee/NotifeeApiModule.kt | 29 ++--- .../notifee/RequestPermissionThreadTest.java | 102 ++++++++++++++++++ 3 files changed, 125 insertions(+), 12 deletions(-) create mode 100644 packages/react-native/android/src/test/java/io/invertase/notifee/RequestPermissionThreadTest.java diff --git a/CHANGELOG.md b/CHANGELOG.md index a4693354..93e4882d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,12 @@ All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/), and this project adheres to [Semantic Versioning](https://semver.org/). +## [Unreleased] + +### Fixed + +- **Android / permissions**: start the `POST_NOTIFICATIONS` request of `requestPermission()` on the main thread. TurboModule promise methods run on the native modules thread, and `Activity.requestPermissions()` walks the view hierarchy (`cancelPendingInputEvents`) while the UI thread may be changing it, which could reject the request with a `NullPointerException` from `View.dispatchCancelPendingInputEvents()`. Results, the path below API 33 and the missing Activity path are unchanged. + ## [10.10.0] - 2026-10-28 ### Added diff --git a/packages/react-native/android/src/main/kotlin/io/invertase/notifee/NotifeeApiModule.kt b/packages/react-native/android/src/main/kotlin/io/invertase/notifee/NotifeeApiModule.kt index 193c6833..75bc0375 100644 --- a/packages/react-native/android/src/main/kotlin/io/invertase/notifee/NotifeeApiModule.kt +++ b/packages/react-native/android/src/main/kotlin/io/invertase/notifee/NotifeeApiModule.kt @@ -15,6 +15,7 @@ import com.facebook.react.bridge.Promise import com.facebook.react.bridge.ReactApplicationContext import com.facebook.react.bridge.ReadableArray import com.facebook.react.bridge.ReadableMap +import com.facebook.react.bridge.UiThreadUtil import com.facebook.react.modules.core.PermissionAwareActivity import com.facebook.react.modules.core.PermissionListener @@ -284,18 +285,22 @@ class NotifeeApiModule(reactContext: ReactApplicationContext) : NotifeeReactUtils.promiseResolver(promise, e, bundle) } - try { - activity.requestPermissions( - arrayOf(Manifest.permission.POST_NOTIFICATIONS), - Notifee.REQUEST_CODE_NOTIFICATION_PERMISSION, - this, - ) - } catch (e: Exception) { - Logger.d( - "requestPermission", - "Failed to request POST_NOTIFICATIONS permission: ${e.message}", - ) - NotifeeReactUtils.promiseResolver(promise, e) + // starting the permission activity walks the view tree, so it must not run on the + // native modules thread while the UI thread changes it + UiThreadUtil.runOnUiThread { + try { + activity.requestPermissions( + arrayOf(Manifest.permission.POST_NOTIFICATIONS), + Notifee.REQUEST_CODE_NOTIFICATION_PERMISSION, + this, + ) + } catch (e: Exception) { + Logger.d( + "requestPermission", + "Failed to request POST_NOTIFICATIONS permission: ${e.message}", + ) + NotifeeReactUtils.promiseResolver(promise, e) + } } } diff --git a/packages/react-native/android/src/test/java/io/invertase/notifee/RequestPermissionThreadTest.java b/packages/react-native/android/src/test/java/io/invertase/notifee/RequestPermissionThreadTest.java new file mode 100644 index 00000000..cfa645c6 --- /dev/null +++ b/packages/react-native/android/src/test/java/io/invertase/notifee/RequestPermissionThreadTest.java @@ -0,0 +1,102 @@ +package io.invertase.notifee; + +import static org.junit.Assert.assertSame; +import static org.mockito.AdditionalMatchers.aryEq; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyInt; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.ArgumentMatchers.same; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.doThrow; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoMoreInteractions; +import static org.mockito.Mockito.when; +import static org.mockito.Mockito.withSettings; + +import android.Manifest; +import android.app.Activity; +import android.os.Looper; +import app.notifee.core.Notifee; +import com.facebook.react.bridge.Promise; +import com.facebook.react.bridge.ReactApplicationContext; +import com.facebook.react.bridge.ReadableMap; +import com.facebook.react.modules.core.PermissionAwareActivity; +import java.util.concurrent.atomic.AtomicReference; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.robolectric.RobolectricTestRunner; +import org.robolectric.Shadows; +import org.robolectric.annotation.Config; +import org.robolectric.annotation.LooperMode; + +/** TurboModule promise methods run on the native modules thread, not on the main thread. */ +@RunWith(RobolectricTestRunner.class) +@Config( + manifest = Config.NONE, + sdk = {33, 36}) +@LooperMode(LooperMode.Mode.PAUSED) +public class RequestPermissionThreadTest { + private static final String[] POST_NOTIFICATIONS = {Manifest.permission.POST_NOTIFICATIONS}; + + private PermissionAwareActivity activity; + private NotifeeApiModule module; + private ReadableMap permissions; + private Promise promise; + + @Before + public void setUp() { + ReactApplicationContext context = mock(ReactApplicationContext.class); + Activity currentActivity = + mock(Activity.class, withSettings().extraInterfaces(PermissionAwareActivity.class)); + activity = (PermissionAwareActivity) currentActivity; + when(context.getCurrentActivity()).thenReturn(currentActivity); + module = new NotifeeApiModule(context); + permissions = mock(ReadableMap.class); + promise = mock(Promise.class); + } + + private void requestFromModulesThread() throws InterruptedException { + Thread modulesThread = new Thread(() -> module.requestPermission(permissions, promise)); + modulesThread.start(); + modulesThread.join(); + } + + @Test + public void startsThePermissionActivityOnTheMainThread() throws Exception { + AtomicReference requestThread = new AtomicReference<>(); + doAnswer( + invocation -> { + requestThread.set(Thread.currentThread()); + return null; + }) + .when(activity) + .requestPermissions(any(), anyInt(), any()); + + requestFromModulesThread(); + verify(activity, never()).requestPermissions(any(), anyInt(), any()); + + Shadows.shadowOf(Looper.getMainLooper()).idle(); + verify(activity) + .requestPermissions( + aryEq(POST_NOTIFICATIONS), + eq(Notifee.REQUEST_CODE_NOTIFICATION_PERMISSION), + same(module)); + assertSame(Looper.getMainLooper().getThread(), requestThread.get()); + verifyNoMoreInteractions(promise); + } + + @Test + public void aRequestThatThrowsOnTheMainThreadStillRejects() throws Exception { + IllegalStateException failure = new IllegalStateException("activity is finishing"); + doThrow(failure).when(activity).requestPermissions(any(), anyInt(), any()); + + requestFromModulesThread(); + Shadows.shadowOf(Looper.getMainLooper()).idle(); + + verify(promise).reject(failure); + verifyNoMoreInteractions(promise); + } +}