@imatis/react-native-notifications 4.1.2-imatis.7 → 4.2.4-imatis.21

package/lib/android/app/src/test/java/com/wix/reactnativenotifications/core/notification/PushNotificationTest.java

@@ -0,0 +1,381 @@
+package com.wix.reactnativenotifications.core.notification;
+
+import android.app.Activity;
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.content.res.Resources;
+import android.os.Bundle;
+import android.os.Message;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.JavaOnlyMap;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.WritableMap;
+import com.wix.reactnativenotifications.core.AppLaunchHelper;
+import com.wix.reactnativenotifications.core.AppLifecycleFacade;
+import com.wix.reactnativenotifications.core.AppLifecycleFacade.AppVisibilityListener;
+import com.wix.reactnativenotifications.core.InitialNotificationHolder;
+import com.wix.reactnativenotifications.core.JsIOHelper;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatcher;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.Shadows;
+import org.robolectric.shadows.ShadowNotification;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.argThat;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import edu.emory.mathcs.backport.java.util.Arrays;
+
+@RunWith(RobolectricTestRunner.class)
+public class PushNotificationTest {
+
+    private static final String NOTIFICATION_OPENED_EVENT_NAME = "notificationOpened";
+    private static final String NOTIFICATION_RECEIVED_EVENT_NAME = "notificationReceived";
+    private static final String NOTIFICATION_RECEIVED_BACKGROUND_EVENT_NAME = "notificationReceivedBackground";
+
+    private static final String DEFAULT_NOTIFICATION_TITLE = "Notification-title";
+    private static final String DEFAULT_NOTIFICATION_BODY = "Notification-body";
+
+    @Mock private ReactContext mReactContext;
+    @Mock private Context mContext;
+    @Mock private NotificationManager mNotificationManager;
+
+    private Bundle mResponseBundle;
+    private Bundle mNotificationBundle;
+    @Mock private Intent mLaunchIntent;
+    @Mock private AppLifecycleFacade mAppLifecycleFacade;
+    @Mock private AppLaunchHelper mAppLaunchHelper;
+    @Mock private JsIOHelper mJsIOHelper;
+    @Mock private Resources mResources;
+    @Mock private PackageManager mPackageManager;
+
+    @Before
+    public void setup() throws Exception {
+        MockitoAnnotations.initMocks(this);
+        InitialNotificationHolder.setInstance(mock(InitialNotificationHolder.class));
+
+        mNotificationBundle = new Bundle();
+        mNotificationBundle.putString("title", DEFAULT_NOTIFICATION_TITLE);
+        mNotificationBundle.putString("body", DEFAULT_NOTIFICATION_BODY);
+
+        mResponseBundle = new Bundle();
+        mResponseBundle.putBundle("notification", mNotificationBundle);
+
+        when(mAppLaunchHelper.getLaunchIntent(eq(mContext))).thenReturn(mLaunchIntent);
+
+        ApplicationInfo ai = mock(ApplicationInfo.class);
+        when(mContext.getApplicationInfo()).thenReturn(ai);
+        when(mContext.getResources()).thenReturn(mResources);
+        when(mContext.getPackageManager()).thenReturn(mPackageManager);
+        when(mContext.getSystemService(Context.NOTIFICATION_SERVICE)).thenReturn(mNotificationManager);
+    }
+
+    @Test
+    public void onOpened_noReactContext_launchApp() throws Exception {
+        when(mAppLifecycleFacade.isReactInitialized()).thenReturn(false);
+
+        final PushNotification uut = createUUT();
+        uut.onOpened();
+
+        verify(mContext).startActivity(eq(mLaunchIntent));
+
+        // The unit shouldn't wait for visibility in this case cause we dont make the extra effort of
+        // notifying the notification upon app launch completion (simply cause we dont know when in completes).
+        // Instead, the user is expected to use getInitialNotification().
+        verify(mAppLifecycleFacade, never()).addVisibilityListener(any(AppVisibilityListener.class));
+    }
+
+    @Test
+    public void onOpened_noReactContext_setAsInitialNotification() throws Exception {
+        when(mAppLifecycleFacade.isReactInitialized()).thenReturn(false);
+        Activity currentActivity = mock(Activity.class);
+        when(mReactContext.getCurrentActivity()).thenReturn(currentActivity);
+
+        final PushNotification uut = createUUT();
+        uut.onOpened();
+
+        verify(InitialNotificationHolder.getInstance()).set(any(PushNotificationProps.class));
+    }
+
+    @Test
+    public void onOpened_appInvisible_resumeAppWaitForVisibility() throws Exception {
+        setUpBackgroundApp();
+
+        final PushNotification uut = createUUT();
+        uut.onOpened();
+
+        verify(mContext).startActivity(any(Intent.class));
+        verify(mAppLifecycleFacade).addVisibilityListener(any(AppVisibilityListener.class));
+    }
+
+    @Test
+    public void onOpened_appInvisible_dontSetInitialNotification() throws Exception {
+        setUpBackgroundApp();
+        Activity currentActivity = mock(Activity.class);
+        when(mReactContext.getCurrentActivity()).thenReturn(currentActivity);
+
+        final PushNotification uut = createUUT();
+        uut.onOpened();
+
+        verify(InitialNotificationHolder.getInstance(), never()).set(any(PushNotificationProps.class));
+    }
+
+    @Test
+    public void onOpened_appGoesVisible_resumeAppAndNotifyJs() throws Exception {
+
+        // Arrange
+
+        setUpBackgroundApp();
+
+        // Act
+
+        final PushNotification uut = createUUT();
+        uut.onOpened();
+
+        // Hijack and invoke visibility listener
+        ArgumentCaptor<AppVisibilityListener> listenerCaptor = ArgumentCaptor.forClass(AppVisibilityListener.class);
+        verify(mAppLifecycleFacade).addVisibilityListener(listenerCaptor.capture());
+        AppVisibilityListener listener = listenerCaptor.getValue();
+        listener.onAppVisible();
+
+        // Assert
+
+        verify(mJsIOHelper).sendEventToJS(eq(NOTIFICATION_OPENED_EVENT_NAME), argThat(new isValidResponse(mResponseBundle)), eq(mReactContext));
+    }
+
+    @Test
+    public void onOpened_appVisible_notifyJS() throws Exception {
+        setUpForegroundApp();
+
+        final PushNotification uut = createUUT();
+        uut.onOpened();
+
+        verify(mContext, never()).startActivity(any(Intent.class));
+        verify(mJsIOHelper).sendEventToJS(eq(NOTIFICATION_OPENED_EVENT_NAME), argThat(new isValidResponse(mResponseBundle)), eq(mReactContext));
+    }
+
+    @Test
+    public void onOpened_appVisible_clearNotificationsDrawer() throws Exception {
+        verify(mNotificationManager, never()).cancelAll();
+        setUpForegroundApp();
+
+        final PushNotification uut = createUUT();
+        uut.onOpened();
+
+        verify(mNotificationManager, never()).cancelAll();
+    }
+
+    @Test
+    public void onOpened_appVisible_dontSetInitialNotification() throws Exception {
+        setUpForegroundApp();
+        Activity currentActivity = mock(Activity.class);
+        when(mReactContext.getCurrentActivity()).thenReturn(currentActivity);
+
+        final PushNotification uut = createUUT();
+        uut.onOpened();
+
+        verify(InitialNotificationHolder.getInstance(), never()).set(any(PushNotificationProps.class));
+    }
+
+    @Test
+    public void onOpened_reactInitializedWithNoActivities_setAsInitialNotification() throws Exception {
+        setUpBackgroundApp();
+        when(mReactContext.getCurrentActivity()).thenReturn(null); // Just for clarity
+
+        final PushNotification uut = createUUT();
+        uut.onOpened();
+
+        verify(InitialNotificationHolder.getInstance()).set(any(PushNotificationProps.class));
+    }
+
+    @Test
+    public void onReceived_validData_dontPostNotificationAndNotifyJS() throws Exception {
+        // Arrange
+
+        setUpForegroundApp();
+
+        // Act
+
+        final PushNotification uut = createUUT();
+        uut.onReceived();
+
+        // Assert
+
+        ArgumentCaptor<Notification> notificationCaptor = ArgumentCaptor.forClass(Notification.class);
+        verify(mNotificationManager, never()).notify(anyInt(), notificationCaptor.capture());
+        verify(mJsIOHelper).sendEventToJS(eq(NOTIFICATION_RECEIVED_EVENT_NAME), argThat(new isValidNotification(mNotificationBundle)), eq(mReactContext));
+    }
+
+    @Test
+    public void onReceived_validDataForBackgroundApp_postNotificationAndNotifyJs() throws Exception {
+        // Arrange
+
+        setUpBackgroundApp();
+
+        // Act
+
+        final PushNotification uut = createUUT();
+        uut.onReceived();
+
+        // Assert
+
+        ArgumentCaptor<Notification> notificationCaptor = ArgumentCaptor.forClass(Notification.class);
+        verify(mNotificationManager).notify(anyInt(), notificationCaptor.capture());
+        verify(mJsIOHelper).sendEventToJS(eq(NOTIFICATION_RECEIVED_BACKGROUND_EVENT_NAME), argThat(new isValidNotification(mNotificationBundle)), eq(mReactContext));
+    }
+
+    @Test
+    public void onReceived_validDataForDeadApp_postNotificationDontNotifyJS() throws Exception {
+        final PushNotification uut = createUUT();
+        uut.onReceived();
+
+        ArgumentCaptor<Notification> notificationCaptor = ArgumentCaptor.forClass(Notification.class);
+        verify(mNotificationManager).notify(anyInt(), notificationCaptor.capture());
+        verifyNotification(notificationCaptor.getValue());
+        verify(mJsIOHelper).sendEventToJS(eq(NOTIFICATION_RECEIVED_BACKGROUND_EVENT_NAME), argThat(new isValidNotification(mNotificationBundle)), eq(null));
+    }
+
+    @Test
+    public void onPostRequest_withValidDataButNoId_postNotifications() throws Exception {
+
+        // Arrange
+
+        setUpForegroundApp();
+
+        // Act
+
+        final PushNotification uut = createUUT();
+        uut.onPostRequest(null);
+
+        // Assert
+
+        ArgumentCaptor<Notification> notificationCaptor = ArgumentCaptor.forClass(Notification.class);
+        verify(mNotificationManager).notify(anyInt(), notificationCaptor.capture());
+        verifyNotification(notificationCaptor.getValue());
+
+        // Shouldn't notify an event on an explicit call to notification posting
+        verify(mJsIOHelper, never()).sendEventToJS(eq(NOTIFICATION_RECEIVED_EVENT_NAME), any(Bundle.class), any(ReactContext.class));
+    }
+
+    @Test
+    public void onPostRequest_withValidDataButNoId_idsShouldBeUnique() throws Exception {
+        createUUT().onPostRequest(null);
+        createUUT().onPostRequest(null);
+
+        ArgumentCaptor<Integer> idsCaptor = ArgumentCaptor.forClass(Integer.class);
+        verify(mNotificationManager, times(2)).notify(idsCaptor.capture(), any(Notification.class));
+        assertNotEquals(idsCaptor.getAllValues().get(0), idsCaptor.getAllValues().get(1));
+    }
+
+    @Test
+    public void onPostRequest_withValidDataAndExplicitId_postNotification() throws Exception {
+        final int id = 666;
+
+        final PushNotification uut = createUUT();
+        uut.onPostRequest(id);
+
+        verify(mNotificationManager).notify(eq(id), any(Notification.class));
+    }
+
+    @Test
+    public void onPostRequest_emptyData_postNotification() throws Exception {
+        PushNotification uut = createUUT(new Bundle());
+        uut.onPostRequest(null);
+
+        verify(mNotificationManager, never()).notify(anyInt(), any(Notification.class));
+    }
+
+    @Test
+    public void onCreate_noExistingChannel_createDefaultChannel() throws Exception {
+        createUUT();
+
+        verify(mNotificationManager).createNotificationChannel(any(NotificationChannel.class));
+    }
+
+    @Test
+    public void onCreate_existingChannel_notCreateDefaultChannel() throws Exception {
+        List<NotificationChannel> existingChannel = new ArrayList<>();
+        existingChannel.add(new NotificationChannel("id", "name", 1));
+        when(mNotificationManager.getNotificationChannels()).thenReturn(existingChannel);
+
+        createUUT();
+
+        verify(mNotificationManager, never()).createNotificationChannel(any(NotificationChannel.class));
+    }
+
+    protected PushNotification createUUT() {
+        return createUUT(mNotificationBundle);
+    }
+
+    protected PushNotification createUUT(Bundle bundle) {
+        return new PushNotification(mContext, bundle, mAppLifecycleFacade, mAppLaunchHelper, mJsIOHelper);
+    }
+
+    protected void setUpBackgroundApp() {
+        when(mAppLifecycleFacade.isReactInitialized()).thenReturn(true);
+        when(mAppLifecycleFacade.getRunningReactContext()).thenReturn(mReactContext);
+        when(mAppLifecycleFacade.isAppVisible()).thenReturn(false);
+    }
+
+    protected void setUpForegroundApp() {
+        when(mAppLifecycleFacade.isReactInitialized()).thenReturn(true);
+        when(mAppLifecycleFacade.getRunningReactContext()).thenReturn(mReactContext);
+        when(mAppLifecycleFacade.isAppVisible()).thenReturn(true);
+    }
+
+    protected void verifyNotification(Notification notification) {
+        ShadowNotification shadowNotification = Shadows.shadowOf(notification);
+        assertEquals(shadowNotification.getContentText(), DEFAULT_NOTIFICATION_BODY);
+        assertEquals(shadowNotification.getContentTitle(), DEFAULT_NOTIFICATION_TITLE);
+    }
+
+    private class isValidNotification implements ArgumentMatcher<Bundle> {
+        private Bundle left;
+
+        protected isValidNotification(Bundle left) {
+            this.left = left;
+        }
+
+        @Override
+        public boolean matches(Bundle right) {
+            return right.getString("body").equals(left.getString("body"));
+        }
+    }
+
+    private class isValidResponse implements ArgumentMatcher<Bundle> {
+        private Bundle left;
+
+        protected isValidResponse(Bundle left) {
+            this.left = left;
+        }
+
+        @Override
+        public boolean matches(Bundle right) {
+            return right.getBundle("notification").getString("body").equals(left.getBundle("notification").getString("body"));
+        }
+    }
+}

