@tyrads.com/tyrads-sdk 3.3.4 → 4.0.0-beta.0

package/src/acmo/modules/premium-widgets/repository.ts

@@ -0,0 +1,107 @@
+import { http } from '../../core/network/http-client';
+import { acmoLaunchURLForce } from '../../core/helpers/launcher';
+import AcmoAPIEndpoints from '../../core/constants/api-endpoints';
+import TyradsSdkCore from '../../core/tyrads-sdk-core';
+import { Logger } from '../../core/helpers/logger';
+
+class PremiumWidgetsRepository {
+  private static instance: PremiumWidgetsRepository;
+  private constructor() { }
+  static getInstance() {
+    if (!PremiumWidgetsRepository.instance) {
+      PremiumWidgetsRepository.instance = new PremiumWidgetsRepository();
+    }
+    return PremiumWidgetsRepository.instance;
+  }
+
+  public async fetchTargetedCampaigns(): Promise<Campaign[]> {
+    const language = TyradsSdkCore.currentLanguage
+
+    const { status, data } = await http.get(`${AcmoAPIEndpoints.TARGETED_CAMPAIGNS}?lang=${language}`);
+
+    if (status !== 200) {
+      throw new Error('Failed to fetch targeted campaigns');
+    }
+
+    const campaigns = data.data as Campaign[];
+
+    const hotOffers = campaigns
+      .sort((a, b) => {
+        if (a.campaignPremium && !b.campaignPremium) return -1;
+        if (!a.campaignPremium && b.campaignPremium) return 1;
+        return 0;
+      })
+      .slice(0, 5);
+
+    return hotOffers as Campaign[];
+  }
+
+  public async fetchCurrencySales(): Promise<CurrencySales> {
+    const language = TyradsSdkCore.currentLanguage
+
+    const { status, data } = await http.get(`${AcmoAPIEndpoints.ENGAGEMENT}?lang=${language}`);
+
+    if (status !== 200) {
+      throw new Error('Failed to fetch currency sales');
+    }
+
+    return data.data.CurrencySales as CurrencySales;
+  }
+
+  public async fetchSummary(): Promise<number> {
+    const language = TyradsSdkCore.currentLanguage
+
+    const { status, data } = await http.get(`${AcmoAPIEndpoints.SUMMARY}?lang=${language}`);
+
+    if (status !== 200) {
+      throw new Error('Failed to fetch summary');
+    }
+
+    return data.data.activeCampaignCount as number;
+  }
+
+  public async track(activity: string): Promise<void> {
+
+    const { status } = await http.post(AcmoAPIEndpoints.USER_ACTIVITIES, { activity });
+
+    if (status !== 200) {
+      throw new Error('Failed to track activity');
+    }
+  }
+
+  public async openOffer(campaign: Campaign): Promise<void> {
+    const campaignId = campaign.campaignId;
+    const clickUrl = campaign.tracking.clickUrl;
+    const isRetryDownload = campaign.validity.isRetryDownload;
+    const isInstalled = campaign.validity.isInstalled;
+    const previewUrl = campaign.app.previewUrl;
+    const s2sClickUrl = campaign.tracking.s2sClickUrl;
+
+    try {
+      let url: string = clickUrl || "";
+      if (isInstalled) {
+        url = previewUrl;
+      } else {
+        if (isRetryDownload) {
+          await this.track("CampaignActivatedRetry");
+        } else {
+          await this.track("CampaignActivated");
+        }
+        await http.post(AcmoAPIEndpoints.ACTIVATE_CAMPAIGN(campaignId), {}, {});
+      }
+      if (s2sClickUrl != null) {
+        const res = await http.get(s2sClickUrl);
+        if (res.status == 200) {
+          // url = res.data.url;
+          return;
+        }
+      }
+      await acmoLaunchURLForce(url);
+    } catch (error) {
+      Logger.error(error)
+    }
+  }
+}
+
+export default PremiumWidgetsRepository.getInstance();
+

package/src/acmo/modules/push-notifications/apns-manager.ts

