Add use fullscreen intent (#944)

Author: danilvalov

README.md

@@ -811,16 +811,17 @@ requestMultiple([PERMISSIONS.IOS.CAMERA, PERMISSIONS.IOS.FACE_ID]).then((statuse
 
 #### openSettings
 
-Open application / alarms / notifications settings (default to `application`).
+Open application / alarms / notifications / fullscreen settings (default to `application`).
 
 > [!NOTE]
 >
 > - `notifications` settings are only available on Android 8+ and iOS 15.4+
 > - `alarms` settings are only available on Android 12+
+> - `fullscreen` settings are only available on Android 14+
 > - If a choice is not available, it fallbacks to `application` settings
 
 ```ts
-function openSettings(type?: 'application' | 'alarms' | 'notifications'): Promise<void>;
+function openSettings(type?: 'application' | 'alarms' | 'notifications' | 'fullscreen'): Promise<void>;
 ```
 
 ```ts
@@ -845,6 +846,23 @@ canScheduleExactAlarms()
   .catch(() => console.warn('Cannot check exact alarms scheduling setting'));
 ```
 
+
+#### canUseFullScreenIntent (Android)
+
+Check if your app can use full screen intent.
+
+```ts
+function canUseFullScreenIntent(): Promise<boolean>;
+```
+
+```ts
+import {canUseFullScreenIntent} from 'react-native-permissions';
+
+canUseFullScreenIntent()
+  .then((value) => console.log(`Can use full screen intent: ${value}`))
+  .catch(() => console.warn('Cannot check full screen intent using setting'));
+```
+
 #### openPhotoPicker (iOS 14+)
 
 Open a picker to update the photo selection when `PhotoLibrary` permission is `limited`. This will reject if unsupported or if full permission is already `granted`.

android/src/main/java/com/zoontek/rnpermissions/RNPermissionsModuleImpl.kt

@@ -1,6 +1,7 @@
 package com.zoontek.rnpermissions
 
 import android.app.AlarmManager
+import android.app.NotificationManager
 import android.content.Context
 import android.content.Intent
 import android.content.pm.PackageManager
@@ -70,6 +71,10 @@ object RNPermissionsModuleImpl {
           setAction(Settings.ACTION_APP_NOTIFICATION_SETTINGS)
           putExtra(Settings.EXTRA_APP_PACKAGE, packageName)
         }
+        Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE && type == "fullscreen" -> Intent().apply {
+          setAction(Settings.ACTION_MANAGE_APP_USE_FULL_SCREEN_INTENT)
+          setData(Uri.parse("package:${packageName}"))
+        }
         else -> Intent().apply {
           setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
           setData(Uri.parse("package:${packageName}"))
@@ -96,6 +101,17 @@ object RNPermissionsModuleImpl {
     promise.resolve(canScheduleExactAlarms)
   }
 
+  fun canUseFullScreenIntent(reactContext: ReactApplicationContext, promise: Promise) {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+      return promise.resolve(true)
+    }
+
+    val notificationManager = reactContext.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+    val canUseFullScreenIntent = notificationManager.canUseFullScreenIntent()
+
+    promise.resolve(canUseFullScreenIntent)
+  }
+
   fun check(reactContext: ReactApplicationContext, permission: String, promise: Promise) {
     if (!isPermissionAvailable(permission)) {
       return promise.resolve(UNAVAILABLE)

android/src/newarch/com/zoontek/rnpermissions/RNPermissionsModule.kt

@@ -27,6 +27,10 @@ class RNPermissionsModule(reactContext: ReactApplicationContext?) :
     RNPermissionsModuleImpl.canScheduleExactAlarms(reactApplicationContext, promise)
   }
 
+  override fun canUseFullScreenIntent(promise: Promise) {
+    RNPermissionsModuleImpl.canUseFullScreenIntent(reactApplicationContext, promise)
+  }
+
   override fun check(permission: String, promise: Promise) {
     RNPermissionsModuleImpl.check(reactApplicationContext, permission, promise)
   }

android/src/oldarch/com/zoontek/rnpermissions/RNPermissionsModule.kt

@@ -31,6 +31,11 @@ class RNPermissionsModule(reactContext: ReactApplicationContext?) :
     RNPermissionsModuleImpl.canScheduleExactAlarms(reactApplicationContext, promise)
   }
 
+  @ReactMethod
+  fun canUseFullScreenIntent(promise: Promise) {
+    RNPermissionsModuleImpl.canUseFullScreenIntent(reactApplicationContext, promise)
+  }
+
   @ReactMethod
   fun check(permission: String, promise: Promise) {
     RNPermissionsModuleImpl.check(reactApplicationContext, permission, promise)

ios/RNPermissions.mm

@@ -460,6 +460,11 @@ - (void)canScheduleExactAlarms:(RCTPromiseResolveBlock)resolve
   reject(@"RNPermissions:canScheduleExactAlarms", @"canScheduleExactAlarms is not supported on iOS", nil);
 }
 
+- (void)canUseFullScreenIntent:(RCTPromiseResolveBlock)resolve
+                        reject:(RCTPromiseRejectBlock)reject {
+  reject(@"RNPermissions:canUseFullScreenIntent", @"canUseFullScreenIntent is not supported on iOS", nil);
+}
+
 - (void)shouldShowRequestRationale:(NSString *)permission
                            resolve:(RCTPromiseResolveBlock)resolve
                             reject:(RCTPromiseRejectBlock)reject {

mock.js

@@ -13,6 +13,7 @@ const PERMISSIONS = {ANDROID, IOS, WINDOWS};
 export {PERMISSIONS, RESULTS};
 
 export const canScheduleExactAlarms = jest.fn(async () => true);
+export const canUseFullScreenIntent = jest.fn(async () => true);
 export const check = jest.fn(async () => RESULTS.GRANTED);
 export const checkLocationAccuracy = jest.fn(async () => 'full');
 export const openPhotoPicker = jest.fn(async () => {});
@@ -70,6 +71,7 @@ export default {
   RESULTS,
 
   canScheduleExactAlarms,
+  canUseFullScreenIntent,
   check,
   checkLocationAccuracy,
   checkMultiple,

src/NativeRNPermissions.ts

@@ -8,6 +8,7 @@ type NotificationsResponse = {
 
 export interface Spec extends TurboModule {
   canScheduleExactAlarms(): Promise<boolean>;
+  canUseFullScreenIntent(): Promise<boolean>;
   check(permission: string): Promise<string>;
   checkLocationAccuracy(): Promise<string>;
   checkMultiple(permissions: string[]): Promise<Object>;

src/contract.ts

@@ -10,14 +10,15 @@ import type {
 
 export type Contract = {
   canScheduleExactAlarms(): Promise<boolean>;
+  canUseFullScreenIntent(): Promise<boolean>;
   check(permission: Permission): Promise<PermissionStatus>;
   checkLocationAccuracy(): Promise<LocationAccuracy>;
   checkMultiple<P extends Permission[]>(
     permissions: P,
   ): Promise<Record<P[number], PermissionStatus>>;
   checkNotifications(): Promise<NotificationsResponse>;
   openPhotoPicker(): Promise<void>;
-  openSettings(type?: 'application' | 'alarms' | 'notifications'): Promise<void>;
+  openSettings(type?: 'application' | 'alarms' | 'notifications' | 'fullscreen'): Promise<void>;
   request(permission: Permission, rationale?: Rationale): Promise<PermissionStatus>;
   requestLocationAccuracy(options: LocationAccuracyOptions): Promise<LocationAccuracy>;
   requestMultiple<P extends Permission[]>(

src/index.ts

@@ -8,6 +8,7 @@ export {RESULTS} from './results';
 export * from './types';
 
 export const canScheduleExactAlarms = methods.canScheduleExactAlarms;
+export const canUseFullScreenIntent = methods.canUseFullScreenIntent;
 export const check = methods.check;
 export const checkLocationAccuracy = methods.checkLocationAccuracy;
 export const checkMultiple = methods.checkMultiple;
@@ -24,6 +25,7 @@ export default {
   RESULTS,
 
   canScheduleExactAlarms,
+  canUseFullScreenIntent,
   check,
   checkLocationAccuracy,
   checkMultiple,

src/methods.android.ts

@@ -46,6 +46,9 @@ const openSettings: Contract['openSettings'] = async (type = 'application') => {
 const canScheduleExactAlarms: Contract['canScheduleExactAlarms'] = () =>
   NativeModule.canScheduleExactAlarms();
 
+const canUseFullScreenIntent: Contract['canUseFullScreenIntent'] = () =>
+  NativeModule.canUseFullScreenIntent();
+
 const check: Contract['check'] = async (permission) => {
   const status = (await NativeModule.check(permission)) as PermissionStatus;
   return status;
@@ -90,6 +93,7 @@ const requestMultiple: Contract['requestMultiple'] = (permissions) => {
 
 export const methods: Contract = {
   canScheduleExactAlarms,
+  canUseFullScreenIntent,
   check,
   checkLocationAccuracy,
   checkMultiple,

src/methods.ios.ts

@@ -1,7 +1,7 @@
 import type {Contract} from './contract';
 import NativeModule from './NativeRNPermissions';
 import {LocationAccuracy, NotificationsResponse, PermissionStatus} from './types';
-import {canScheduleExactAlarms} from './unsupportedMethods';
+import {canScheduleExactAlarms, canUseFullScreenIntent} from './unsupportedMethods';
 import {uniq} from './utils';
 
 const openPhotoPicker: Contract['openPhotoPicker'] = async () => {
@@ -66,6 +66,7 @@ const requestMultiple: Contract['requestMultiple'] = async (permissions) => {
 
 export const methods: Contract = {
   canScheduleExactAlarms,
+  canUseFullScreenIntent,
   check,
   checkLocationAccuracy,
   checkMultiple,

src/methods.ts

@@ -27,6 +27,7 @@ const checkMultiple: Contract['checkMultiple'] = async (permissions) => {
 
 export const methods: Contract = {
   canScheduleExactAlarms: Promise.reject,
+  canUseFullScreenIntent: Promise.reject,
   check,
   checkLocationAccuracy,
   checkMultiple,

src/methods.windows.ts

@@ -3,6 +3,7 @@ import type {Contract} from './contract';
 import type {NotificationsResponse, PermissionStatus} from './types';
 import {
   canScheduleExactAlarms,
+  canUseFullScreenIntent,
   checkLocationAccuracy,
   openPhotoPicker,
   requestLocationAccuracy,
@@ -50,6 +51,7 @@ const requestMultiple: Contract['requestMultiple'] = async (permissions) => {
 
 export const methods: Contract = {
   canScheduleExactAlarms,
+  canUseFullScreenIntent,
   check,
   checkLocationAccuracy,
   checkMultiple,

src/unsupportedMethods.ts

@@ -7,6 +7,10 @@ export const canScheduleExactAlarms: Contract['canScheduleExactAlarms'] = async
   throw getUnsupportedError('Android', 12);
 };
 
+export const canUseFullScreenIntent: Contract['canUseFullScreenIntent'] = async () => {
+  throw getUnsupportedError('Android', 14);
+};
+
 export const openPhotoPicker: Contract['openPhotoPicker'] = async () => {
   throw getUnsupportedError('iOS', 14);
 };

windows/RNPermissions/RNPermissions.cpp

@@ -41,6 +41,11 @@ void RNPermissions::RNPermissions::CanScheduleExactAlarms(React::ReactPromise<bo
   promise.Resolve(false);
 }
 
+void RNPermissions::RNPermissions::CanUseFullScreenIntent(React::ReactPromise<bool>&& promise) noexcept {
+  // no-op - Android only
+  promise.Resolve(false);
+}
+
 void RNPermissions::RNPermissions::CheckLocationAccuracy(React::ReactPromise<std::string>&& promise) noexcept {
   // no-op - iOS 14+ only
   promise.Resolve("N/A");

windows/RNPermissions/RNPermissions.h

@@ -29,6 +29,9 @@ struct RNPermissions
     REACT_METHOD(CanScheduleExactAlarms, L"canScheduleExactAlarms");
     void CanScheduleExactAlarms(React::ReactPromise<bool>&& promise) noexcept;
 
+    REACT_METHOD(CanUseFullScreenIntent, L"canUseFullScreenIntent");
+    void CanUseFullScreenIntent(React::ReactPromise<bool>&& promise) noexcept;
+
     REACT_METHOD(CheckLocationAccuracy, L"checkLocationAccuracy");
     void CheckLocationAccuracy(React::ReactPromise<std::string>&& promise) noexcept;
 

windows/RNPermissions/codegen/NativeRNPermissionsSpec.g.h

@@ -26,6 +26,7 @@ inline winrt::Microsoft::ReactNative::FieldMap GetStructInfo(RNPermissionsSpec_N
 struct RNPermissionsSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
   static constexpr auto methods = std::tuple{
       Method<void(Promise<bool>) noexcept>{0, L"canScheduleExactAlarms"},
+      Method<void(Promise<bool>) noexcept>{0, L"canUseFullScreenIntent"},
       Method<void(std::string, Promise<std::string>) noexcept>{1, L"check"},
       Method<void(Promise<std::string>) noexcept>{2, L"checkLocationAccuracy"},
       Method<void(std::vector<std::string>, Promise<::React::JSValue>) noexcept>{3, L"checkMultiple"},
@@ -48,6 +49,11 @@ struct RNPermissionsSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
           "canScheduleExactAlarms",
           "    REACT_METHOD(canScheduleExactAlarms) void canScheduleExactAlarms(::React::ReactPromise<bool> &&result) noexcept { /* implementation */ }\n"
           "    REACT_METHOD(canScheduleExactAlarms) static void canScheduleExactAlarms(::React::ReactPromise<bool> &&result) noexcept { /* implementation */ }\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          0,
+          "canUseFullScreenIntent",
+          "    REACT_METHOD(canUseFullScreenIntent) void canUseFullScreenIntent(::React::ReactPromise<bool> &&result) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(canUseFullScreenIntent) static void canUseFullScreenIntent(::React::ReactPromise<bool> &&result) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           1,
           "check",