rn-bg-actions 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Rapsssito
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,211 @@
+<p align="center">
+    <img src="https://i.imgur.com/G8BUzdZ.png" />
+    <br></br>
+    <img src="https://github.com/Rapsssito/react-native-background-actions/workflows/Release/badge.svg" />
+    <img src="https://img.shields.io/npm/dw/react-native-background-actions" />
+    <img src="https://img.shields.io/npm/v/react-native-background-actions?color=gr&label=npm%20version" />
+</p>
+
+React Native background service library for running **background tasks forever in Android & iOS**. Schedule a background job that will run your JavaScript when your app is in the background or foreground.
+
+### WARNING
+- **Android**: This library relies on React Native's [`HeadlessJS`](https://facebook.github.io/react-native/docs/headless-js-android) for Android. Before building your JS task, make sure to read all the [documentation](https://facebook.github.io/react-native/docs/headless-js-android). The jobs will run even if the app has been closed. [In Android 12+](https://developer.android.com/guide/components/foreground-services#background-start-restrictions) you will not be able to launch background tasks from the background. A notification will be shown when the task is running, it is not possible to start the service without it. The notification will only be visible in Android.
+
+- **iOS**: This library relies on iOS's [`UIApplication beginBackgroundTaskWithName` method](https://developer.apple.com/documentation/uikit/uiapplication/1623051-beginbackgroundtaskwithname?language=objc), which **won't keep your app in the background forever** by itself. However, you can rely on other libraries like [`react-native-track-player`](https://github.com/react-native-kit/react-native-track-player) that use audio, geolocalization, etc. to keep your app alive in the background while you excute the JS from this library.
+
+
+## Table of Contents <!-- omit in toc -->
+
+- [React Native / Android / iOS compatibility](#react-native--android--ios-compatibility)
+- [Install](#install)
+- [Usage](#usage)
+  - [Example Code](#example-code)
+  - [Options](#options)
+    - [taskIconOptions](#taskiconoptions)
+    - [taskProgressBarOptions](#taskprogressbaroptions)
+  - [Deep Linking](#deep-linking)
+  - [Events](#events)
+    - ['expiration'](#expiration)
+- [Maintainers](#maintainers)
+- [Acknowledgments](#acknowledgments)
+- [License](#license)
+
+## React Native / Android / iOS compatibility
+To use this module you need to ensure you are using the correct version of React Native. If you are using an Android (targetSdkVersion) version lower than 31 (introduced in React Native 0.68.0) you will need to upgrade before attempting to use `react-native-background-actions`'s latest version.
+
+| Version | React Native version | Android (targetSdkVersion) version | iOS version  |
+| ------- | -------------------- | ---------------------------------- | ------------ |
+| `4.X.X` | `>= Unknown`         | `>= 34`                            | `>= Unknown` |
+| `3.X.X` | `>= Unknown`         | `>= 31`                            | `>= Unknown` |
+| `2.6.7` | `>= Unknown`         | `>= Unknown`                       | `>= Unknown` |
+
+## Install
+
+Go to [INSTALL.md](./INSTALL.md) to see the how to install, compatibility with RN and Linking process.
+
+## Usage
+
+### Example Code
+
+```js
+import BackgroundService from 'react-native-background-actions';
+
+const sleep = (time) => new Promise((resolve) => setTimeout(() => resolve(), time));
+
+// You can do anything in your task such as network requests, timers and so on,
+// as long as it doesn't touch UI. Once your task completes (i.e. the promise is resolved),
+// React Native will go into "paused" mode (unless there are other tasks running,
+// or there is a foreground app).
+const veryIntensiveTask = async (taskDataArguments) => {
+    // Example of an infinite loop task
+    const { delay } = taskDataArguments;
+    await new Promise( async (resolve) => {
+        for (let i = 0; BackgroundService.isRunning(); i++) {
+            console.log(i);
+            await sleep(delay);
+        }
+    });
+};
+
+const options = {
+    taskName: 'Example',
+    taskTitle: 'ExampleTask title',
+    taskDesc: 'ExampleTask description',
+    taskIcon: {
+        name: 'ic_launcher',
+        type: 'mipmap',
+    },
+    color: '#ff00ff',
+    linkingURI: 'yourSchemeHere://chat/jane', // See Deep Linking for more info
+    parameters: {
+        delay: 1000,
+    },
+};
+
+
+await BackgroundService.start(veryIntensiveTask, options);
+await BackgroundService.updateNotification({taskDesc: 'New ExampleTask description'}); // Only Android, iOS will ignore this call
+// iOS will also run everything here in the background until .stop() is called
+await BackgroundService.stop();
+```
+> If you call stop() on background no new tasks will be able to be started!
+> Don't call .start() twice, as it will stop performing previous background tasks and start a new one. 
+> If .start() is called on the backgound, it will not have any effect.
+
+### Options
+| Property      | Type                                                  | Description                                                                                                                                                                    |
+| ------------- | ----------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `taskName`    | `<string>`                                            | Task name for identification.                                                                                                                                                  |
+| `taskTitle`   | `<string>`                                            | **Android Required**. Notification title.                                                                                                                                      |
+| `taskDesc`    | `<string>`                                            | **Android Required**. Notification description.                                                                                                                                |
+| `taskIcon`    | [`<taskIconOptions>`](#taskIconOptions)               | **Android Required**. Notification icon.                                                                                                                                       |
+| `color`       | `<string>`                                            | Notification color. **Default**: `"#ffffff"`.                                                                                                                                  |
+| `linkingURI`  | `<string>`                                            | Link that will be called when the notification is clicked. Example: `"yourSchemeHere://chat/jane"`. See [Deep Linking](#deep-linking) for more info. **Default**: `undefined`. |
+| `progressBar` | [`<taskProgressBarOptions>`](#taskProgressBarOptions) | Notification progress bar.                                                                                                                                                     |
+| `parameters`  | `<any>`                                               | Parameters to pass to the task.                                                                                                                                                |
+
+#### taskIconOptions
+**Android only**
+| Property  | Type       | Description                                                                                                                                          |
+| --------- | ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `name`    | `<string>` | **Required**. Icon name in res/ folder. Ex: `ic_launcher`.                                                                                           |
+| `type`    | `<string>` | **Required**. Icon type in res/ folder. Ex: `mipmap`.                                                                                                |
+| `package` | `<string>` | Icon package where to search the icon. Ex: `com.example.package`. **It defaults to the app's package. It is highly recommended to leave like that.** |
+
+Example:
+
+![photo5837026843969041365](https://user-images.githubusercontent.com/44206249/72532521-de49e280-3873-11ea-8bf6-00618bcb82ab.jpg)
+
+#### taskProgressBarOptions
+**Android only**
+| Property        | Type        | Description                                   |
+| --------------- | ----------- | --------------------------------------------- |
+| `max`           | `<number>`  | **Required**. Maximum value.                  |
+| `value`         | `<number>`  | **Required**. Current value.                  |
+| `indeterminate` | `<boolean>` | Display the progress status as indeterminate. |
+
+Example:
+
+![ProgressBar](https://developer.android.com/images/ui/notifications/notification-progressbar_2x.png)
+
+### Deep Linking
+**Android only**
+
+To handle incoming links when the notification is clicked by the user, first you need to modify your **`android/app/src/main/AndroidManifest.xml`** and add an `<intent-filter>` (fill `yourSchemeHere` with the name you prefer):
+```xml
+  <manifest ... >
+      ...
+      <application ... >
+          <activity
+              ...
+              android:launchMode="singleTask"> // Add this if not present
+                  ...
+                  <intent-filter android:label="filter_react_native">
+                      <action android:name="android.intent.action.VIEW" />
+                      <category android:name="android.intent.category.DEFAULT" />
+                      <category android:name="android.intent.category.BROWSABLE" />
+                      <data android:scheme="yourSchemeHere" />
+                  </intent-filter>
+      </application>
+    </manifest>
+```
+
+You must provide a `linkingURI` in the BackgroundService's [options](#options) that matches the scheme you just added to **`android/app/src/main/AndroidManifest.xml`**:
+```js
+const options = {
+    taskName: 'Example',
+    taskTitle: 'ExampleTask title',
+    taskDesc: 'ExampleTask description',
+    taskIcon: {
+        name: 'ic_launcher',
+        type: 'mipmap',
+    },
+    color: '#ff00ff',
+    linkingURI: 'yourSchemeHere://chat/jane', // Add this
+    parameters: {
+        delay: 1000,
+    },
+};
+
+
+await BackgroundService.start(veryIntensiveTask, options);
+```
+
+React Native provides a `Linking` class to get notified of incoming links. Your JavaScript code must then listen to the url using React Native `Linking` class:
+```js
+import { Linking } from 'react-native';
+
+Linking.addEventListener('url', handleOpenURL);
+
+function handleOpenURL(evt) {
+    // Will be called when the notification is pressed
+    console.log(evt.url);
+    // do something
+}
+```
+
+### Events
+#### 'expiration'
+**iOS only**
+Listen for the iOS-only expiration handler that allows you to 'clean up' shortly before the app’s remaining background time reaches 0. Check the iOS [documentation](https://developer.apple.com/documentation/uikit/uiapplication/1623031-beginbackgroundtask) for more info.
+
+```js
+BackgroundService.on('expiration', () => {
+    console.log('I am being closed :(');
+});
+
+await BackgroundService.start(veryIntensiveTask, options);
+
+```
+
+## Maintainers
+
+* [Rapsssito](https://github.com/rapsssito) [[Support me :heart:](https://github.com/sponsors/Rapsssito)]
+
+## Acknowledgments
+
+* iOS part originally forked from [react-native-background-timer](https://github.com/ocetnik/react-native-background-timer)
+
+## License
+
+The library is released under the MIT license. For more information see [`LICENSE`](/LICENSE).

package/android/build.gradle

@@ -0,0 +1,24 @@
+apply plugin: 'com.android.library'
+
+def safeExtGet(prop, fallback) {
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+android {
+    compileSdkVersion safeExtGet('compileSdkVersion', 34)
+
+    defaultConfig {
+        minSdkVersion safeExtGet('minSdkVersion', 16)
+        targetSdkVersion safeExtGet('targetSdkVersion', 34)
+    }
+
+    // Conditional for compatibility with AGP <4.2.
+    if (project.android.hasProperty("namespace")) {
+        namespace = "com.asterinet.react.bgactions"
+    }
+}
+
+dependencies {
+    //noinspection GradleDynamicVersion
+    implementation 'com.facebook.react:react-native:+'  // From node_modules
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,6 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.asterinet.react.bgactions">
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <application>
+        <service android:name=".RNBackgroundActionsTask"/>
+    </application>
+</manifest>

package/android/src/main/java/com/asterinet/react/bgactions/BackgroundActionsModule.java

@@ -0,0 +1,91 @@
+package com.asterinet.react.bgactions;
+
+import android.app.Notification;
+import android.app.NotificationManager;
+import android.content.Context;
+import android.content.Intent;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+
+@SuppressWarnings("WeakerAccess")
+public class BackgroundActionsModule extends ReactContextBaseJavaModule {
+
+    private static final String TAG = "RNBackgroundActions";
+
+    private final ReactContext reactContext;
+
+    private Intent currentServiceIntent;
+
+    public BackgroundActionsModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.reactContext = reactContext;
+    }
+
+    @NonNull
+    @Override
+    public String getName() {
+        return TAG;
+    }
+
+    @SuppressWarnings("unused")
+    @ReactMethod
+    public void start(@NonNull final ReadableMap options, @NonNull final Promise promise) {
+        try {
+            // Stop any other intent
+            if (currentServiceIntent != null) reactContext.stopService(currentServiceIntent);
+            // Create the service
+            currentServiceIntent = new Intent(reactContext, RNBackgroundActionsTask.class);
+            // Get the task info from the options
+            final BackgroundTaskOptions bgOptions = new BackgroundTaskOptions(reactContext, options);
+            currentServiceIntent.putExtras(bgOptions.getExtras());
+            // Start the task
+            reactContext.startService(currentServiceIntent);
+            promise.resolve(null);
+        } catch (Exception e) {
+            promise.reject(e);
+        }
+    }
+
+    @SuppressWarnings("unused")
+    @ReactMethod
+    public void stop(@NonNull final Promise promise) {
+        if (currentServiceIntent != null)
+            reactContext.stopService(currentServiceIntent);
+        promise.resolve(null);
+    }
+
+    @SuppressWarnings("unused")
+    @ReactMethod
+    public void updateNotification(@NonNull final ReadableMap options, @NonNull final Promise promise) {
+        // Get the task info from the options
+        try {
+            final BackgroundTaskOptions bgOptions = new BackgroundTaskOptions(reactContext, options);
+            final Notification notification = RNBackgroundActionsTask.buildNotification(reactContext, bgOptions);
+            final NotificationManager notificationManager = (NotificationManager) reactContext.getSystemService(Context.NOTIFICATION_SERVICE);
+            notificationManager.notify(RNBackgroundActionsTask.SERVICE_NOTIFICATION_ID, notification);
+        } catch (Exception e) {
+            promise.reject(e);
+            return;
+        }
+        promise.resolve(null);
+    }
+
+    @SuppressWarnings("unused")
+    @ReactMethod
+    public void addListener(String eventName) {
+        // Keep: Required for RN built in Event Emitter Calls.
+    }
+
+    @SuppressWarnings("unused")
+    @ReactMethod
+    public void removeListeners(Integer count) {
+        // Keep: Required for RN built in Event Emitter Calls.
+    }
+}

package/android/src/main/java/com/asterinet/react/bgactions/BackgroundActionsPackage.java

@@ -0,0 +1,26 @@
+package com.asterinet.react.bgactions;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import androidx.annotation.NonNull;
+
+@SuppressWarnings("unused")
+public class BackgroundActionsPackage implements ReactPackage {
+    @Override
+    public @NonNull List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+        //noinspection ArraysAsListWithZeroOrOneArgument
+        return Arrays.<NativeModule>asList(new BackgroundActionsModule(reactContext));
+    }
+
+    @Override
+    public @NonNull List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+}

package/android/src/main/java/com/asterinet/react/bgactions/BackgroundTaskOptions.java

@@ -0,0 +1,104 @@
+package com.asterinet.react.bgactions;
+
+import android.graphics.Color;
+import android.os.Bundle;
+
+import androidx.annotation.ColorInt;
+import androidx.annotation.IdRes;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReadableMap;
+
+public final class BackgroundTaskOptions {
+    private final Bundle extras;
+
+    public BackgroundTaskOptions(@NonNull final Bundle extras) {
+        this.extras = extras;
+    }
+
+    public BackgroundTaskOptions(@NonNull final ReactContext reactContext, @NonNull final ReadableMap options) {
+        // Create extras
+        extras = Arguments.toBundle(options);
+        if (extras == null)
+            throw new IllegalArgumentException("Could not convert arguments to bundle");
+        // Get taskTitle
+        try {
+            if (options.getString("taskTitle") == null)
+                throw new IllegalArgumentException();
+        } catch (Exception e) {
+            throw new IllegalArgumentException("Task title cannot be null");
+        }
+        // Get taskDesc
+        try {
+            if (options.getString("taskDesc") == null)
+                throw new IllegalArgumentException();
+        } catch (Exception e) {
+            throw new IllegalArgumentException("Task description cannot be null");
+        }
+        // Get iconInt
+        try {
+            final ReadableMap iconMap = options.getMap("taskIcon");
+            if (iconMap == null)
+                throw new IllegalArgumentException();
+            final String iconName = iconMap.getString("name");
+            final String iconType = iconMap.getString("type");
+            String iconPackage;
+            try {
+                iconPackage = iconMap.getString("package");
+                if (iconPackage == null)
+                    throw new IllegalArgumentException();
+            } catch (Exception e) {
+                // Get the current package as default
+                iconPackage = reactContext.getPackageName();
+            }
+            final int iconInt = reactContext.getResources().getIdentifier(iconName, iconType, iconPackage);
+            extras.putInt("iconInt", iconInt);
+            if (iconInt == 0)
+                throw new IllegalArgumentException();
+        } catch (Exception e) {
+            throw new IllegalArgumentException("Task icon not found");
+        }
+        // Get color
+        try {
+            final String color = options.getString("color");
+            extras.putInt("color", Color.parseColor(color));
+        } catch (Exception e) {
+            extras.putInt("color", Color.parseColor("#ffffff"));
+        }
+    }
+
+    public Bundle getExtras() {
+        return extras;
+    }
+
+    public String getTaskTitle() {
+        return extras.getString("taskTitle", "");
+    }
+
+    public String getTaskDesc() {
+        return extras.getString("taskDesc", "");
+    }
+
+    @IdRes
+    public int getIconInt() {
+        return extras.getInt("iconInt");
+    }
+
+    @ColorInt
+    public int getColor() {
+        return extras.getInt("color");
+    }
+
+    @Nullable
+    public String getLinkingURI() {
+        return extras.getString("linkingURI");
+    }
+
+    @Nullable
+    public Bundle getProgressBar() {
+        return extras.getBundle("progressBar");
+    }
+}

package/android/src/main/java/com/asterinet/react/bgactions/RNBackgroundActionsTask.java

@@ -0,0 +1,120 @@
+package com.asterinet.react.bgactions;
+
+import android.annotation.SuppressLint;
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.content.pm.ServiceInfo;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import android.Manifest;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.core.app.NotificationCompat;
+import androidx.core.content.ContextCompat;
+
+import com.facebook.react.HeadlessJsTaskService;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.jstasks.HeadlessJsTaskConfig;
+
+final public class RNBackgroundActionsTask extends HeadlessJsTaskService {
+
+    public static final int SERVICE_NOTIFICATION_ID = 92901;
+    private static final String CHANNEL_ID = "RN_BACKGROUND_ACTIONS_CHANNEL";
+
+    @SuppressLint("UnspecifiedImmutableFlag")
+    @NonNull
+    public static Notification buildNotification(@NonNull Context context, @NonNull final BackgroundTaskOptions bgOptions) {
+        // Get info
+        final String taskTitle = bgOptions.getTaskTitle();
+        final String taskDesc = bgOptions.getTaskDesc();
+        final int iconInt = bgOptions.getIconInt();
+        final int color = bgOptions.getColor();
+        final String linkingURI = bgOptions.getLinkingURI();
+        Intent notificationIntent;
+        if (linkingURI != null) {
+            notificationIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(linkingURI));
+        } else {
+            //as RN works on single activity architecture - we don't need to find current activity on behalf of react context
+            notificationIntent = new Intent(Intent.ACTION_MAIN).addCategory(Intent.CATEGORY_LAUNCHER);
+        }
+        final PendingIntent contentIntent;
+        if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+            contentIntent = PendingIntent.getActivity(context,0, notificationIntent, PendingIntent.FLAG_MUTABLE | PendingIntent.FLAG_ALLOW_UNSAFE_IMPLICIT_INTENT);
+        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            contentIntent = PendingIntent.getActivity(context, 0, notificationIntent, PendingIntent.FLAG_MUTABLE);
+        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            contentIntent = PendingIntent.getActivity(context, 0, notificationIntent, PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE);
+        } else {
+            contentIntent = PendingIntent.getActivity(context, 0, notificationIntent, PendingIntent.FLAG_UPDATE_CURRENT);
+        }
+        final NotificationCompat.Builder builder = new NotificationCompat.Builder(context, CHANNEL_ID)
+                .setContentTitle(taskTitle)
+                .setContentText(taskDesc)
+                .setSmallIcon(iconInt)
+                .setContentIntent(contentIntent)
+                .setOngoing(true)
+                .setPriority(NotificationCompat.PRIORITY_MIN)
+                .setColor(color);
+
+        final Bundle progressBarBundle = bgOptions.getProgressBar();
+        if (progressBarBundle != null) {
+            final int progressMax = (int) Math.floor(progressBarBundle.getDouble("max"));
+            final int progressCurrent = (int) Math.floor(progressBarBundle.getDouble("value"));
+            final boolean progressIndeterminate = progressBarBundle.getBoolean("indeterminate");
+            builder.setProgress(progressMax, progressCurrent, progressIndeterminate);
+        }
+        return builder.build();
+    }
+
+    @Override
+    protected @Nullable
+    HeadlessJsTaskConfig getTaskConfig(Intent intent) {
+        final Bundle extras = intent.getExtras();
+        if (extras != null) {
+            return new HeadlessJsTaskConfig(extras.getString("taskName"), Arguments.fromBundle(extras), 0, true);
+        }
+        return null;
+    }
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        final Bundle extras = intent.getExtras();
+        if (extras == null) {
+            throw new IllegalArgumentException("Extras cannot be null");
+        }
+        final BackgroundTaskOptions bgOptions = new BackgroundTaskOptions(extras);
+        createNotificationChannel(bgOptions.getTaskTitle(), bgOptions.getTaskDesc()); // Necessary creating channel for API 26+
+        // Create the notification
+        final Notification notification = buildNotification(this, bgOptions);
+
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+            startForeground(SERVICE_NOTIFICATION_ID, notification);
+        } else {
+            if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) == PackageManager.PERMISSION_GRANTED && 
+                ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED
+            ) {
+                startForeground(SERVICE_NOTIFICATION_ID, notification, 
+                ServiceInfo.FOREGROUND_SERVICE_TYPE_LOCATION);
+            }
+        }
+
+        return super.onStartCommand(intent, flags, startId);
+    }
+
+    private void createNotificationChannel(@NonNull final String taskTitle, @NonNull final String taskDesc) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            final int importance = NotificationManager.IMPORTANCE_LOW;
+            final NotificationChannel channel = new NotificationChannel(CHANNEL_ID, taskTitle, importance);
+            channel.setDescription(taskDesc);
+            final NotificationManager notificationManager = getSystemService(NotificationManager.class);
+            notificationManager.createNotificationChannel(channel);
+        }
+    }
+}

package/ios/RNBackgroundActions.h

@@ -0,0 +1,6 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RNBackgroundActions : RCTEventEmitter<RCTBridgeModule>
+
+@end

package/ios/RNBackgroundActions.m

@@ -0,0 +1,53 @@
+@import UIKit;
+#import "RNBackgroundActions.h"
+
+@implementation RNBackgroundActions {
+    UIBackgroundTaskIdentifier bgTask;
+}
+
+RCT_EXPORT_MODULE()
+- (NSArray<NSString *> *)supportedEvents
+{
+    return @[@"expiration"];
+}
+
+- (void) _start
+{
+    [self _stop];
+    bgTask = [[UIApplication sharedApplication] beginBackgroundTaskWithName:@"RNBackgroundActions" expirationHandler:^{
+        [self onExpiration];
+        [[UIApplication sharedApplication] endBackgroundTask: self->bgTask];
+        self->bgTask = UIBackgroundTaskInvalid;
+    }];
+}
+
+- (void) _stop
+{
+    if (bgTask != UIBackgroundTaskInvalid) {
+        [[UIApplication sharedApplication] endBackgroundTask:bgTask];
+        bgTask = UIBackgroundTaskInvalid;
+    }
+}
+
+- (void)onExpiration
+{
+    [self sendEventWithName:@"expiration"
+                       body:@{}];
+}
+
+RCT_EXPORT_METHOD(start:(NSDictionary *)options
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    [self _start];
+    resolve(nil);
+}
+
+RCT_EXPORT_METHOD(stop:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    [self _stop];
+    resolve(nil);
+}
+
+@end