@@ -0,0 +1,254 @@
+import { Platform } from 'react-native';
+import TyradsSdkCoreMethods from '../../core/tyrads-sdk-core';
+
+export interface PushNotificationEvent {
+  type: 'received' | 'clicked' | 'dismissed';
+  id?: string;
+  data?: any;
+}
+
+export type PushEventCallback = (event: PushNotificationEvent) => void;
+
+class ApnsManager {
+  private static instance: ApnsManager;
+  private tokenFetched: boolean = false;
+  private pushEventSubscriptions: any[] = [];
+
+  private initialized = false;
+  private isLoggedIn = false;
+  private pendingEvent: { identifier: string; userInfo: any } | null = null;
+
+  private constructor() { }
+
+  static getInstance(): ApnsManager {
+    if (!ApnsManager.instance) {
+      ApnsManager.instance = new ApnsManager();
+    }
+    return ApnsManager.instance;
+  }
+
+  setLoggedIn(status: boolean): void {
+    this.isLoggedIn = status;
+    if (this.isLoggedIn && this.pendingEvent) {
+      const { identifier, userInfo } = this.pendingEvent;
+      this.pendingEvent = null;
+      this._onNotificationClicked(identifier, userInfo);
+    }
+  }
+
+  async init(): Promise<void> {
+    if (Platform.OS !== 'ios') {
+      console.log('APNs is only available on iOS');
+      return;
+    }
+
+    if (this.initialized) {
+      return;
+    }
+
+    try {
+      this._requestPushPermission();
+      this._fetchTokenSafely();
+      this._setupPushEventListeners();
+      this.initialized = true;
+    } catch (error) {
+      console.error('Failed to initialize APNs manager:', error);
+    }
+  }
+
+  private async _fetchTokenSafely(): Promise<void> {
+    if (this.tokenFetched) {
+      return;
+    }
+
+    try {
+      const token = await this._fetchTokenWithRetry(3);
+      if (token) {
+        console.log('APNs token:', token);
+        this.tokenFetched = true;
+        this.emit('tokenFetched', token);
+      } else {
+        console.log('APNs token not available after retries');
+      }
+    } catch (error) {
+      console.log('APNs token fetch failed:', error);
+    }
+  }
+
+  private async _fetchTokenWithRetry(maxRetries: number): Promise<string | null> {
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        console.log(`Fetching APNs token (attempt ${attempt}/${maxRetries})...`);
+
+        const token = await TyradsSdkCoreMethods.getApnsToken();
+
+        if (token && typeof token === 'string' && token.length > 0) {
+          return token;
+        }
+
+        if (attempt < maxRetries) {
+          await new Promise(resolve => setTimeout(resolve, 3000));
+        }
+      } catch (error) {
+        console.log(`Attempt ${attempt} failed:`, error);
+        if (attempt < maxRetries) {
+          await new Promise(resolve => setTimeout(resolve, 3000));
+        }
+      }
+    }
+    return null;
+  }
+
+
+  private async _requestPushPermission(): Promise<void> {
+    try {
+      const granted = await TyradsSdkCoreMethods.requestPushPermission();
+      console.log('Push permission granted:', granted);
+    } catch (error) {
+      console.error('Error requesting push permission:', error);
+    }
+  }
+
+  private _setupPushEventListeners(): void {
+    const subscription = TyradsSdkCoreMethods.addPushNotificationListener(
+      (event: PushNotificationEvent) => {
+        console.log('Push event:', event);
+        const eventParsed = typeof event === 'string' ? JSON.parse(event) : event;
+        this._handlePushEvent(eventParsed);
+      }
+    );
+
+    this.pushEventSubscriptions.push(subscription);
+  }
+
+  private _handlePushEvent(event: PushNotificationEvent): void {
+    switch (event.type) {
+      case 'received':
+        this._onNotificationReceived(event.data);
+        break;
+      case 'clicked':
+        this._onNotificationClicked(event.id!, event.data);
+        break;
+      case 'dismissed':
+        this._onNotificationDismissed(event.id!);
+        break;
+    }
+  }
+
+  private _onNotificationReceived(userInfo: any): void {
+    console.log('Notification received:', userInfo);
+    this.emit('notificationReceived', userInfo);
+  }
+
+  private async _onNotificationClicked(identifier: string, userInfo: any): Promise<void> {
+    console.log('Notification clicked:', identifier, userInfo);
+    const deepLink = userInfo['deepLink']
+
+    if (!this.isLoggedIn && deepLink) {
+      console.log('Notification clicked (iOS) but user not logged in. Queueing navigation.');
+      this.pendingEvent = { identifier, userInfo };
+      this.emit('notificationClicked', { identifier, userInfo });
+      return;
+    }
+
+    this.emit('notificationClicked', { identifier, userInfo });
+    if (deepLink != null && deepLink != '') {
+      setTimeout(() => {
+        TyradsSdkCoreMethods.showOffers({
+          route: deepLink,
+          launchMode: 2,
+        }).catch(err => {
+          console.error('Failed to show offers from notification click (iOS):', err);
+        });
+      }, 500);
+    }
+  }
+
+  private _onNotificationDismissed(identifier: string): void {
+    console.log('Notification dismissed:', identifier);
+    this.emit('notificationDismissed', identifier);
+  }
+
+  private listeners: Map<string, Function[]> = new Map();
+
+  on(event: string, callback: Function): void {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, []);
+    }
+    this.listeners.get(event)!.push(callback);
+  }
+
+  off(event: string, callback: Function): void {
+    const callbacks = this.listeners.get(event);
+    if (callbacks) {
+      const index = callbacks.indexOf(callback);
+      if (index > -1) {
+        callbacks.splice(index, 1);
+      }
+    }
+  }
+
+  private emit(event: string, data?: any): void {
+    const callbacks = this.listeners.get(event);
+    if (callbacks) {
+      callbacks.forEach(callback => {
+        try {
+          callback(data);
+        } catch (error) {
+          console.error(`Error in ${event} listener:`, error);
+        }
+      });
+    }
+  }
+
+  async fetchToken(): Promise<string | null> {
+    try {
+      const token = await TyradsSdkCoreMethods.getApnsToken();
+      if (token) {
+        this.tokenFetched = true;
+        console.log('Manually fetched APNs token:', token);
+      }
+      return token;
+    } catch (error) {
+      console.error('Error fetching token:', error);
+      return null;
+    }
+  }
+
+  async requestPermission(): Promise<boolean> {
+    try {
+      return await TyradsSdkCoreMethods.requestPushPermission();
+    } catch (error) {
+      console.error('Error requesting permission:', error);
+      return false;
+    }
+  }
+
+  addPushEventHandler(callback: PushEventCallback): any {
+    return TyradsSdkCoreMethods.addPushNotificationListener(callback);
+  }
+
+  dispose(): void {
+    this.pushEventSubscriptions.forEach(subscription => {
+      subscription.remove();
+    });
+    this.pushEventSubscriptions = [];
+    this.listeners.clear();
+    this.initialized = false;
+  }
+
+  isTokenFetched(): boolean {
+    return this.tokenFetched;
+  }
+
+  async getCurrentToken(): Promise<string | null> {
+    if (!this.tokenFetched) {
+      return await this.fetchToken();
+    }
+    return await TyradsSdkCoreMethods.getApnsToken();
+  }
+}
+
+export default ApnsManager.getInstance();
+
+export { ApnsManager };

