apps-sdk 1.0.57 → 1.0.59

package/config.js

@@ -2,7 +2,8 @@ export var ENDPOINTS = {
     CONTENT: "https://backend.ailandsapp.com/content",
     PAYMENT_CARD: "https://backend.ailandsapp.com/payment-card",
     EVENTS_PUSH: "https://backend.ailandsapp.com/event/push",
-    ATTRIBUTION_SET_ID: "https://backend.ailandsapp.com/user/set-adjust-id",
+    ATTRIBUTION_SET_ID: "https://backend.ailandsapp.com/user/set-attribution-data",
+    SET_ATTRIBUTION_DATA: "https://backend.ailandsapp.com/user/set-attribution-data",
     USER_CREATE_ID: "https://backend.ailandsapp.com/user/create-id",
     NOTIFICATION_SET_TOKEN: "https://backend.ailandsapp.com/user/notification-token",
     CONFIG: "https://backend.ailandsapp.com/core/config",
@@ -34,9 +35,15 @@ export const EVENT_TYPES = {
 }
 
 export const ADJUST = {
-    ADJUST_TOKEN    : 'y4o1gcezs6ps',
-    ENVIRONMENT     : 'SANDBOX', // or 'PRODUCTION'
-    LOG_LEVEL       : 'VERBOSE'
+    ADJUST_TOKEN     : 'y4o1gcezs6ps',
+    ENVIRONMENT      : 'SANDBOX', // or 'PRODUCTION'
+    LOG_LEVEL        : 'VERBOSE',
+    ATTRIBUTION_DATA : {
+        ATTRIBUTION: {},
+        ADID: '',
+        IDFA: '',
+        GOOGLE_AID: '',
+    },
 }
 
 export var TRACKING_ACTIVE = true;

package/package.json

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

package/src/libraries/AdJust.js

@@ -1,19 +1,64 @@
 import { Adjust, AdjustEvent, AdjustConfig, AdjustPlayStoreSubscription, AdjustAppStoreSubscription, AdjustAttribution } from 'react-native-adjust';
 import * as config from '../../config';
 import { default as storage } from './Storage';
+import Session from './Session';
 import {Platform} from "react-native";
+import Networking from './Networking';
 
 class AdJust {
+    sdkVersion = null;
+    attribution = {};
     initialize() {
         const adjustEnvironment = config.ADJUST.ENVIRONMENT === 'SANDBOX' ? AdjustConfig.EnvironmentSandbox : AdjustConfig.EnvironmentProduction;
         const adjustLogLevel = config.ADJUST.LOG_LEVEL === 'VERBOSE' ? AdjustConfig.LogLevelVerbose : AdjustConfig.LogLevelSuppress;
         console.log("Initializing AdJust. Environment: " + adjustEnvironment + ", Log level: " + adjustLogLevel);
         const adjustConfig = new AdjustConfig(config.ADJUST.ADJUST_TOKEN, adjustEnvironment);
         adjustConfig.setLogLevel(adjustLogLevel);
+        const self = this;
         adjustConfig.setAttributionCallbackListener(function(attribution) {
-            console.log("AdJust Attribution callback received: ", JSON.stringify(attribution));
+            self.attribution = attribution;
+            setTimeout(() => {
+                self.sendAttributionData(attribution);
+            }, 60000);
         });
-        Adjust.create(adjustConfig);
+        Adjust.create(adjustConfig)
+    }
+
+    updateAttributionInfo() {
+        setTimeout(() => {
+            this.getAttribution();
+            this.getAdid();
+            this.getIdfa();
+            this.getGoogleAdId();
+            this.getSDKVersion();
+        }, 10000);
+    }
+
+    async getAttributionData() {
+        return new Promise((resolve, reject) => {
+            Adjust.getAttribution(attr => {
+                if (attr) {
+                    resolve(attr);
+                } else {
+                    reject('No attribution data');
+                }
+            });
+        });
+    }
+
+    async sendAttributionData(attribution) {
+        const data = {
+            user_id: Session.getUserID(),
+            adjust: {
+                attribution_id: Session.getAdjustAttributionID() || attribution.adid,
+                googleAdid: Session.getAdjustGoogleAdid(),
+                idfa: Session.getAdjustIDFA(),
+                sdkVersion: this.sdkVersion,
+                attribution: attribution,
+            }
+        }
+        console.log('sendAttributionData', data);
+        Networking.request(config.ENDPOINTS.SET_ATTRIBUTION_DATA, data);
     }
 
     trackEventIfExist(eventKeyword, eventValue= 0) {
@@ -63,6 +108,82 @@ class AdJust {
     isSpecialEvent(eventKeyword) {
         return config.SPECIAL_EVENTS.includes(eventKeyword);
     }
+
+    async getAttribution() {
+        try {
+            const attribution = await new Promise((resolve, reject) => {
+                Adjust.getAttribution((attribution) => {
+                    if (attribution) {
+                        resolve(attribution);
+                    } else {
+                        reject('Invalid Attribution');
+                    }
+                });
+            });
+
+            Session.setAdjustAttribution(attribution);
+        } catch (error) {
+            console.error(error);
+        }
+    }
+
+    async getAdid() {
+        try {
+            const adid = await new Promise((resolve, reject) => {
+                Adjust.getAdid((adid) => {
+                    if (adid) {
+                        resolve(adid);
+                    } else {
+                        reject('Invalid Adid');
+                    }
+                });
+            });
+
+            Session.setAdjustAttributionID(adid);
+        } catch (error) {
+            console.error(error);
+        }
+    }
+
+    async getGoogleAdId() {
+        try {
+            const googleAdId = await new Promise((resolve, reject) => {
+                Adjust.getGoogleAdId((googleAdId) => {
+                    if (googleAdId) {
+                        resolve(googleAdId);
+                    } else {
+                        reject('Invalid Google AdId');
+                    }
+                });
+            });
+
+            Session.setAdjustGoogleAdid(googleAdId);
+        } catch (error) {
+            console.error(error);
+        }
+    }
+
+    async getIdfa() {
+        try {
+            const idfa = await new Promise((resolve, reject) => {
+                Adjust.getIdfa((idfa) => {
+                    if (idfa && idfa !== '00000000-0000-0000-0000-000000000000') {
+                        resolve(idfa);
+                    } else {
+                        reject('Invalid IDFA');
+                    }
+                });
+            });
+            Session.setAdjustIDFA(idfa);
+        } catch (error) {
+            console.error(error);
+        }
+    }
+    getSDKVersion() {
+        Adjust.getSdkVersion((sdkVersion) => {
+            this.sdkVersion = sdkVersion;
+        });
+    }
 }
 
 export default new AdJust();

package/src/libraries/Networking.js

@@ -155,8 +155,9 @@ class Networking {
 
     setForcedUpdate = (data) => {
         const currentVersion = DeviceInfo.getVersion();
-        const updateNeeded = (data.data.update_state === 'force' && semver.lt(currentVersion, data.release));
+        const updateNeeded = (data.update_state === 'force' && semver.lt(currentVersion, data.release));
         console.log('update_state: ' + data.update_state + ', currentVersion: ' + currentVersion + ', initVersion: ' + data.release + ',  updateNeeded: ' + updateNeeded);
+        config.FORCED_UPDATE = updateNeeded;
         return updateNeeded;
     }
 

package/src/libraries/PayWallLogic.js

@@ -105,6 +105,7 @@ class PayWallLogic {
                     ...(offerToken && {subscriptionOffers: [{sku, offerToken}]}),
                 });
                 subscribed = true;
+                Session.setIsSubscribed(true);
                 if (hidePayWallCallback) {
                     hidePayWallCallback();
                 }

package/src/libraries/Session.js

@@ -4,6 +4,7 @@ import { Platform } from 'react-native';
 import * as Localization from 'expo-localization'
 import Storage from './Storage';
 import Networking from './Networking';
+import AdJust from './AdJust';
 import * as config from "../../config";
 
 class Session {
@@ -45,7 +46,9 @@ class Session {
                 "domains": "0"
             },
             adjust : {
-
+                attribution_id: await Storage.getData("adjustAttributionID") || '',
+                idfa: await Storage.getData("adjustIDFA") || '',
+                googleAdid: await Storage.getData("adjustGoogleAdid") || '',
             },
             dev : false,
             lang : Localization.getLocales()[0].languageCode || 'en',
@@ -140,10 +143,41 @@ class Session {
         return this.sessionData.user_id;
     }
 
+    setAdjustIDFA = (idfa) => {
+        this.sessionData.adjust.idfa = idfa;
+        Storage.storeData("adjustIDFA", idfa);
+    }
+
+    getAdjustIDFA = () => {
+        return this.sessionData.adjust.idfa || Storage.getData("adjustIDFA") || '';
+    }
+
+    setAdjustGoogleAdid = (googleAdid) => {
+        this.sessionData.adjust.googleAdid = googleAdid;
+        Storage.storeData("adjustGoogleAdid", googleAdid);
+    }
+
+    getAdjustGoogleAdid = () => {
+        return this.sessionData.adjust.googleAdid || Storage.getData("adjustGoogleAdid") || '';
+    }
+
+    setAdjustAttributionID = (attribution_id) => {
+        this.sessionData.adjust.attribution_id = attribution_id;
+        Storage.storeData("adjustAttributionID", attribution_id);
+    }
+
+    getAdjustAttributionID = () => {
+        return this.sessionData.adjust.attribution_id || Storage.getData("adjustAttributionID") || '';
+    }
+
+    setAdjustAttribution = (attribution) => {
+        console.log('setAdjustAttribution', attribution);
+    }
+
     sendFirstOpen = async () => {
         config.DEBUG_MODE && console.debug("sendFirstOpen");
         try {
-            let result = Networking.sendEvent(config.EVENT_TYPES.OTHER, 'first_open');
+            let result = await Networking.sendEvent(config.EVENT_TYPES.OTHER, 'first_open');
             config.DEBUG_MODE && console.debug("sendFirstOpen - result: ", result);
         } catch (error) {
             console.error(error);
@@ -154,7 +188,7 @@ class Session {
     checkSubscription = async () => {
         config.DEBUG_MODE && console.debug("checkSubscription");
         try {
-            let result = Networking.checkSubscription();
+            let result = await Networking.checkSubscription();
             config.DEBUG_MODE && console.debug("checkSubscription - result: ", result);
         } catch (error) {
             console.error(error);

package/types/index.d.ts

@@ -26,27 +26,38 @@ declare module 'apps-sdk' {
     }
 
     export class Session {
-        sessionData: SessionData;
+        sessionData: any;
         sessionID: string | null;
         isFirstOpen: boolean;
         isSubscribed: boolean;
+        subscriptionData: any;
         isDevUser: boolean;
+        forcedUpdate: boolean;
         init(): Promise<void>;
         storeSessionStructure(): Promise<void>;
         checkFirstOpen(): Promise<void>;
-        checkUserID(): Promise<void>;
-        setSubscriptionID(subscriptionID: string): void;
         generateSessionID(): string;
-        getSessionData(): SessionData;
+        checkUserID(): Promise<string | null>;
+        getSessionData(): any;
         getSessionID(): string | null;
         getIsFirstOpen(): boolean;
         getIsSubscribed(): boolean;
         getIsDevUser(): boolean;
         setIsSubscribed(isSubscribed: boolean): void;
+        setSubscriptionData(subscriptionData: any): void;
+        setSubscriptionID(subscriptionID: string): void;
         setIsDevUser(isDevUser: boolean): void;
         setUserID(userID: string): void;
         getUserID(): string | null;
-        setSubscriptionData(subscriptionData: any): void;
+        setAdjustIDFA(idfa: string): void;
+        getAdjustIDFA(): string;
+        setAdjustGoogleAdid(googleAdid: string): void;
+        getAdjustGoogleAdid(): string;
+        setAdjustAttributionID(attributionID: string): void;
+        getAdjustAttributionID(): string;
+        setAdjustAttribution(attribution: any): void;
+        sendFirstOpen(): Promise<void>;
+        checkSubscription(): Promise<void>;
         checkSubscription24h(): Promise<void>;
         isForcedUpdate(): boolean;
     }
@@ -112,8 +123,20 @@ declare module 'apps-sdk' {
     }
 
     export class AdJust {
-        initialize(): Promise<void>;
-        trackEvent(eventKeyword: string, eventValue: number): void;
+        sdkVersion: string | null;
+        attribution: object;
+        initialize(): void;
+        updateAttributionInfo(): void;
+        getAttributionData(): Promise<any>;
+        sendAttributionData(attribution: any): Promise<void>;
+        trackEventIfExist(eventKeyword: string, eventValue?: number): void;
+        storeSubscription(subscriptionData: any): void;
+        isSpecialEvent(eventKeyword: string): boolean;
+        getAttribution(): Promise<void>;
+        getAdid(): Promise<void>;
+        getIdfa(): Promise<void>;
+        getGoogleAdId(): Promise<void>;
+        getSDKVersion(): void;
     }
 
     export class TrackingTransparency {