apps-sdk 1.0.187 → 1.0.189

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apps-sdk",
-  "version": "1.0.187",
+  "version": "1.0.189",
   "description": "Apps SDK",
   "main": "index.js",
   "scripts": {

package/src/libraries/Adapty.js

@@ -1,6 +1,7 @@
 import { adapty } from 'react-native-adapty';
 import * as config from '../../config';
 import {Session} from "./index";
+import {createPaywallView} from "react-native-adapty/dist/ui";
 
 class Adapty {
     async initialize(apiKey = null) {
@@ -15,6 +16,7 @@ class Adapty {
                     diskStorageSizeLimit: 100 * 1024 * 1024, // 100MB
                 },
             });
+            const profile = await adapty.getProfile();
         } catch (error) {
             console.error('Error initializing Adapty:', error);
         }
@@ -22,10 +24,63 @@ class Adapty {
 
     async getPaywallForPlacement(placementID, lang) {
         try {
-            config.DEBUG_MODE && console.log('Getting paywall for placement:', placementID, 'and language:', lang);
             return await adapty.getPaywall(placementID, lang);
         } catch (error) {
-            console.error('Error getting paywall:', error);
+            return null;
+        }
+    }
+
+    async isActivated() {
+        try {
+            return await adapty.isActivated();
+        } catch (error) {
+            console.error('Error getting Adapty activation status:', error);
+            return false;
+        }
+    }
+
+    async createPaywallView(paywall) {
+        try {
+            return await createPaywallView(paywall);
+        } catch (error) {
+            console.error('Error creating paywall view:', error);
+            return null;
+        }
+    }
+
+    async showPaywall(placementID, lang, eventHandlers = {}) {
+        try {
+            const paywall = await this.getPaywallForPlacement(placementID, lang);
+            config.DEBUG_MODE && console.log('Getting paywall for placement:', placementID, 'and language:', lang, 'paywall:', paywall);
+            if (paywall) {
+                const paywallView = await this.createPaywallView(paywall);
+                paywallView.registerEventHandlers({
+                    onCloseButtonPress: eventHandlers.onCloseButtonPress || (() => { return true; }),
+                    onAndroidSystemBack: eventHandlers.onAndroidSystemBack || (() => { paywallView.dismiss(); return true; }),
+                    onPurchaseCompleted: eventHandlers.onPurchaseCompleted || (() => { paywallView.dismiss(); return true; }),
+                    onPurchaseStarted: eventHandlers.onPurchaseStarted || (() => { }),
+                    onPurchaseFailed: eventHandlers.onPurchaseFailed || (() => { paywallView.dismiss(); return true; }),
+                    onRestoreCompleted: eventHandlers.onRestoreCompleted || (() => { paywallView.dismiss(); return true; }),
+                    onRestoreFailed: eventHandlers.onRestoreFailed || (() => { paywallView.dismiss(); return true; }),
+                    onProductSelected: eventHandlers.onProductSelected || (() => {  }),
+                    onRenderingFailed: eventHandlers.onRenderingFailed || (() => { return true; }),
+                    onLoadingProductsFailed: eventHandlers.onLoadingProductsFailed || (() => { paywallView.dismiss(); return true; }),
+                    onUrlPress: eventHandlers.onUrlPress || (() => { return true; }),
+                });
+                await paywallView.present();
+            } else {
+                console.warn('Error showing paywall: paywall not found for placement', placementID, 'and language', lang);
+            }
+        } catch (error) {
+            console.error('Error showing paywall:', error);
+        }
+    }
+
+    async getProfile() {
+        try {
+            return await adapty.getProfile();
+        } catch (error) {
+            console.error('Error getting profile:', error);
             return null;
         }
     }

package/src/libraries/MixPanel.js

@@ -25,50 +25,83 @@ class MixPanel {
         }
     }
 