package/src/acmo/modules/push-notifications/fcm-manager.ts

@@ -0,0 +1,162 @@
+import { Platform } from 'react-native';
+import TyradsSdkCoreMethods from '../../core/tyrads-sdk-core';
+
+export interface PushNotificationEvent {
+  type: 'received' | 'clicked' | 'dismissed';
+  id?: string;
+  data?: any;
+}
+
+export type PushEventCallback = (event: PushNotificationEvent) => void;
+
+class FcmManager {
+  private static instance: FcmManager;
+  private pushEventSubscriptions: any[] = [];
+
+  private initialized = false;
+  private isLoggedIn = false;
+  private pendingEvent: { identifier: string; userInfo: any } | null = null;
+
+  private constructor() { }
+
+  static getInstance(): FcmManager {
+    if (!FcmManager.instance) {
+      FcmManager.instance = new FcmManager();
+    }
+    return FcmManager.instance;
+  }
+
+  setLoggedIn(status: boolean): void {
+    this.isLoggedIn = status;
+    if (this.isLoggedIn && this.pendingEvent) {
+      const { identifier, userInfo } = this.pendingEvent;
+      this.pendingEvent = null;
+      this._onNotificationClicked(identifier, userInfo);
+    }
+  }
+
+  async init(): Promise<void> {
+    if (Platform.OS !== 'android') {
+      console.log('FCM is only available on Android');
+      return;
+    }
+
+    if (this.initialized) {
+      return;
+    }
+
+    try {
+      this._setupPushEventListeners();
+      this.initialized = true;
+    } catch (error) {
+      console.error('Failed to initialize FCM manager:', error);
+    }
+  }
+
+  private _setupPushEventListeners(): void {
+    const subscription = TyradsSdkCoreMethods.addPushNotificationListener(
+      (event: PushNotificationEvent) => {
+        console.log('Push event:', event);
+        const eventParsed = typeof event === 'string' ? JSON.parse(event) : event;
+        this._handlePushEvent(eventParsed);
+      }
+    );
+
+    this.pushEventSubscriptions.push(subscription);
+  }
+
+  private _handlePushEvent(event: PushNotificationEvent): void {
+    switch (event.type) {
+      case 'received':
+        this._onNotificationReceived(event.data);
+        break;
+      case 'clicked':
+        this._onNotificationClicked(event.id!, event.data);
+        break;
+      case 'dismissed':
+        this._onNotificationDismissed(event.id!);
+        break;
+    }
+  }
+
+  private _onNotificationReceived(userInfo: any): void {
+    console.log('Notification received:', userInfo);
+    this.emit('notificationReceived', userInfo);
+  }
+
+  private async _onNotificationClicked(identifier: string, userInfo: any): Promise<void> {
+    console.log('Notification clicked:', identifier, userInfo);
+    const deepLink = userInfo['deepLink']
+
+    if (!this.isLoggedIn && deepLink) {
+      this.pendingEvent = { identifier, userInfo };
+      this.emit('notificationClicked', { identifier, userInfo });
+      return;
+    }
+    this.emit('notificationClicked', { identifier, userInfo });
+    if (deepLink != null && deepLink != '') {
+      setTimeout(() => {
+        TyradsSdkCoreMethods.showOffers({
+          route: deepLink,
+          launchMode: 2,
+        }).catch(err => {
+          console.error('Failed to show offers from notification click:', err);
+        });
+      }, 500);
+    }
+  }
+
+  private _onNotificationDismissed(identifier: string): void {
+    console.log('Notification dismissed:', identifier);
+    this.emit('notificationDismissed', identifier);
+  }
+
+  private listeners: Map<string, Function[]> = new Map();
+
+  on(event: string, callback: Function): void {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, []);
+    }
+    this.listeners.get(event)!.push(callback);
+  }
+
+  off(event: string, callback: Function): void {
+    const callbacks = this.listeners.get(event);
+    if (callbacks) {
+      const index = callbacks.indexOf(callback);
+      if (index > -1) {
+        callbacks.splice(index, 1);
+      }
+    }
+  }
+
+  private emit(event: string, data?: any): void {
+    const callbacks = this.listeners.get(event);
+    if (callbacks) {
+      callbacks.forEach(callback => {
+        try {
+          callback(data);
+        } catch (error) {
+          console.error(`Error in ${event} listener:`, error);
+        }
+      });
+    }
+  }
+
+  addPushEventHandler(callback: PushEventCallback): any {
+    return TyradsSdkCoreMethods.addPushNotificationListener(callback);
+  }
+
+  dispose(): void {
+    this.pushEventSubscriptions.forEach(subscription => {
+      subscription.remove();
+    });
+    this.pushEventSubscriptions = [];
+    this.listeners.clear();
+    this.initialized = false;
+  }
+}
+
+export default FcmManager.getInstance();
+
+export { FcmManager };

package/src/acmo_config.ts

@@ -1,9 +1,10 @@
 export class AcmoConfig {
-  public static API_VERSION = "3.0";
-  public static MAJOR_VERSION = "3";
-  public static MINOR_VERSION = "3";
-  public static PATCH_VERSION = "2";
-  public static BUILD_VERSION = "2";
+  public static API_VERSION = "4.0";
+  public static BASE_URL = `https://api.tyrads.com/v${this.API_VERSION}/`;
+  public static MAJOR_VERSION = "4";
+  public static MINOR_VERSION = "0";
+  public static PATCH_VERSION = "0";
+  public static BUILD_VERSION = "1";
   public static SDK_PLATFORM = "React Native";
   public static SDK_VERSION = `${this.MAJOR_VERSION}.${this.MINOR_VERSION}.${this.PATCH_VERSION}-${this.BUILD_VERSION}`;
 }