package/lib/android/app/src/test/java/com/wix/reactnativenotifications/core/notificationdrawer/PushNotificationsDrawerTest.java

@@ -0,0 +1,96 @@
+package com.wix.reactnativenotifications.core.notificationdrawer;
+
+import android.app.Activity;
+import android.app.NotificationManager;
+import android.content.Context;
+import android.content.Intent;
+
+import com.facebook.react.bridge.ReactContext;
+import com.wix.reactnativenotifications.core.AppLaunchHelper;
+import com.wix.reactnativenotifications.core.InitialNotificationHolder;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RobolectricTestRunner;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@RunWith(RobolectricTestRunner.class)
+public class PushNotificationsDrawerTest {
+
+    @Mock private ReactContext mReactContext;
+    @Mock private Context mContext;
+    @Mock private NotificationManager mNotificationManager;
+    @Mock private AppLaunchHelper mAppLaunchHelper;
+
+    @Before
+    public void setup() throws Exception {
+        MockitoAnnotations.initMocks(this);
+
+        InitialNotificationHolder.setInstance(mock(InitialNotificationHolder.class));
+        when(mContext.getSystemService(Context.NOTIFICATION_SERVICE)).thenReturn(mNotificationManager);
+    }
+
+    @Test
+    public void onAppInit_neverClearAllNotifications() throws Exception {
+        createUUT().onAppInit();
+        verify(mNotificationManager, never()).cancelAll();
+    }
+
+    @Test
+    public void onAppVisible_neverClearAllNotifications() throws Exception {
+        createUUT().onAppVisible();
+        verify(mNotificationManager, never()).cancelAll();
+    }
+
+    @Test
+    public void onNotificationOpened_neverClearAllNotifications() throws Exception {
+        createUUT().onNotificationOpened();
+        verify(mNotificationManager, never()).cancelAll();
+    }
+
+    @Test
+    public void onNotificationClearRequest_clearSpecificNotification() throws Exception {
+        createUUT().onNotificationClearRequest(666);
+        verify(mNotificationManager).cancel(eq(666));
+        verify(mNotificationManager, never()).cancelAll();
+    }
+
+    @Test
+    public void onNewActivity_activityIsNotTheOneLaunchedByNotifs_dontClearInitialNotification() throws Exception {
+        Activity activity = mock(Activity.class);
+        Intent intent = mock(Intent.class);
+        when(activity.getIntent()).thenReturn(intent);
+        when(mAppLaunchHelper.isLaunchIntentsActivity(activity)).thenReturn(false);
+        when(mAppLaunchHelper.isLaunchIntentOfNotification(any(Intent.class))).thenReturn(false);
+
+        createUUT().onNewActivity(activity);
+
+        verify(InitialNotificationHolder.getInstance(), never()).clear();
+    }
+
+    @Test
+    public void onNewActivity_activityLaunchedFromPushNotification_dontClearInitialNotification() throws Exception {
+        Activity activity = mock(Activity.class);
+        Intent intent = mock(Intent.class);
+        when(activity.getIntent()).thenReturn(intent);
+        when(mAppLaunchHelper.isLaunchIntentsActivity(activity)).thenReturn(true);
+        when(mAppLaunchHelper.isLaunchIntentOfNotification(eq(intent))).thenReturn(true);
+
+        createUUT().onNewActivity(activity);
+
+        verify(InitialNotificationHolder.getInstance(), never()).clear();
+    }
+
+    protected PushNotificationsDrawer createUUT() {
+        return new PushNotificationsDrawer(mContext, mAppLaunchHelper);
+    }
+}

