@tyrads.com/tyrads-sdk 3.3.4 → 4.0.0

package/src/acmo/core/components/snap-carousel.tsx

@@ -0,0 +1,106 @@
+import '../helpers/patches'
+
+import React, { useRef, useState } from "react";
+import { View, Dimensions, StyleSheet, type ViewStyle } from "react-native";
+import Carousel, { Pagination } from "react-native-snap-carousel";
+
+interface SnapCarouselProps {
+  data: any[];
+  renderItem: ({ item, index }: any) => JSX.Element;
+  sliderWidth?: number;
+  itemWidth?: number;
+  showPagination?: boolean;
+  onSnapToItem?: (index: number) => void;
+  inactiveSlideScale?: number;
+  inactiveSlideOpacity?: number;
+  activeSlideAlignment?: "start" | "center" | "end";
+  containerStyle?: ViewStyle;
+  paginationContainerStyle?: ViewStyle;
+  dotStyle?: ViewStyle;
+  inActiveDotStyle?: ViewStyle;
+  inActiveDotScale?: number;
+  loop?: boolean;
+  autoplay?: boolean;
+  autoPlayDelay?: number;
+  [key: string]: any;
+}
+
+const { width: screenWidth } = Dimensions.get("window");
+
+const SnapCarousel: React.FC<SnapCarouselProps> = ({
+  data,
+  renderItem,
+  sliderWidth = screenWidth,
+  itemWidth = screenWidth * 0.75,
+  showPagination = true,
+  onSnapToItem = () => {},
+  inactiveSlideScale = 1,
+  inactiveSlideOpacity = 0.99,
+  activeSlideAlignment = "center",
+  containerStyle,
+  paginationContainerStyle,
+  dotStyle,
+  inActiveDotStyle,
+  inActiveDotScale = 0.95,
+  loop = false,
+  autoplay = false,
+  autoPlayDelay = 5000,
+  ...rest
+}) => {
+  const carouselRef = useRef<Carousel<any>>(null);
+  const [activeIndex, setActiveIndex] = useState(0);
+
+  const sidePadding = (sliderWidth - itemWidth) / 2;
+
+  const safeData = data || [];
+
+  return (
+    <View style={[containerStyle]}>
+      <Carousel
+        ref={carouselRef}
+        data={safeData}
+        renderItem={renderItem}
+        sliderWidth={sliderWidth}
+        itemWidth={itemWidth}
+        inactiveSlideScale={inactiveSlideScale}
+        inactiveSlideOpacity={inactiveSlideOpacity}
+        activeSlideAlignment={activeSlideAlignment}
+        onSnapToItem={(index) => {
+          setActiveIndex(index);
+          onSnapToItem(index);
+        }}
+        contentContainerCustomStyle={{
+          paddingHorizontal: sidePadding,
+        }}
+        loop={loop}
+        autoplay={autoplay}
+        autoplayDelay={autoPlayDelay}
+        {...rest}
+      />
+
+      {showPagination && (
+        <Pagination
+          dotsLength={safeData.length}
+          activeDotIndex={activeIndex}
+          dotStyle={[styles.dot, dotStyle]}
+          inactiveDotOpacity={0.3}
+          inactiveDotStyle={[inActiveDotStyle]}
+          inactiveDotScale={inActiveDotScale}
+          dotContainerStyle={[{ marginHorizontal: 4 , marginBottom: 0}]}
+          containerStyle={paginationContainerStyle}
+        />
+      )}
+    </View>
+  );
+};
+
+const styles = StyleSheet.create({
+  dot: {
+    width: 8,
+    height: 8,
+    borderRadius: 4,
+    backgroundColor: "#fff",
+  },
+});
+
+export default SnapCarousel;

package/src/acmo/core/constants/api-endpoints.ts