-    async identifyUser(userId) {
+    async trackEvent(eventName, properties = {}) {
         if (!this.mixpanel) {
             console.log('Mixpanel is not initialized');
             return;
         }
 
         try {
-            await this.mixpanel.identify(userId);
-            this.mixpanel.getPeople().set('user_id', userId);
-            this.mixpanel.getPeople().set('subscribed_user', Session.getIsSubscribed());
-            this.mixpanel.getPeople().set('app_version', Constants.expoConfig.version);
-            this.mixpanel.getPeople().set('language', Localization.getLocales()[0].languageCode || 'en');
-            config.DEBUG_MODE && console.log(`MixPanel User identified: ${userId} with data:`, {
-                subscribed_user: Session.getIsSubscribed(),
-                app_version: Constants.expoConfig.version,
-                language: Localization.getLocales()[0].languageCode || 'en'
-            });
+            await this.mixpanel.track(eventName, properties);
+            config.DEBUG_MODE && console.log(`MixPanel Event tracked: ${eventName} with properties:`, properties);
         } catch (error) {
-            console.error('Error identifying user:', error);
+            console.error('Error tracking event:', error);
         }
     }
 
-    async trackEvent(eventName, properties = {}) {
+    async trackEventIfExist(eventKeyword, eventData = {}) {
+        if (config.EVENTS_MIXPANEL[eventKeyword]) {
+            this.trackEvent(eventKeyword, eventData);
+        } else {
+            console.log("Event not found in MixPanel, not sent: " + eventKeyword);
+        }
+    }
+
+    async superProperties(properties) {
         if (!this.mixpanel) {
             console.log('Mixpanel is not initialized');
             return;
         }
 
         try {
-            await this.mixpanel.track(eventName, properties);
-            config.DEBUG_MODE && console.log(`MixPanel Event tracked: ${eventName} with properties:`, properties);
+            await this.mixpanel.registerSuperProperties(properties);
+            config.DEBUG_MODE && console.log('MixPanel Super Properties registered:', properties);
         } catch (error) {
-            console.error('Error tracking event:', error);
+            console.error('Error registering super properties:', error);
         }
     }
 
-    async trackEventIfExist(eventKeyword, eventData = {}) {
-        if (config.EVENTS_MIXPANEL[eventKeyword]) {
-            this.trackEvent(eventKeyword, eventData);
-        } else {
-            console.log("Event not found in MixPanel, not sent: " + eventKeyword);
+    async superPropertiesAppend(properties) {
+        if (!this.mixpanel) {
+            console.log('Mixpanel is not initialized');
+            return;
+        }
+
+        try {
+            await this.mixpanel.registerSuperPropertiesOnce(properties);
+            config.DEBUG_MODE && console.log('MixPanel Super Properties appended:', properties);
+        } catch (error) {
+            console.error('Error appending super properties:', error);
+        }
+    }
+
+    async identifyUser(userID) {
+        if (!this.mixpanel) {
+            console.log('Mixpanel is not initialized');
+            return;
+        }
+
+        try {
+            await this.mixpanel.identify(userID);
+            config.DEBUG_MODE && console.log('MixPanel User identified:', userID);
+        } catch (error) {
+            console.error('Error identifying user:', error);
         }
     }
 
+    async setUserProperty(propertyName, propertyValue) {
+        if (!this.mixpanel) {
+            console.log('Mixpanel is not initialized');
+            return;
+        }
+
+        try {
+            await this.mixpanel.getPeople().set(propertyName, propertyValue);
+            config.DEBUG_MODE && console.log(`MixPanel User property set: ${propertyName} = ${propertyValue}`);
+        } catch (error) {
+            console.error('Error setting user property:', error);
+        }
+    }
 
     isMixpanelInitialized() {
         return this.mixpanel !== null;

package/types/index.d.ts

@@ -75,7 +75,7 @@ declare module 'apps-sdk' {
         getEndpoints(): any;
         setEvents(events: any): void;
         sendEvent(eventType: string, eventKeyword:string, eventData?: object, forceSend?: boolean): Promise<void>;
-        createSubscription(): any;
+        createSubscription(data: any): Promise<boolean>;
         checkConnection(): Promise<boolean>;
         setImageCompression(compression: any): void;
         addPendingEvent(event: any): void;
@@ -181,15 +181,36 @@ declare module 'apps-sdk' {
 
     export class MixPanel {
         initialize(token?: string, trackAutomaticEvents?: boolean, useNative?: boolean): Promise<void>;
-        identifyUser(userID: string): Promise<void>;
         trackEvent(event: string, properties?: object): Promise<void>;
-        isMixpanelInitialized(): boolean;
         trackEventIfExist(eventKeyword: string, eventData?: object): Promise<void>;
-    }
+        isMixpanelInitialized(): boolean;
+        superProperties(properties: object): Promise<void>;
+        superPropertiesAppend(properties: object): Promise<void>;
+        identifyUser(userID: string): Promise<void>;
+        setUserProperty(property: string, value: any): Promise<void>;
+    }
+
+    type PaywallEventHandlers = {
+        onCloseButtonPress?: () => void;
+        onAndroidSystemBack?: () => void;
+        onPurchaseCompleted?: (purchaseResult: any, product: any) => void;
+        onPurchaseStarted?: (product: any) => void;
+        onPurchaseFailed?: (error: any) => void;
+        onRestoreCompleted?: (profile: any) => void;
+        onRestoreFailed?: (error: any, product: any) => void;
+        onProductSelected?: (productId: string) => void;
+        onRenderingFailed?: (error: any) => void;
+        onLoadingProductsFailed?: (error: any) => void;
+        onUrlPress?: (url: string) => void;
+    };
 
     export class Adapty {
         initialize(apiKey: string): Promise<void>;
         getPaywallForPlacement(placementID: string, lang: string): Promise<any>;
+        isActivated(): Promise<boolean>;
+        createPaywallView(paywall: any): Promise<any>;
+        showPaywall(placementID: any, lang: any, eventHandlers?: PaywallEventHandlers): Promise<void>;
+        getProfile(): Promise<any>;
     }
 
     export class TrackingTransparency {