package/lib/android/app/src/test/resources/robolectric.properties

@@ -0,0 +1 @@
+sdk=28

package/lib/android/build.gradle

@@ -6,7 +6,7 @@ buildscript {
         androidGradlePluginVersion = '4.0.0'
         kotlinVersion = "1.3.61"
         googleServices = "4.3.3"
-        androidSdkVersion = 29
+        androidSdkVersion = 31
     }
 
     repositories {

package/lib/android/local.properties

@@ -4,5 +4,5 @@
 # Location of the SDK. This is only used by Gradle.
 # For customization when using a Version Control System, please read the
 # header note.
-#Mon Jul 12 10:26:56 ICT 2021
-sdk.dir=/Users/troy/Library/Android/sdk
+#Tue Mar 22 09:43:01 CET 2022
+sdk.dir=/Users/larserlingdahl/Library/Android/sdk

package/lib/dist/commands/Commands.test.js

@@ -165,6 +165,8 @@ describe('Commands', () => {
                 providesAppNotificationSettings: false,
                 provisional: false,
                 announcement: false,
+                notificationCenter: true,
+                lockScreen: false,
             };
             ts_mockito_1.when(mockedNativeCommandsSender.checkPermissions()).thenResolve(expectedPermissions);
             const permissions = await uut.checkPermissions();

package/lib/dist/interfaces/NotificationCategory.d.ts

@@ -7,11 +7,12 @@ export interface NotificationTextInput {
     buttonTitle: string;
     placeholder: string;
 }
+export declare type ActivationMode = 'background' | 'foreground' | 'authenticationRequired' | 'destructive';
 export declare class NotificationAction {
     identifier: string;
-    activationMode: 'background' | 'foreground' | 'authenticationRequired' | 'destructive';
+    activationMode: ActivationMode;
     title: string;
     authenticationRequired: boolean;
     textInput?: NotificationTextInput;
-    constructor(identifier: string, activationMode: 'background' | 'foreground' | 'authenticationRequired' | 'destructive', title: string, authenticationRequired: boolean, textInput?: NotificationTextInput);
+    constructor(identifier: string, activationMode: ActivationMode, title: string, authenticationRequired: boolean, textInput?: NotificationTextInput);
 }

package/lib/dist/interfaces/NotificationPermissions.d.ts

@@ -9,4 +9,6 @@ export interface NotificationPermissions extends NotificationPermissionOptions {
     badge: boolean;
     alert: boolean;
     sound: boolean;
+    notificationCenter: boolean;
+    lockScreen: boolean;
 }

package/lib/src/interfaces/NotificationCategory.ts

@@ -13,14 +13,16 @@ export interface NotificationTextInput {
   placeholder: string;
 }
 
+export type ActivationMode = 'background' | 'foreground' | 'authenticationRequired' | 'destructive';
+
 export class NotificationAction {
   identifier: string;
-  activationMode: 'background' | 'foreground' | 'authenticationRequired' | 'destructive';
+  activationMode: ActivationMode;
   title: string;
   authenticationRequired: boolean;
   textInput?: NotificationTextInput;
 
-  constructor(identifier: string, activationMode: 'background' | 'foreground' | 'authenticationRequired' | 'destructive', title: string, authenticationRequired: boolean, textInput?: NotificationTextInput) {
+  constructor(identifier: string, activationMode: ActivationMode, title: string, authenticationRequired: boolean, textInput?: NotificationTextInput) {
     this.identifier = identifier;
     this.activationMode = activationMode;
     this.title = title;

package/metro.config.js

@@ -7,7 +7,6 @@ module.exports = {
     sourceExts: ['ts', 'tsx', 'js']
   },
   transformer: {
-    babelTransformerPath: require.resolve('react-native-typescript-transformer'),
     getTransformOptions: async () => ({
       transform: {
         experimentalImportSupport: false,

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "@imatis/react-native-notifications",
-  "version": "4.1.2-imatis.7",
+  "version": "4.2.4-imatis.21",
   "description": "Advanced Push Notifications (Silent, interactive notifications) for iOS & Android",
-  "author": "Lidan Hifi <lidan.hifi@gmail.com>",
   "license": "MIT",
   "keywords": [
     "react-component",
@@ -37,7 +36,7 @@
     "test-unit-android": "node ./scripts/test-unit --android",
     "test-js": "node ./scripts/test-js",
     "xcode": "open example/ios/NotificationsExampleApp.xcworkspace",
-    "androidStudio": "open -a /Applications/Android\\ Studio.app ./example/android",
+    "studio": "open -a /Applications/Android\\ Studio.app ./example/android",
     "prerelease": "npm run build",
     "release": "node ./scripts/release",
     "generate-changelog": "gren changelog",
@@ -46,8 +45,8 @@
   },
   "nativePackage": true,
   "peerDependencies": {
-    "react": ">=0.14.5",
-    "react-native": ">=0.25.1"
+    "react": "*",
+    "react-native": "*"
   },
   "devDependencies": {
     "@babel/plugin-proposal-export-default-from": "7.2.0",
@@ -55,19 +54,17 @@
     "@types/jest": "24.9.0",
     "@types/lodash": "4.14.170",
     "@types/react": "16.9.35",
-    "@types/react-native": "0.62.2",
+    "@types/react-native": "0.67.1",
     "@types/react-test-renderer": "16.9.2",
     "babel-eslint": "10.0.3",
-    "detox": "^17.5.7",
+    "detox": "^19.4.2",
     "github-release-notes": "https://github.com/yogevbd/github-release-notes/tarball/e601b3dba72dcd6cba323c1286ea6dd0c0110b58",
-    "hermes-engine": "0.4.2-rc1",
     "jest": "24.9.0",
     "lodash": "4.17.21",
-    "metro-react-native-babel-preset": "0.59.0",
-    "react": "16.11.0",
+    "metro-react-native-babel-preset": "0.66.2",
+    "react": "17.0.2",
     "react-autobind": "1.0.6",
-    "react-native": "0.62.2",
-    "react-native-typescript-transformer": "1.2.13",
+    "react-native": "0.67.3",
     "shell-utils": "1.0.10",
     "ts-mockito": "2.5.0",
     "tslint": "6.1.2",
@@ -134,4 +131,4 @@
       "html"
     ]
   }
-}
+}

package/react-native-notifications.podspec

@@ -6,15 +6,16 @@ Pod::Spec.new do |s|
   s.name           = 'react-native-notifications'
   s.version        = package['version']
   s.summary        = package['description']
-  s.description    = package['description']
-  s.license        = package['license']
-  s.author         = package['author']
+
+  s.authors        = "Wix.com"
   s.homepage       = package['homepage']
+  s.license        = package['license']
+  s.platform       = :ios, '11.0'
+
+  s.module_name    = 'RNNotifications'
   s.source         = { :git => 'https://github.com/wix/react-native-notifications', :tag => s.version }
-  s.module_name  = 'RNNotifications'
 
   s.requires_arc   = true
-  s.platform       = :ios, '8.0'
 
   s.preserve_paths = 'LICENSE', 'README.md', 'package.json', 'notification.ios.js', 'notification.android.js', 'index.android.js', 'index.ios.js'
   s.source_files   = 'lib/ios/*.{h,m}'

package/react-native.config.js

@@ -9,4 +9,12 @@ module.exports = {
     },
     assets: []
   },
+  project: {
+    ios: {
+      project: './example/ios/NotificationsExampleApp.xcworkspace',
+    },
+    android: {
+      sourceDir: './example/android/',
+    },
+  },
 };

package/android/app/src/reactNative59/reactNative59.iml

@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" inherit-compiler-output="true">
-    <exclude-output />
-    <content url="file://$MODULE_DIR$">
-      <sourceFolder url="file://$MODULE_DIR$/java" isTestSource="false" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>