@@ -0,0 +1,12 @@
+class AcmoAPIEndpoints {
+  public static readonly TARGETED_CAMPAIGNS = "campaigns";
+  public static readonly ACTIVE_CAMPAIGNS = "campaigns/activated";
+  public static readonly SUMMARY = "campaigns/activated/summary";
+  public static readonly ENGAGEMENT = "account/engagement";
+  public static readonly USER_ACTIVITIES = "account/activity";
+  public static readonly ACTIVATE_CAMPAIGN = (id: number) => `campaigns/${id}/activate`;
+  public static readonly TRANSLATIONS = (locale: string) => `translations/${locale}`;
+  public static readonly TRANSLATIONS_VERSION = "translations/version";
+}
+
+export default AcmoAPIEndpoints;

package/src/acmo/core/helpers/colors.ts

@@ -0,0 +1,16 @@
+export const getContrastColor = (hexColor: string | null | undefined): string => {
+  if (!hexColor) return 'white';
+
+  let hex = hexColor.replace('#', '');
+
+  if (hex.length === 3) {
+    hex = hex.split('').map(char => char + char).join('');
+  }
+
+  const r = parseInt(hex.substring(0, 2), 16);
+  const g = parseInt(hex.substring(2, 4), 16);
+  const b = parseInt(hex.substring(4, 6), 16);
+  const yiq = ((r * 299) + (g * 587) + (b * 114)) / 1000;
+
+  return (yiq >= 128) ? 'black' : 'white';
+};

package/src/acmo/core/helpers/logger.ts

@@ -0,0 +1,11 @@
+export const Logger = {
+  log: (...args: any[]) => {
+    if (__DEV__) console.log(...args);
+  },
+  warn: (...args: any[]) => {
+    if (__DEV__) console.warn(...args);
+  },
+  error: (...args: any[]) => {
+    if (__DEV__) console.error(...args);
+  }
+};

package/src/acmo/core/helpers/patches.js

@@ -0,0 +1,6 @@
+import { View } from 'react-native';
+
+if (typeof View.propTypes === 'undefined') {
+  View.propTypes = {};
+}
+

package/src/acmo/core/network/http-client.ts

