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

package/src/acmo/core/services/localization_service.ts

@@ -1,7 +1,9 @@
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import axios, { type AxiosInstance } from 'axios';
+import TyradsSdkCore from '../tyrads-sdk-core';
+import { AcmoConfig } from '../../../acmo_config';
 
-const BASE_URL = 'https://api.tyrads.com/v3.0/';
+const BASE_URL = `https://api.tyrads.com/v${AcmoConfig.API_VERSION}/`;
 
 interface TranslationResponse {
   data: Array<{
@@ -31,23 +33,14 @@ class LocalizationService {
     return LocalizationService.instance;
   }
 
-  private static async getHeadersFromStorage(): Promise<Record<string, string>> {
-    try {
-      const data = await AsyncStorage.getItem('credentials');
-      return data ? JSON.parse(data) : {};
-    } catch (error) {
-      console.error('Failed to retrieve headers from AsyncStorage', error);
-      return {};
-    }
-  }
-
 
   public async init(locale: string): Promise<void> {
     if (this.axios) {
       return;
     }
 
-    const headers = await LocalizationService.getHeadersFromStorage();
+    const apiKey = TyradsSdkCore.apiKey;
+    const apiSecret = TyradsSdkCore.apiSecret;
 
     this.axios = axios.create({
       baseURL: BASE_URL,
@@ -55,8 +48,8 @@ class LocalizationService {
       headers: {
         'Content-Type': 'application/json',
         Accept: 'application/json',
-        "X-API-Key": headers["X-API-Key"],
-        "X-API-Secret": headers["X-API-Secret"],
+        "X-API-Key": apiKey,
+        "X-API-Secret": apiSecret,
       }
     });
 

package/src/acmo/core/types/activated-campaings.d.ts

@@ -0,0 +1,101 @@
+interface ActivatedCampaignsResponse {
+  data: ActivatedCampaignsData[];
+  message: string;
+}
+
+interface ActivatedCampaignsData {
+  groupName: string;
+  availableCurrencies: { [key: string]: AvailableCurrency };
+  campaigns: ActivatedCampaign[];
+}
+
+interface AvailableCurrency {
+  currencyId: number;
+  currencyIcon: string;
+  currencyName: string;
+}
+
+interface ActivatedCampaign {
+  campaignId: number;
+  campaignName: string;
+  campaignDescription: null | string;
+  campaignType: string;
+  campaignPremium: boolean;
+  validity: {
+    isRetryDownload: boolean;
+    isActivated: boolean;
+    isOldUser: boolean;
+    activeCurrencyId: number;
+    expiredOn: string | null;
+    expiredInSeconds: number | null;
+    isInstalled: boolean;
+    capReached: boolean;
+  };
+  availableCurrencies: { [key: string]: AvailableCurrency };
+  app: App;
+  campaignStatus: string;
+  group: null | string;
+  stage: null | string;
+  eventSummary: CampaignEventSummary;
+  limitedTimeEvents: LimitedTimeEvent[];
+  shorterMaxTimeEvents: any[];
+}
+
+interface App {
+  id: number;
+  title: string;
+  packageName: string;
+  rating: number;
+  shortDescription: string;
+  store: string;
+  storeCategory: string;
+  previewUrl: string;
+  thumbnail: string;
+}
+
+interface CampaignEventSummary {
+  playableEventCountAvailable: number;
+  playableEventCountCompleted: number;
+  playableEventCountTotal: number;
+  microchargeEventCountAvailable: number;
+  microchargeEventCountCompleted: number;
+  microchargeEventCountTotal: number;
+}
+
+interface LimitedTimeEvent {
+  appEventId: number;
+  conversionStatus: null | string;
+  identifier: string;
+  eventName: string;
+  eventDescription: null | string;
+  eventCategory: string;
+  payoutInfo: { [key: string]: PayoutInfo };
+  allowDuplicateEvents: boolean;
+  maxTime: number;
+  maxTimeMetric: null | string;
+  maxTimeRemainSeconds: null | number;
+  enforceMaxTimeCompletion: boolean;
+  isLimitedTimeEvent: boolean;
+  limitedTimeEventRemainingSeconds: number;
+  isTicketSubmitted: boolean;
+  ticketStatus: null | string;
+  lockEventRule: null | string;
+  hideEventRule: null | string;
+  shorterMaxTimeRule: null | string;
+  specialCompletionReason: null | string;
+  dailyCount: number;
+  dailyLimit: null | number;
+  count: number;
+  limit: null | number;
+  totalDailyUniqueCount: number;
+  totalDailyUniqueLimit: null | number;
+  dailyUniqueTodayExist: boolean;
+}
+
+interface PayoutInfo {
+  currencyId: number;
+  currencyName: string;
+  currencyIcon: string;
+  currencyConversionRate: number;
+  payoutAmountConverted: number;
+}

package/src/acmo/core/types/external_types.ts

@@ -18,5 +18,11 @@ export interface TyradsMediaSourceInfo {
 export interface TyradsUserInfo {
   email?: string,
   phoneNumber?: string,
-  userGroup?: string
+  userGroup?: string,
+  age?: number,
+  gender?: number,
+}
+
+export interface TyradsConfig {
+  skipInitialPages: boolean | false,
 }

package/src/acmo/core/types/types.d.ts

@@ -1,85 +1,110 @@
 
+interface AcmoOffersResponseModel {
+  code: number;
+  data: Campaign[];
+  message: string;
+  timestamp: number;
+  responseTime: number;
+}
+
 interface Campaign {
   campaignId: number;
   campaignName: string;
-  campaignDescription: null | string;
-  createdOn: string;
-  sortingScore: number;
-  status: string;
-  expiredOn: null | string;
+  campaignDescription: string;
+  campaignType: string;
+  campaignPremium: boolean;
+  campaignStatus: string;
+  validity: Validity;
+  availableCurrencies: { [key: string]: AvailableCurrency };
+  app: App;
+  targeting: Targeting;
+  payoutSummary: { [key: string]: PayoutSummary };
+  tracking: Tracking;
+  creative: Creative;
   hasPlaytimeEvents: boolean;
-  app: {
-    id: number;
-    title: string;
-    packageName: string;
-    rating: number;
-    shortDescription: string;
-    store: string;
-    storeCategory: string;
-    previewUrl: string;
-    thumbnail: string;
-    confidenceScore: number;
-    securityLabel: string;
-  };
-  currency: {
-    name: string;
-    symbol: string;
-    adUnitName: string;
-    adUnitCurrencyName: string;
-    adUnitCurrencyConversion: number;
-    adUnitCurrencyIcon: string;
-  };
-  campaignPayout: {
-    totalEvents: number;
-    totalPayout: number;
-    totalPlayablePayout: number;
-    totalMicrochargePayout: number;
-    totalPayoutConverted: number;
-    totalPlayablePayoutConverted: number;
-    totalMicrochargePayoutConverted: number;
-  };
-  tracking: {
-    impressionUrl: string;
-    clickUrl: string;
-    s2sClickUrl: string;
-  };
-  targeting: {
-    os: string;
-    targetingType: string;
-    reward: {
-      rewardDifficulty: string;
-      incentRewardDescription: string;
-    };
-  };
-  creative: {
-    creativeUrl: string;
-    creativePacks: {
-      creativePackId: null | number;
-      creativePackName: string;
-      languageName: string;
-      languageCode: string;
-      creatives: {
-        creativeId: null | number;
-        creativeName: string;
-        callToAction: string;
-        text: string;
-        byteSize: string;
-        fileUrl: string;
-        duration: string;
-        creativeType: {
-          name: string;
-          type: string;
-          width: string;
-          height: string;
-          creativeCategoryType: string;
-        };
-      }[];
-    }[];
-  };
-  isInstalled: boolean;
+}
+
+interface Validity {
   isRetryDownload: boolean;
-  capReached: boolean;
-  premium: boolean;
+  isActivated: boolean;
+  isOldUser: boolean;
+  expiredOn: string | null;
+  expiredInSeconds: number | null;
+  isInstalled: boolean;
+}
+
+interface AvailableCurrency {
+  currencyId: number;
+  currencyIcon: string;
+  currencyName: string;
+}
+
+interface PayoutSummary {
+  totalPayoutConverted: number;
+  totalPlayablePayoutConverted: number;
+  totalMicrochargePayoutConverted: number;
+}
+
+interface Creative {
+  creativeUrl: string;
+  creativePacks: CreativePack[];
+}
+
+interface CreativePack {
+  creativePackId: number;
+  creativePackName: string;
+  languageName: string;
+  languageCode: string;
+  creatives: (CreativeElement | null)[];
+}
+
+interface CreativeElement {
+  creativeId: number;
+  creativeName: string;
+  callToAction: string | null;
+  text: string;
+  byteSize: string;
+  fileUrl: string;
+  duration: string | null;
+  creativeType: CreativeType;
+}
+
+interface CreativeType {
+  name: string;
+  type: string;
+  width: string;
+  height: string;
+  creativeCategoryType: string;
+}
+
+interface Targeting {
+  os: string | null;
+  targetingType: string;
+  reward: Reward | null;
+}
+
+interface Tracking {
+  attributionTool: string | null;
+  clickUrl: string | null;
+  impressionUrl: string | null;
+  s2sClickUrl: string | null;
+}
+
+interface App {
+  id: number;
+  title: string;
+  packageName: string;
+  rating: number;
+  previewUrl: string;
+  shortDescription: string;
+  store: string;
+  storeCategory: string;
+  thumbnail: string;
+}
+
+interface Reward {
+  rewardDifficulty: string;
+  incentRewardDescription: string;
 }
 
 interface CurrencySales {
@@ -89,4 +114,15 @@ interface CurrencySales {
   dateStart: null | string,
   dateEnd: null | string,
   remainingTimeSeconds: null | number
+}
+
+interface ApiHeaders {
+  languageCode: string;
+  premiumColor: string;
+  xUserId: string;
+  xApiKey: string;
+  xApiSecret: string;
+  xSdkPlatform: string;
+  xSdkVersion: string;
+  userAgent: string;
 }

package/src/acmo/core/tyrads-sdk-core.tsx

@@ -0,0 +1,256 @@
+import { NativeEventEmitter, NativeModules, Platform } from "react-native";
+import { AcmoConfig } from "../../acmo_config";
+import type { TyradsConfig, TyradsMediaSourceInfo, TyradsUserInfo } from "./types/external_types";
+import NetworkCommon from "./network/network-common";
+import { FcmManager } from "../modules/push-notifications/fcm-manager";
+import { ApnsManager } from "../modules/push-notifications/apns-manager";
+import { saveData } from "./storage/storage";
+import { changeProviderLanguage, updateProviderLanguage } from "../modules/localization/localization_context";
+import Localization from './services/localization_service';
+import InAppNotificationController from "../modules/inapp-notifications/controller";
+
+const LINKING_ERROR =
+  `The package 'tyrads-sdk' doesn't seem to be linked. Make sure: \n\n` +
+  Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
+  '- You rebuilt the app after installing the package\n' +
+  '- You are not using Expo Go\n';
+
+const TyradsSdk = NativeModules.TyradsSdk
+  ? NativeModules.TyradsSdk
+  : new Proxy(
+    {},
+    {
+      get() {
+        throw new Error(LINKING_ERROR);
+      },
+    }
+  );
+
+export interface PushNotificationEvent {
+  type: 'received' | 'clicked' | 'dismissed';
+  id?: string;
+  data?: any;
+}
+
+export type PushNotificationCallback = (event: PushNotificationEvent) => void;
+
+export class TyradsSdkCore {
+  private static instance: TyradsSdkCore;
+  private tyradsEmitter: NativeEventEmitter;
+  private languageChangedSubscription: any = null;
+
+  private constructor() {
+    this.tyradsEmitter = new NativeEventEmitter(TyradsSdk);
+  }
+
+  public static getInstance(): TyradsSdkCore {
+    if (!TyradsSdkCore.instance) {
+      TyradsSdkCore.instance = new TyradsSdkCore();
+    }
+    return TyradsSdkCore.instance;
+  }
+  public userId: string = "";
+  public apiKey: string = "";
+  public apiSecret: string = "";
+  public encKey?: string = "";
+  public engagementId?: string = "";
+  public placementId?: string = "";
+
+  public premiumColor?: string;
+  public mainColor?: string;
+  public currentLanguage: string = "en";
+
+  public async init(
+    apiKey: string,
+    apiSecret: string,
+    encKey?: string,
+    engagementId?: string,
+    placementId?: string,
+    mediaSourceInfo?: TyradsMediaSourceInfo,
+    userInfo?: TyradsUserInfo,
+    config?: TyradsConfig,
+  ) {
+    this.setSDKVersion();
+    if (mediaSourceInfo) {
+      this.setMediaSourceInfo(mediaSourceInfo);
+    }
+    if (userInfo) {
+      this.setUserInfo(userInfo);
+    }
+    var data;
+    if (Platform.OS === 'ios') {
+      data = await TyradsSdk.init(apiKey, apiSecret, encKey, engagementId, placementId);
+    } else {
+      data = await TyradsSdk.init(apiKey, apiSecret, encKey, engagementId, placementId, config);
+    }
+
+    this.apiKey = apiKey;
+    this.apiSecret = apiSecret;
+    this.encKey = encKey;
+    this.engagementId = engagementId;
+    this.placementId = placementId;
+
+    try {
+      const parsed = typeof data === "string" ? JSON.parse(data) : data;
+      if (parsed?.languageCode) {
+        this.currentLanguage = parsed.languageCode;
+      }
+    } catch { }
+
+    await Localization.getInstance().init(this.currentLanguage);
+    await NetworkCommon.getInstance().init();
+
+    if (Platform.OS === 'android') {
+      await FcmManager.getInstance().init().catch(console.error);
+    }
+    if (Platform.OS === 'ios') {
+      await ApnsManager.getInstance().init().catch(console.error);
+    }
+    TyradsSdk.startObserving();
+    this.languageChangedSubscription?.remove();
+    this.languageChangedSubscription = this.tyradsEmitter.addListener(
+      'LanguageChanged',
+      async (lang: string) => {
+        console.log('LanguageChanged event from Android SDK:', lang);
+        await changeProviderLanguage(lang);
+      }
+    );
+    await updateProviderLanguage(this.currentLanguage);
+
+    return data;
+  }
+
+  public async loginUser(userId: string) {
+    try {
+      const data = await TyradsSdk.loginUser(userId);
+      if (typeof data === "object") {
+        await saveData('xUserId', data.xUserId);
+        this.userId = data.xUserId;
+        this.currentLanguage = data.currentLanguage;
+        this.premiumColor = data.premiumColor;
+        this.mainColor = data.mainColor;
+      } else if (typeof data === "string") {
+        await saveData('xUserId', JSON.parse(data).xUserId);
+        this.userId = JSON.parse(data).xUserId;
+        this.currentLanguage = JSON.parse(data).languageCode;
+        this.premiumColor = JSON.parse(data).premiumColor;
+        this.mainColor = JSON.parse(data).mainColor;
+      }
+      await NetworkCommon.getInstance().init();
+      if (Platform.OS === 'android') {
+        FcmManager.getInstance().setLoggedIn(true);
+      } else {
+        ApnsManager.getInstance().setLoggedIn(true);
+      }
+
+      InAppNotificationController.getInstance().init().catch(err => console.error("In-app notification init error:", err));
+
+      return data;
+    } catch (err) {
+      console.error('Error logging in user:', err);
+      return null;
+    }
+  }
+
+  public async showOffers({
+    launchMode = 3,
+    route,
+    campaignID,
+  }: { launchMode?: number; route?: string; campaignID?: number | null } = {}) {
+    if (Platform.OS === 'ios') {
+      if (campaignID == null) {
+        return await TyradsSdk.showOffers(launchMode, route);
+      }
+      return await TyradsSdk.showOfferDetails(launchMode, route, campaignID);
+    } else {
+      if (campaignID == null) {
+        return await TyradsSdk.showOffers(route);
+      }
+      return await TyradsSdk.showOfferDetails(route, campaignID);
+    }
+  }
+
+  public async changeLanguage(lang: string) {
+    return await TyradsSdk.changeLanguage(lang);
+  }
+
+  public async preloadOffers(route?: string) {
+    if (Platform.OS !== 'ios') return;
+    try {
+      await TyradsSdk.preloadOffers(route || null);
+    } catch (err) {
+      console.error("Error preloading offers:", err);
+    }
+  }
+
+  public setSDKVersion() {
+    const version = AcmoConfig.SDK_VERSION;
+    TyradsSdk.setSDKVersion(version);
+  }
+
+  public setMediaSourceInfo(mediaSourceInfo: TyradsMediaSourceInfo) {
+    TyradsSdk.setMediaSourceInfo(mediaSourceInfo);
+  }
+
+  public setUserInfo(userInfo: TyradsUserInfo) {
+    TyradsSdk.setUserInfo(userInfo);
+  }
+
+
+  public async isPrivacyAccepted() {
+    try {
+      return await TyradsSdk.isPrivacyAccepted();
+    } catch (err) {
+      console.error("Error checking privacy acceptance:", err);
+      return false;
+    }
+  }
+
+  public async checkOnboardingProcess() {
+    try {
+      const result = await TyradsSdk.checkOnboardingProcess();
+      return result === true;
+    } catch (err) {
+      console.error("Error showing privacy flow:", err);
+      return false;
+    }
+  }
+
+  public async requestPushPermission(): Promise<boolean> {
+    try {
+      const granted = await TyradsSdk.pushRequestPermission();
+      return granted === true;
+    } catch (err) {
+      console.error("Error requesting push permission:", err);
+      return false;
+    }
+  }
+
+  public async getApnsToken(): Promise<string | null> {
+    try {
+      const token = await TyradsSdk.pushGetApnsToken();
+      return token || null;
+    } catch (err) {
+      console.error("Error getting APNs token:", err);
+      return null;
+    }
+  }
+
+  public addPushNotificationListener(callback: PushNotificationCallback) {
+    return this.tyradsEmitter.addListener('PushNotificationEvent', callback);
+  }
+
+  public startObserving() {
+    TyradsSdk.startObserving();
+  }
+
+  public stopObserving() {
+    TyradsSdk.stopObserving();
+  }
+
+  public dismissInAppNotification() {
+    TyradsSdk.dismissInAppNotification();
+  }
+}
+
+export default TyradsSdkCore.getInstance();

package/src/acmo/modules/inapp-notifications/components/gradient_card.tsx

@@ -0,0 +1,87 @@
+import React from 'react';
+import { View, Pressable, StyleSheet, Image } from 'react-native';
+import LinearGradient from 'react-native-linear-gradient';
+import { TyradsSdkCore } from '../../../core/tyrads-sdk-core';
+
+interface CardGradientProps {
+  children?: React.ReactNode;
+  onClose: () => void;
+  gradientColors?: (string | number)[];
+  gradientStart?: { x: number; y: number };
+  gradientEnd?: { x: number; y: number };
+}
+
+export const CardGradient: React.FC<CardGradientProps> = ({
+  children,
+  onClose,
+  gradientColors = (['#ffffff', '#02B5BE'] as (string | number)[]),
+  gradientStart = { x: 0.5, y: 0.25 },
+  gradientEnd = { x: 0.5, y: 1.2 },
+}) => {
+  const mainColor = TyradsSdkCore.getInstance().mainColor;
+  const colors = mainColor ? (['#ffffff', mainColor] as string[]) : gradientColors;
+  return (
+    <View style={styles.wrapper}>
+      <View style={styles.topLeftIcon}>
+        <Image
+          source={require('../../../../assets/images/coin.png')}
+          style={{
+            width: 110,
+            height: 110,
+          }}
+        />
+      </View>
+      <LinearGradient
+        colors={colors}
+        start={gradientStart}
+        end={gradientEnd}
+        style={styles.gradientCard}
+      >
+        <Pressable style={styles.closeButton} onPress={onClose}>
+          <Image
+            source={require('../../../../assets/images/circle-x.png')}
+            style={styles.closeIcon}
+          />
+        </Pressable>
+        {children && <View style={styles.content}>{children}</View>}
+      </LinearGradient>
+    </View>
+  );
+};
+
+const styles = StyleSheet.create({
+  wrapper: {
+    position: 'relative',
+    width: '90%',
+    maxWidth: '90%',
+  },
+  gradientCard: {
+    borderRadius: 16,
+    width: '100%',
+    shadowColor: '#000',
+    shadowOffset: { width: 0, height: 4 },
+    shadowOpacity: 0.25,
+    shadowRadius: 8,
+    elevation: 10,
+  },
+  topLeftIcon: {
+    position: 'absolute',
+    left: 10,
+    top: -35,
+    zIndex: 10,
+  },
+  closeButton: {
+    position: 'absolute',
+    top: 16,
+    right: 16,
+    zIndex: 10,
+    padding: 4,
+  },
+  closeIcon: {
+    width: 24,
+    height: 24,
+  },
+  content: {
+    margin: 16,
+  },
+});