apps-sdk 1.0.86 → 1.0.88

package/config.js

@@ -46,7 +46,15 @@ export const ADJUST = {
     },
 }
 
-export var TRACKING_ACTIVE = true;
+export var IMAGE_COMPRESSION =  {
+    COMPRESSION: 0.8,
+    WIDTH: 800,
+    ACTIVE: true,
+}
+
+export var TRACKING_ACTIVE = false;
+
+export var TRACKING_ANSWERED = false;
 
 export var FORCED_UPDATE = false;
 

package/package.json

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

package/src/libraries/Networking.js

@@ -11,6 +11,7 @@ class Networking {
     constructor() {
         this.ENCRYPT_KEY = null;
         this.DEFAULT_ENCRYPT_VALUE = false;
+        this.PENDING_EVENTS = [];
     }
 
     setEncryptKey(value) {
@@ -27,11 +28,13 @@ class Networking {
             let initData = await this.request(config.ENDPOINTS.CONFIG);
             if (initData) {
                 config.DEBUG_MODE && console.debug("initData", JSON.stringify(initData));
+                config.TRACKING_ANSWERED = await storage.getData('TRACKING_PERMISSION_ANSWERED');
                 this.setEndpoints(initData.data.domains);
                 this.setEvents(initData.data.attribution);
                 this.setPayWallData(initData);
                 this.checkSubscription();
                 this.setForcedUpdate(initData.data);
+                this.setImageCompression(initData.data.image);
             }
         } catch (error) {
             console.error(error);
@@ -135,6 +138,13 @@ class Networking {
         storage.storeData("ENDPOINTS", config.ENDPOINTS);
     }
 
+    setImageCompression(compression) {
+        config.IMAGE_COMPRESSION.COMPRESSION = compression.compress;
+        config.IMAGE_COMPRESSION.WIDTH = compression.width;
+        config.IMAGE_COMPRESSION.ACTIVE = Boolean(compression.active);
+        storage.storeData("IMAGE_COMPRESSION", config.IMAGE_COMPRESSION);
+    }
+
     getEndpoints() {
         return storage.getData("ENDPOINTS");
     }
@@ -201,6 +211,10 @@ class Networking {
     sendEvent = async (eventType, eventKeyword, eventData={}) => {
         if (config.TRACKING_ACTIVE === false) {
             console.log('Event not sent, tracking is denied: ', eventType, eventKeyword);
+            console.log('Tracking answered: ', config.TRACKING_ANSWERED);
+            if (!config.TRACKING_ANSWERED) {
+                this.addPendingEvent({eventType, eventKeyword, eventData});
+            }
             return;
         }
         config.DEBUG_MODE && console.debug("sendEvent", eventType, eventKeyword, eventData);
@@ -209,7 +223,6 @@ class Networking {
             let eventResponse = await this.request(config.ENDPOINTS.EVENTS_PUSH, {
                 event_name: eventKeyword,
                 event_type: eventType,
-                // action: eventKeyword,
                 appevent: eventKeyword,
                 payload: eventData,
                 ...Session.sessionData,
@@ -223,6 +236,24 @@ class Networking {
             console.log('Error al enviar evento a AdJust', error);
         }
     }
+
+    addPendingEvent(event) {
+        console.log('addPendingEvent', event);
+        this.PENDING_EVENTS.push(event);
+    }
+
+    clearPendingEvents() {
+        console.log('clearPendingEvents');
+        this.PENDING_EVENTS = [];
+    }
+
+    async sendPendingEvents() {
+        this.PENDING_EVENTS.forEach(async event => {
+            console.log('sendPendingEvents', event);
+            await this.sendEvent(event.eventType, event.eventKeyword, event.eventData);
+        });
+        this.clearPendingEvents();
+    }
 }
 
 export default new Networking();

package/src/libraries/Session.js

@@ -67,7 +67,9 @@ class Session {
         if (this.sessionData.isFirstOpen) {
             config.DEBUG_MODE && console.debug("checkFirstOpen - First Open");
             await this.sendFirstOpen();
-            await Storage.storeData("FirstOpenAlreadyExecuted", true);
+            if (config.TRACKING_ACTIVE) {
+                await Storage.storeData("FirstOpenAlreadyExecuted", true);
+            }
         } else {
             config.DEBUG_MODE && console.debug("checkFirstOpen - Not First Open");
         }

package/src/libraries/Storage.js

@@ -270,6 +270,7 @@ class Storage {
 
     setTrackingPermissionGranted(value) {
         config.TRACKING_ACTIVE = value;
+        this.storeData('TRACKING_PERMISSION', value ? 'granted' : 'denied');
     }
 }
 

package/src/libraries/TrackingTransparency.js

@@ -1,4 +1,4 @@
-import {getAdvertisingId, requestTrackingPermissionsAsync} from "expo-tracking-transparency";
+import {getAdvertisingId, requestTrackingPermissionsAsync, getTrackingPermissionsAsync} from "expo-tracking-transparency";
 import Storage from './Storage';
 import Networking from './Networking';
 import * as config from '../../config';
@@ -6,25 +6,38 @@ import * as config from '../../config';
 class TrackingTransparency {
     async requestTrackingTransparencyPermission() {
         console.log('requestTrackingTransparencyPermission');
-        let trackingResult = 'granted';
+        let trackingResult = 'denied';
         let trackingPermission = await Storage.getData('TRACKING_PERMISSION');
-        if (!trackingPermission || trackingPermission !== 'granted') {
+        console.log('current trackingPermission', trackingPermission);
+        if (!trackingPermission) {
             const { status } = await requestTrackingPermissionsAsync();
-            if (status === 'granted') {
-                Storage.storeData('TRACKING_PERMISSION', 'granted');
-                Networking.sendEvent('action', 'tracking_consent');
-                console.log('Tracking Transparency permission granted');
-            } else {
-                Storage.storeData('TRACKING_PERMISSION', 'denied');
-                Networking.sendEvent('action', 'tracking_denied');
-                trackingResult = 'denied';
-                console.log('Tracking Transparency permission denied');
+            await Storage.storeData('TRACKING_PERMISSION_ANSWERED', true);
+            await Networking.sendPendingEvents();
+            config.TRACKING_ANSWERED = true;
+            if (status !== 'undetermined') {
+                if (status === 'granted') {
+                    trackingResult = 'granted';
+                    await Storage.storeData('TRACKING_PERMISSION', 'granted');
+                    await Networking.sendEvent('action', 'tracking_consent');
+                    console.log('Tracking Transparency permission granted');
+                } else {
+                    await Storage.storeData('TRACKING_PERMISSION', 'denied');
+                    await Networking.sendEvent('action', 'tracking_denied');
+                    console.log('Tracking Transparency permission denied');
+                }
             }
         }
         config.TRACKING_ACTIVE = (trackingResult === 'granted');
         return trackingResult;
     }
 
+    async getTrackingTransparencyPermission() {
+        let tracking = await getTrackingPermissionsAsync();
+        if (tracking) {
+            return tracking.status;
+        }
+    }
+
     async getAdvertisingIdentifier() {
         return getAdvertisingId();
     }

package/types/index.d.ts

@@ -73,8 +73,12 @@ declare module 'apps-sdk' {
         getEndpoints(): any;
         setEvents(events: any): void;
         sendEvent(eventType: string, eventKeyword:string, eventData?: object): Promise<void>;
-        createSubscription();
+        createSubscription(): any;
         checkConnection(): Promise<boolean>;
+        setImageCompression(compression: any): void;
+        addPendingEvent(event: any): void;
+        sendPendingEvents(): Promise<void>;
+        clearPendingEvents(): void;
     }
 
     export class Storage {
@@ -147,6 +151,7 @@ declare module 'apps-sdk' {
     export class TrackingTransparency {
         requestTrackingTransparencyPermission(): Promise<string>;
         getAdvertisingIdentifier(): Promise<string>;
+        getTrackingTransparencyPermission(): Promise<string>;
     }
 
     export class AppsSDK {