@@ -0,0 +1,89 @@
+import axios from "axios";
+import NetworkCommon from "./network-common";
+
+export type HttpError = {
+  type: "network" | "server" | "timeout" | "unknown";
+  status?: number;
+  data?: any;
+  message: string;
+};
+
+class HttpClient {
+  private handleError(error: any): HttpError {
+    if (axios.isAxiosError(error)) {
+      const status = error.response?.status;
+      const data = error.response?.data;
+
+      if (!error.response) {
+        return {
+          type: 'network',
+          message: 'Network error or no response from server',
+        };
+      }
+
+      if (error.code === 'ECONNABORTED') {
+        return {
+          type: 'timeout',
+          message: 'Request timed out',
+        };
+      }
+
+      return {
+        type: 'server',
+        status,
+        data,
+        message: error.message,
+      };
+    }
+
+    return {
+      type: 'unknown',
+      message: String(error),
+    };
+  }
+
+  async get(url: string, params?: any) {
+    const api = NetworkCommon.getInstance().getAxios();
+    try {
+      const response = await api.get(url, {
+        params: params ?? {},
+      });
+      return { status: response.status, data: response.data };
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  async post(url: string, data?: any, config?: any) {
+    const api = NetworkCommon.getInstance().getAxios();
+    try {
+      const response = await api.post(url, data, config);
+      return { status: response.status, data: response.data };
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  async put(url: string, data?: any, config?: any) {
+    const api = NetworkCommon.getInstance().getAxios();
+    try {
+      const response = await api.put(url, data, config);
+      return { status: response.status, data: response.data };
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  async delete(url: string, config?: any) {
+    const api = NetworkCommon.getInstance().getAxios();
+    try {
+      const response = await api.delete(url, config);
+      return { status: response.status, data: response.data };
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+}
+
+export const http = new HttpClient();
+

package/src/acmo/core/network/network-common.ts

@@ -0,0 +1,128 @@
+import axios, { type AxiosInstance, AxiosError } from 'axios';
+import { AcmoConfig } from '../../../acmo_config';
+import { Logger } from '../helpers/logger';
+import TyradsSdkCore from '../tyrads-sdk-core';
+import { getData } from '../storage/storage';
+
+const BASE_URL = AcmoConfig.BASE_URL;
+
+class NetworkCommon {
+  private static instance: NetworkCommon;
+  private axiosInstance: AxiosInstance | null = null;
+
+  private constructor() { }
+
+
+  public static getInstance(): NetworkCommon {
+    if (!NetworkCommon.instance) {
+      NetworkCommon.instance = new NetworkCommon();
+    }
+    return NetworkCommon.instance;
+  }
+
+  public async init(): Promise<void> {
+    if (this.axiosInstance) return;
+
+    this.axiosInstance = axios.create({
+      baseURL: BASE_URL,
+      timeout: 10000,
+      headers: {
+        'Content-Type': 'application/json',
+        Accept: 'application/json',
+      },
+    });
+
+    this.addInterceptors();
+  }
+
+  private logSafe(title: string, data: any) {
+    if (!__DEV__) return;
+
+    try {
+      console.group(title);
+      console.log(JSON.stringify(data, null, 2));
+      console.groupEnd();
+    } catch {
+      console.log(title, data);
+    }
+  }
+
+  private addInterceptors() {
+    if (!this.axiosInstance) return;
+
+    this.axiosInstance.interceptors.request.use(
+      async (config) => {
+        const apiKey = TyradsSdkCore.apiKey;
+        const apiSecret = TyradsSdkCore.apiSecret;
+        const sdkPlatform = AcmoConfig.SDK_PLATFORM;
+        const sdkVersion = AcmoConfig.SDK_VERSION;
+
+        let userId = TyradsSdkCore.userId;
+        if (!userId) {
+          userId = (await getData<string>('xUserId')) || '';
+        }
+
+        config.headers['X-API-Key'] = apiKey;
+        config.headers['X-API-Secret'] = apiSecret;
+        config.headers['X-User-ID'] = userId;
+        config.headers['X-SDK-Platform'] = sdkPlatform;
+        config.headers['X-SDK-Version'] = sdkVersion;
+
+        if (__DEV__) {
+          this.logSafe('HTTP REQUEST', {
+            timestamp: new Date().toISOString(),
+            method: config.method?.toUpperCase(),
+            url: `${config.baseURL}${config.url}`,
+            headers: {
+              ...config.headers,
+              'X-API-Key': '***',
+              'X-API-Secret': '***',
+            },
+            body: config.data,
+          });
+        }
+        return config;
+      },
+      (error) => {
+        Logger.error('Request Interceptor Error:', error);
+        return Promise.reject(error);
+      }
+    );
+
+    this.axiosInstance.interceptors.response.use(
+      (response) => {
+        if (__DEV__) {
+          this.logSafe('HTTP RESPONSE', {
+            timestamp: new Date().toISOString(),
+            status: response.status,
+            url: response.config.url,
+            data: response.data,
+          });
+        }
+        return response;
+      },
+      (error: AxiosError) => {
+        if (__DEV__) {
+          this.logSafe('HTTP ERROR', {
+            timestamp: new Date().toISOString(),
+            isAxiosError: axios.isAxiosError(error),
+            status: error.response?.status,
+            url: error.config?.url,
+            message: error.message,
+            responseData: error.response?.data,
+          });
+        }
+        return Promise.reject(error);
+      }
+    );
+  }
+
+  public getAxios(): AxiosInstance {
+    if (!this.axiosInstance) {
+      throw new Error('NetworkCommon not initialized. Call init() first.');
+    }
+    return this.axiosInstance;
+  }
+}
+
+export default NetworkCommon;

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,
 }