@tyrads.com/tyrads-sdk 3.0.0-beta.0 → 3.2.0-beta.0

package/src/acmo/modules/dashboard/repository.ts

@@ -1,5 +1,6 @@
-import axios, { type AxiosResponse } from 'axios';
+import axios from 'axios';
 import { getData } from '../../core/storage/storage';
+import { acmoLaunchURLForce } from '../../core/helpers/launcher';
 
 interface ApiHeaders {
   languageCode: string;
@@ -12,28 +13,11 @@ interface ApiHeaders {
   userAgent: string;
 }
 
-const transformCampaigns = (campaigns: Campaign[]): TransformedCampaign[] => {
-  return campaigns.map((campaign) => ({
-    campaignId: campaign.campaignId || 0,
-    appId: campaign.app?.id || 0,
-    title: campaign.app?.title || 'Unknown Title',
-    creativePackName:
-      campaign.creative?.creativePacks?.[0]?.creativePackName || '',
-    fileUrl:
-      campaign.creative?.creativePacks?.[0]?.creatives?.[0]?.fileUrl || '',
-    points: campaign.campaignPayout?.totalPayoutConverted || 0,
-    rewards: campaign.campaignPayout?.totalEvents || 0,
-    currency: campaign.currency || {},
-    thumbnail: campaign.app?.thumbnail || '',
-    premium: campaign.premium || false,
-    sortingScore: campaign.sortingScore || 0,
-  }));
-};
-
-export const fetchCampaignsData = async (
-  // setLanguage: (language: string) => void,
+export const fetchPremiumOfferDetails = async (
   setPremiumColor: (color: string) => void,
-  setCampaigns: (campaigns: TransformedCampaign[]) => void,
+  setCampaigns: (campaigns: Campaign[]) => void,
+  setCurrencySale: (currencySale: CurrencySales) => void,
+  setActiveCount: (activeCount: number) => void,
   setError: (error: string) => void,
   setIsLoading: (loading: boolean) => void
 ): Promise<void> => {
@@ -41,11 +25,9 @@ export const fetchCampaignsData = async (
 
   try {
     const data: any = await getData('apiHeaders');
-    if (!data) {
-      throw new Error('apiHeaders data not found.');
-    }
+    if (!data) throw new Error('apiHeaders data not found.');
+
     const parsedHeaderData: ApiHeaders = JSON.parse(data);
-    // setLanguage(parsedHeaderData.languageCode);
     setPremiumColor(parsedHeaderData.premiumColor);
 
     const headers = {
@@ -59,37 +41,130 @@ export const fetchCampaignsData = async (
       'User-Agent': parsedHeaderData.userAgent,
     };
 
-    const response: AxiosResponse<{ data: Campaign[] }> = await axios.get(
-      `https://api.tyrads.com/v3.0/campaigns?lang=${parsedHeaderData.languageCode}`,
-      {
-        headers: headers,
-      }
-    );
+    const langParam = `?lang=${parsedHeaderData.languageCode}`;
 
-    const transformedCampaigns = transformCampaigns(response.data.data);
+    const [campaignsRes, currencyRes, summaryRes] = await Promise.all([
+      axios.get<{ data: Campaign[] }>(`https://api.tyrads.com/v3.0/campaigns${langParam}`, { headers }),
+      axios.get<{ data: { CurrencySales: CurrencySales } }>(`https://api.tyrads.com/v3.0/engagement${langParam}`, { headers }),
+      axios.get<{ data: { activeCampaignCount: number } }>(`https://api.tyrads.com/v3.0/activated-campaigns/summary${langParam}`, { headers })
+    ]);
 
-    const hotOffers = transformedCampaigns
-    .sort((a, b) => {
-      if (a.premium && !b.premium) return -1;
-      if (!a.premium && b.premium) return 1;
-      return b.sortingScore - a.sortingScore;
-    })
-    .filter((item) => item.points > 0)
-    .slice(0, 5);
+    const hotOffers = campaignsRes.data.data
+      .sort((a, b) => {
+        if (a.premium && !b.premium) return -1;
+        if (!a.premium && b.premium) return 1;
+        return b.sortingScore - a.sortingScore;
+      })
+      .filter(item => item.campaignPayout.totalPlayablePayoutConverted > 0)
+      .slice(0, 5);
+    // const currency: CurrencySales = {
+    //   "name": "Ramadhan Karem",
+    //   "multiplier": 1.5,
+    //   "bannerUrl": "",
+    //   "dateStart": "2025-03-10T00:00:00.000Z",
+    //   "dateEnd": "2025-03-10T23:59:59.000Z",
+    //   remainingTimeSeconds: 3090
+    // };
 
     setCampaigns(hotOffers);
+
+    setCurrencySale(currencyRes.data.data.CurrencySales);
+
+    setActiveCount(summaryRes.data.data.activeCampaignCount);
   } catch (error: any) {
     if (axios.isAxiosError(error) && error.response) {
       console.log('Response Error:', error.response.data);
-      console.log('Status Code:', error.response.status);
-      console.log('Response Headers:', error.response.headers);
     } else if (axios.isAxiosError(error) && error.request) {
       console.log('No Response from API:', error.request);
     } else {
-      console.log('Error setting up request:', error.message);
+      console.log('Request Setup Error:', error.message);
     }
-    setError('Something went wrong, please try again');
+    setError('Something went wrong, please try again.');
   } finally {
     setIsLoading(false);
   }
-};
+};
+
+const track = async (activity: string) => {
+  const data: any = await getData('apiHeaders');
+  if (!data) throw new Error('apiHeaders data not found.');
+
+  const parsedHeaderData: ApiHeaders = JSON.parse(data);
+
+  const headers = {
+    'Content-Type': 'application/json',
+    Accept: 'application/json',
+    'X-User-ID': parsedHeaderData.xUserId,
+    'X-API-Key': parsedHeaderData.xApiKey,
+    'X-API-Secret': parsedHeaderData.xApiSecret,
+    'X-SDK-Platform': parsedHeaderData.xSdkPlatform,
+    'X-SDK-Version': parsedHeaderData.xSdkVersion,
+    'User-Agent': parsedHeaderData.userAgent,
+  };
+  try {
+    const fd = {
+      "activity": activity
+    };
+    await axios.post('https://api.tyrads.com/v3.0/user-activities', fd, { headers });
+  } catch (error) {
+    if (axios.isAxiosError(error) && error.response) {
+      console.log('Response Error:', error.response.data);
+    } else if (axios.isAxiosError(error) && error.request) {
+      console.log('No Response from API:', error.request);
+    } else {
+      console.log('Request Setup Error:', error);
+    }
+  }
+}
+
+export const openOffer = async (campaign: Campaign) => {
+  const campaignId = campaign.campaignId;
+  const clickUrl = campaign.tracking.clickUrl;
+  const isRetryDownload = campaign.isRetryDownload;
+  const isInstalled = campaign.isInstalled;
+  const previewUrl = campaign.app.previewUrl;
+  const s2sClickUrl = campaign.tracking.s2sClickUrl;
+
+  const data: any = await getData('apiHeaders');
+  if (!data) throw new Error('apiHeaders data not found.');
+
+  const parsedHeaderData: ApiHeaders = JSON.parse(data);
+
+  const headers = {
+    'Content-Type': 'application/json',
+    Accept: 'application/json',
+    'X-User-ID': parsedHeaderData.xUserId,
+    'X-API-Key': parsedHeaderData.xApiKey,
+    'X-API-Secret': parsedHeaderData.xApiSecret,
+    'X-SDK-Platform': parsedHeaderData.xSdkPlatform,
+    'X-SDK-Version': parsedHeaderData.xSdkVersion,
+    'User-Agent': parsedHeaderData.userAgent,
+  };
+
+  try {
+    var url = clickUrl;
+    if (isInstalled) {
+      url = previewUrl;
+    } else {
+      if (isRetryDownload) {
+        await track("CampaignActivatedRetry");
+      } else {
+        await track("CampaignActivated");
+      }
+      await axios.post(`https://api.tyrads.com/v3.0/campaigns/active/${campaignId}`, {}, { headers });
+    }
+    if (s2sClickUrl != null) {
+      const res = await axios.get(s2sClickUrl);
+      if (res.status == 200) {
+        // url = res.data.url;
+        return;
+      }
+    }
+    await acmoLaunchURLForce(url);
+  } catch (error) {
+    console.log('=============Error=============');
+    console.log(error);
+    console.log('====================================');
+  }
+}
+

package/src/acmo/modules/dashboard/top_offers.tsx

@@ -2,65 +2,95 @@ import React, { useState, useEffect } from 'react';
 import {
   View,
   Text,
-  ActivityIndicator,
   StyleSheet,
 } from 'react-native';
-import { fetchCampaignsData } from './repository';
+import { fetchPremiumOfferDetails, openOffer } from './repository';
 import PremiumHeaderSection from './components/premium_header';
 import CustomCard from './components/custom_card';
-import MyGamesButton from './components/my_games_button';
-import PremiumOption1 from './components/premium_option_1';
-import PremiumOption2 from './components/premium_option_2';
-import PremiumOption3 from './components/premium_option_3';
-import PremiumOption4 from './components/premium_option_4';
+import ActiveOffersButton from './components/active_offers_button';
+import { AcmoOfferListItem } from './components/offer_list_item';
+import AcmoOfferCard from './components/offer_card';
+import AcmoScrollPager from './components/custom_scroller';
+import PremiumEmptyView from './components/premium_empty_widget';
+import PremiumWidgetsLoading from './components/premium_loading';
+import TyradsNativeMethods from '../../core/helpers/native_methods';
 
-interface TopOffersProps {
-  showMore?: boolean;
-  showMyOffers?: boolean;
-  showMyOffersEmptyView?: boolean;
-  style?: number;
+export const enum PremiumWidgetStyles {
+  list,
+  sliderCards,
+}
+
+interface PremiumWidgetProps {
+  widgetStyle?: PremiumWidgetStyles;
   onNavigate: (route?: string, campaignID?: number) => void;
 }
 
-const TopOffers: React.FC<TopOffersProps> = ({
-  showMore,
-  showMyOffers = false,
-  showMyOffersEmptyView = false,
-  style = 1,
+const PremiumWidgets: React.FC<PremiumWidgetProps> = ({
+  widgetStyle = PremiumWidgetStyles.list,
   onNavigate
 }) => {
-  const [campaigns, setCampaigns] = useState<TransformedCampaign[]>([]);
+  const [campaigns, setCampaigns] = useState<Campaign[]>([]);
   const [isLoading, setIsLoading] = useState<boolean>(true);
   const [error, setError] = useState<string | null>(null);
   const [premiumColor, setPremiumColor] = useState<string>('#1C90DF');
-  // const [language, setLanguage] = useState<string>('en');
+  const [currencySale, setCurrencySale] = useState<CurrencySales>();
+  const [activeCount, setActiveCount] = useState<number>(0);
+  const [loadingIndex, setLoadingIndex] = useState<number | null>(null);
 
   useEffect(() => {
-    fetchCampaignsData(
-      // setLanguage,
+    fetchPremiumOfferDetails(
       setPremiumColor,
       setCampaigns,
+      setCurrencySale,
+      setActiveCount,
       setError,
-      setIsLoading
+      setIsLoading,
     );
+
   }, []);
 
   const handleShowOffers = () => {
     onNavigate();
   };
   const handleCampaignPress = (campaignId: number) => {
-    onNavigate('campaign-details',campaignId );
+    onNavigate("offers", campaignId);
   };
 
-  const handleMoreOffersPress = (route: string) => {
+  const handleActiveOffersPress = (route: string) => {
     onNavigate(route);
   };
 
+  const handleButtonPress = async (campaign: Campaign) => {
+    let isReady = await TyradsNativeMethods.isPrivacyAccepted()
+    if (!isReady) {
+      try {
+        const result = await TyradsNativeMethods.checkOnboardingProcess();
+        console.log("Privacy flow result:", result);
+        isReady = result === true;
+      } catch (err) {
+        console.error("Privacy flow error:", err);
+        isReady = false;
+      }
+    }
+    if (!isReady) {
+      return
+    }
+    await openOffer(campaign);
+    await fetchPremiumOfferDetails(
+      setPremiumColor,
+      setCampaigns,
+      setCurrencySale,
+      setActiveCount,
+      setError,
+      setIsLoading,
+    );
+  }
+
   if (isLoading) {
     return (
-      <View style={styles.loadingContainer}>
-        <ActivityIndicator size="large" color="#007AFF" />
-      </View>
+      <PremiumWidgetsLoading
+        widgetStyle={widgetStyle}
+      />
     );
   }
 
@@ -72,53 +102,75 @@ const TopOffers: React.FC<TopOffersProps> = ({
     );
   }
 
+
   if (campaigns.length === 0) {
-    if (showMyOffersEmptyView) {
-      return (
-        <View style={styles.noCampaignContainer}>
-          <Text>No campaigns available</Text>
-        </View>
-      );
-    } else {
-      return <View />;
-    }
+    return <PremiumEmptyView
+      colorPremium={premiumColor}
+      onContinue={handleShowOffers}
+    />
   }
 
   return (
-    <CustomCard style={{}}>
+    <CustomCard style={{ flexDirection: 'row' }}>
       <View style={{ flex: 1 }}>
-        <PremiumHeaderSection showMore={showMore} premiumColor={premiumColor} onShowOffers={handleShowOffers} />
+        <PremiumHeaderSection premiumColor={premiumColor} onShowOffers={handleShowOffers} />
         <View style={styles.headerSpacer} />
         {(() => {
-          switch (style) {
-            case 1:
-              return (
-                <PremiumOption1 data={campaigns} premiumColor={premiumColor} onCampaignPress={handleCampaignPress} />
-              );
-            case 2:
+          switch (widgetStyle) {
+            case PremiumWidgetStyles.list:
               return (
-                <PremiumOption2 data={campaigns} premiumColor={premiumColor}  onCampaignPress={handleCampaignPress} />
+                campaigns.map((item, index) => (
+                  <AcmoOfferListItem
+                    key={index}
+                    onPress={async () => handleCampaignPress && handleCampaignPress(item.campaignId)}
+                    offer={item}
+                    currencySales={currencySale}
+                    index={index}
+                    loadingIndex={loadingIndex}
+                    setLoadingIndex={setLoadingIndex}
+                    colorPremium={premiumColor}
+                    onButtonTap={async () => handleButtonPress(item)}
+                  />
+                ))
               );
-            case 3:
+            case PremiumWidgetStyles.sliderCards:
               return (
-                <PremiumOption3 data={campaigns} premiumColor={premiumColor}  onCampaignPress={handleCampaignPress} />
-              );
-            case 4:
-              return (
-                <PremiumOption4 data={campaigns} premiumColor={premiumColor} onCampaignPress={handleCampaignPress} />
+                <AcmoScrollPager
+                  totalPages={campaigns.length}
+                  activeIndicatorColor={premiumColor}
+                  content={(index) => (
+                    <AcmoOfferCard
+                      item={campaigns[index]!}
+                      onButtonClick={async () => handleButtonPress(campaigns[index]!)}
+                      currencySaleModel={currencySale}
+                      premiumColor={premiumColor}
+                      isLoading={false}
+                      onTap={async () => handleCampaignPress && handleCampaignPress(campaigns[index]!.campaignId)}
+                    />
+                  )}
+                />
               );
             default:
               return <Text>Please specify a correct style</Text>;
           }
         })()}
         <View style={styles.gameListSpacer} />
-        {showMyOffers && <MyGamesButton premiumColor={premiumColor} onPress={handleMoreOffersPress}/>}
+        <ActiveOffersButton activeCount={activeCount} premiumColor={premiumColor} onPress={handleActiveOffersPress} />
       </View>
     </CustomCard>
   );
 };
 
 const styles = StyleSheet.create({
+  itemContainer: {
+    flexDirection: 'row',
+    flex: 1,
+    width: '100%',
+    justifyContent: 'space-between',
+    alignItems: 'center',
+    paddingHorizontal: 16,
+    paddingVertical: 8,
+  },
   loadingContainer: {
     flex: 1,
     justifyContent: 'center',
@@ -141,4 +193,4 @@ const styles = StyleSheet.create({
   },
 });
 
-export default TopOffers;
+export default PremiumWidgets;

package/src/acmo/modules/localization/localization_context.tsx

@@ -0,0 +1,52 @@
+import React, { createContext, useContext, useState, useEffect } from 'react';
+import LocalizationService from '../../core/services/localization_service';
+
+interface LocalizationContextProps {
+  t: (key: string, args?: Record<string, string | number>) => string;
+  changeLanguage: (lang: string) => Promise<void>;
+  currentLanguage: string;
+}
+
+const LocalizationContext = createContext<LocalizationContextProps>({
+  t: (key) => key,
+  changeLanguage: async () => {},
+  currentLanguage: 'en',
+});
+
+let _updateLanguage: ((lang: string) => void) | null = null;
+
+export const LocalizationProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
+  const [currentLanguage, setCurrentLanguage] = useState('en');
+  const service = LocalizationService.getInstance();
+
+  useEffect(() => {
+    _updateLanguage = setCurrentLanguage;
+  }, []);
+
+  const changeLanguage = async (lang: string) => {
+    await service.changeLanguage(lang);
+    setCurrentLanguage(lang);
+  };
+
+  const t = (key: string, args?: Record<string, string | number>) => service.translate(key, args);
+
+  return (
+    <LocalizationContext.Provider value={{ t, changeLanguage, currentLanguage }}>
+      {children}
+    </LocalizationContext.Provider>
+  );
+};
+
+export const useLocalization = () => useContext(LocalizationContext);
+
+export const updateProviderLanguage = async (lang: string) => {
+  const service = LocalizationService.getInstance();
+  await service.init(lang);
+  _updateLanguage?.(lang);
+};
+
+export const changeProviderLanguage = async (lang: string) => {
+  const service = LocalizationService.getInstance();
+  await service.changeLanguage(lang);
+  _updateLanguage?.(lang);
+};

package/src/index.tsx

@@ -1,9 +1,10 @@
-import { NativeModules, Platform, View,} from 'react-native';
+import { NativeEventEmitter, NativeModules, Platform, View, } from 'react-native';
 
-import TopOffers from './acmo/modules/dashboard/top_offers';
+import TopOffers, { PremiumWidgetStyles } from './acmo/modules/dashboard/top_offers';
 import { saveData } from './acmo/core/storage/storage';
-import { I18nextProvider } from 'react-i18next';
-import i18n from './i18n';
+import Localization from './acmo/core/services/localization_service';
+import { changeProviderLanguage, LocalizationProvider, updateProviderLanguage } from './acmo/modules/localization/localization_context';
+import PremiumWidgetsLoading from './acmo/modules/dashboard/components/premium_loading';
 
 // const TyradsSdkComposeView = requireNativeComponent('TyradsSdkComposeView');
 
@@ -17,23 +18,54 @@ const LINKING_ERROR =
 const TyradsSdk = NativeModules.TyradsSdk
   ? NativeModules.TyradsSdk
   : new Proxy(
-      {},
-      {
-        get() {
-          throw new Error(LINKING_ERROR);
-        },
-      }
-    );
+    {},
+    {
+      get() {
+        throw new Error(LINKING_ERROR);
+      },
+    }
+  );
+
+const tyradsEmitter = new NativeEventEmitter(TyradsSdk);
+
+let languageChangedSubscription: any = null;
 
 const Tyrads = {
   init: async (apiKey: string, apiSecret: string, encKey?: string) => {
     const data = await TyradsSdk.init(apiKey, apiSecret, encKey);
+
+    await saveData("credentials", {
+      'X-API-Key': apiKey,
+      'X-API-Secret': apiSecret
+    });
+
+    let languageCode = "en";
+    try {
+      const parsed = typeof data === "string" ? JSON.parse(data) : data;
+      if (parsed?.languageCode) {
+        languageCode = parsed.languageCode;
+      }
+    } catch { }
+
+    TyradsSdk.startObserving();
+    languageChangedSubscription?.remove();
+    languageChangedSubscription = tyradsEmitter.addListener(
+      'LanguageChanged',
+      async (lang: string) => {
+        console.log('LanguageChanged event from Android SDK:', lang);
+        await changeProviderLanguage(lang);
+      }
+    );
+
+    await saveData("language", languageCode);
+    await Localization.getInstance().init(languageCode);
+    await updateProviderLanguage(languageCode);
+
     return data;
   },
   loginUser: async (userId: string) => {
     try {
       const data = await TyradsSdk.loginUser(userId);
-  
       if (typeof data === "object") {
         await saveData('apiHeaders', JSON.stringify(data));
         await saveData('language', data.languageCode);
@@ -41,54 +73,64 @@ const Tyrads = {
         await saveData('apiHeaders', data);
         await saveData('language', JSON.parse(data).languageCode);
       }
-  
       return data;
     } catch (err) {
       return null;
     }
   },
-  
+
   showOffers: async ({
     launchMode = 3,
     route,
-    campaignID = 0,
-  }: { launchMode?: number; route?: string; campaignID?: number } = {}) => {
+    campaignID,
+  }: { launchMode?: number; route?: string; campaignID?: number | null } = {}) => {
     if (Platform.OS === 'ios') {
-      return await TyradsSdk.showOffers(launchMode, route, campaignID);
+      if (campaignID == null) {
+        return await TyradsSdk.showOffers(launchMode, route);
+      }
+      return await TyradsSdk.showOfferDetails(launchMode, route, campaignID);
     } else {
-      return await TyradsSdk.showOffers(route, campaignID);
+      if (campaignID == null) {
+        return await TyradsSdk.showOffers(route);
+      }
+      return await TyradsSdk.showOfferDetails(route, campaignID);
     }
   },
   topPremiumOffers: ({
-    showMore = true,
-    showMyOffers = true,
-    showMyOffersEmptyView = false,
-    viewStyle = 1,
+    widgetStyle,
     launchMode = 2,
   }: {
-    showMore?: boolean;
-    showMyOffers?: boolean;
-    showMyOffersEmptyView?: boolean;
-    viewStyle?: number;
+    widgetStyle?: PremiumWidgetStyles;
     launchMode?: number;
   } = {}) => {
-    const handleNavigation = (route?: string, campaignID?: number) => {
-      Tyrads.showOffers({ route: route, campaignID: campaignID, launchMode: launchMode});
+    const handleNavigation = (route?: string, campaignID?: number | null) => {
+      Tyrads.showOffers({ route: route, campaignID: campaignID, launchMode: launchMode });
     };
     return (
-      <I18nextProvider i18n={i18n}>
+      <LocalizationProvider>
         <View style={{ flex: 1, justifyContent: 'center', alignItems: 'center' }}>
           <TopOffers
-            showMore={showMore}
-            showMyOffers={showMyOffers}
-            showMyOffersEmptyView={showMyOffersEmptyView}
-            style={viewStyle}
+            widgetStyle={widgetStyle}
             onNavigate={handleNavigation}
           />
         </View>
-      </I18nextProvider>
+      </LocalizationProvider>
     );
   },
+  topPremiumOffersLoading: (
+    { widgetStyle = PremiumWidgetStyles.list }: {
+      widgetStyle?: PremiumWidgetStyles;
+    }
+  ) => {
+    return (
+      <PremiumWidgetsLoading
+        widgetStyle={widgetStyle}
+      />
+    );
+  },
+  changeLanguage: async (lang: string) => {
+    return await TyradsSdk.changeLanguage(lang);
+  },
 };
 
 export default Tyrads;