Offerwall SDK

{
  "user_id": "user_12345",
  "offer_id": "offer_678",
  "offer_name": "Premium Subscription",
  "reward": 100,
  "currency": "coins",
  "payout": 0.50,
  "status": "completed",
  "timestamp": 1699123456,
  "signature": "a3f5d8...",
  "transaction_id": "txn_abc123",
  "device_type": "android",
  "country": "US"
}

dependencies {
    // Chrome Custom Tabs (for offerwall display)
    implementation 'androidx.browser:browser:1.7.0'

    // HTTP client (for API calls)
    implementation 'com.squareup.okhttp3:okhttp:4.12.0'

    // JSON parsing
    implementation 'com.google.code.gson:gson:2.10.1'
}

// Add these frameworks in Xcode:
// - SafariServices.framework (for SFSafariViewController)

// In your Project Settings > General > Frameworks, Libraries:
// SafariServices.framework

using UnityEngine;
using UnityEngine.Networking;
using System.Collections;

public class InfyClickSDK : MonoBehaviour
{
    private static InfyClickSDK _instance;
    public static InfyClickSDK Instance
    {
        get
        {
            if (_instance == null)
            {
                GameObject go = new GameObject("InfyClickSDK");
                _instance = go.AddComponent<InfyClickSDK>();
                DontDestroyOnLoad(go);
            }
            return _instance;
        }
    }

    private string baseURL = "https://infyclick.com";
    private string apiKey;
    private string userId;
    private string deviceId;
    private bool sandbox;

    public void Initialize(string apiKey, string userId, string deviceId = "", bool sandbox = false)
    {
        this.apiKey = apiKey;
        this.userId = userId;
        this.deviceId = deviceId;
        this.sandbox = sandbox;
        Debug.Log($"InfyClickSDK initialized for user: {userId}");
    }

    public void ShowOfferwall()
    {
        string sandboxParam = sandbox ? "&sandbox=1" : "";
        string url = $"{baseURL}/api/offerwall/{apiKey}?user_id={userId}&device_id={deviceId}&platform=unity{sandboxParam}";

        #if UNITY_ANDROID
        // Use Chrome Custom Tabs on Android
        using (AndroidJavaClass unityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer"))
        using (AndroidJavaObject currentActivity = unityPlayer.GetStatic<AndroidJavaObject>("currentActivity"))
        using (AndroidJavaClass customTabs = new AndroidJavaClass("androidx.browser.customtabs.CustomTabsIntent"))
        using (AndroidJavaObject builder = new AndroidJavaObject("androidx.browser.customtabs.CustomTabsIntent$Builder"))
        using (AndroidJavaObject customTabsIntent = builder.Call<AndroidJavaObject>("build"))
        {
            customTabsIntent.Call("launchUrl", currentActivity, new AndroidJavaObject("android.net.Uri", url));
        }
        #elif UNITY_IOS
        // Use Safari on iOS
        Application.OpenURL(url);
        #else
        Application.OpenURL(url);
        #endif
    }

    public void GetBalance(System.Action<int> callback)
    {
        StartCoroutine(GetBalanceCoroutine(callback));
    }

    private IEnumerator GetBalanceCoroutine(System.Action<int> callback)
    {
        string url = $"{baseURL}/api/balance?api_key={apiKey}&user_id={userId}";
        using (UnityWebRequest request = UnityWebRequest.Get(url))
        {
            yield return request.SendWebRequest();

            if (request.result == UnityWebRequest.Result.Success)
            {
                string json = request.downloadHandler.text;
                BalanceResponse response = JsonUtility.FromJson<BalanceResponse>(json);
                callback?.Invoke(response.balance);
            }
            else
            {
                callback?.Invoke(0);
            }
        }
    }

    public void TrackEvent(string eventName, System.Collections.Generic.Dictionary<string, object> parameters = null)
    {
        StartCoroutine(TrackEventCoroutine(eventName, parameters));
    }

    private IEnumerator TrackEventCoroutine(string eventName, System.Collections.Generic.Dictionary<string, object> parameters)
    {
        string url = $"{baseURL}/api/events";
        // Implementation using UnityWebRequest
        yield return null;
    }
}

[System.Serializable]
private class BalanceResponse
{
    public int balance;
    public string currency;
}
}

using UnityEngine;
using UnityEngine.UI;

public class GameManager : MonoBehaviour
{
    public string apiKey = "your_api_key_here";
    public string userId = "user_" + System.Guid.NewGuid().ToString();
    public string deviceId = SystemInfo.deviceUniqueIdentifier;
    public Text balanceText;
    public Button offerwallButton;

    void Start()
    {
        // Initialize SDK
        InfyClickSDK.Instance.Initialize(apiKey, userId, deviceId, sandbox: false);

        // Setup button
        offerwallButton.onClick.AddListener(OpenOfferwall);

        // Get initial balance
        UpdateBalance();
    }

    void OpenOfferwall()
    {
        InfyClickSDK.Instance.ShowOfferwall();
    }

    void UpdateBalance()
    {
        InfyClickSDK.Instance.GetBalance((balance) => {
            balanceText.text = $"Coins: {balance}";
        });
    }
}

dependencies {
    implementation 'androidx.browser:browser:1.7.0'
}

# No npm package needed! Just copy the SDK file below
# Required dependencies (usually already installed):
npm install @react-native-community/netinfo

import { Linking, Platform } from 'react-native';
import InAppBrowser from 'react-native-inappbrowser-reborn';

const BASE_URL = 'https://infyclick.com';

class InfyClickSDK {
  constructor() {
    this.apiKey = '';
    this.userId = '';
    this.deviceId = '';
    this.sandbox = false;
  }

  initialize(apiKey, userId, deviceId = '', sandbox = false) {
    this.apiKey = apiKey;
    this.userId = userId;
    this.deviceId = deviceId;
    this.sandbox = sandbox;
    console.log('InfyClickSDK initialized for user:', userId);
    return this;
  }

  async showOfferwall() {
    const sandboxParam = this.sandbox ? '&sandbox=1' : '';
    const url = `${BASE_URL}/api/offerwall/${this.apiKey}?user_id=${this.userId}&device_id=${this.deviceId}&platform=${Platform.OS}${sandboxParam}`;

    try {
      if (await InAppBrowser.isAvailable()) {
        await InAppBrowser.open(url, {
          dismissButtonStyle: 'cancel',
          preferredBarTintColor: '#0c4a6e',
          preferredControlTintColor: 'white',
          readerMode: false,
          animated: true,
          modalPresentationStyle: 'fullScreen',
          modalTransitionStyle: 'coverVertical',
          modalEnabled: true,
          enableBarCollapsing: false,
        });
      } else {
        Linking.openURL(url);
      }
    } catch (error) {
      console.error('Error opening offerwall:', error);
      Linking.openURL(url);
    }
  }

  async getBalance() {
    try {
      const url = `${BASE_URL}/api/balance?api_key=${this.apiKey}&user_id=${this.userId}`;
      const response = await fetch(url);
      const data = await response.json();
      return data.balance || 0;
    } catch (error) {
      console.error('Error fetching balance:', error);
      return 0;
    }
  }

  async trackEvent(eventName, params = {}) {
    try {
      const url = `${BASE_URL}/api/events`;
      const response = await fetch(url, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          api_key: this.apiKey,
          user_id: this.userId,
          event_name: eventName,
          params
        })
      });
      return await response.json();
    } catch (error) {
      console.error('Error tracking event:', error);
    }
  }
}

export default new InfyClickSDK();

import React, { useEffect, useState } from 'react';
import { View, Text, Button, StyleSheet, Platform } from 'react-native';
import InfyClickSDK from './InfyClickSDK';

const API_KEY = 'your_api_key_here';
const USER_ID = 'user_' + Date.now();
const DEVICE_ID = Platform.OS === 'ios' ? 
  'ios_device_id_here' : 
  'android_device_id_here';

export default function App() {
  const [balance, setBalance] = useState(0);

  useEffect(() => {
    // Initialize SDK
    InfyClickSDK.initialize(API_KEY, USER_ID, DEVICE_ID, false);

    // Get initial balance
    updateBalance();
  }, []);

  const updateBalance = async () => {
    const newBalance = await InfyClickSDK.getBalance();
    setBalance(newBalance);
  };

  const openOfferwall = async () => {
    await InfyClickSDK.showOfferwall();
    // Refresh balance when returning
    updateBalance();
  };

  return (
    <View style={styles.container}>
      <Text style={styles.balance}>Coins: {balance}</Text>
      <Button title="Earn Coins" onPress={openOfferwall} />
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
    justifyContent: 'center',
    alignItems: 'center',
    backgroundColor: '#F5FCFF',
  },
  balance: {
    fontSize: 24,
    marginBottom: 20,
    fontWeight: 'bold',
  },
});

npm install react-native-inappbrowser-reborn
# or
yarn add react-native-inappbrowser-reborn

# iOS - install pods
cd ios && pod install

dependencies:
  flutter:
    sdk: flutter
  url_launcher: ^6.2.1
  flutter_inappwebview: ^6.0.0

import 'dart:io' show Platform;
import 'package:flutter/material.dart';
import 'package:flutter_inappwebview/flutter_inappwebview.dart';
import 'package:http/http.dart' as http;
import 'dart:convert';
import 'package:device_info_plus/device_info_plus.dart';

class InfyClickSDK {
  static final InfyClickSDK _instance = InfyClickSDK._internal();
  factory InfyClickSDK() => _instance;
  InfyClickSDK._internal();

  static const String baseURL = 'https://infyclick.com';
  String _apiKey = '';
  String _userId = '';
  String _deviceId = '';
  bool _sandbox = false;

  Future<void> initialize(String apiKey, String userId, {String deviceId = '', bool sandbox = false}) async {
    _apiKey = apiKey;
    _userId = userId;
    _deviceId = deviceId;
    _sandbox = sandbox;
    
    if (_deviceId.isEmpty) {
      final deviceInfo = DeviceInfoPlugin();
      if (Platform.isAndroid) {
        final androidInfo = await deviceInfo.androidInfo;
        _deviceId = androidInfo.id;
      } else if (Platform.isIOS) {
        final iosInfo = await deviceInfo.iosInfo;
        _deviceId = iosInfo.identifierForVendor ?? '';
      }
    }
    
    print('InfyClickSDK initialized for user: $userId');
  }

  Future<void> showOfferwall(BuildContext context) async {
    final sandboxParam = _sandbox ? '&sandbox=1' : '';
    final url = '$baseURL/api/offerwall/$_apiKey?user_id=$_userId&device_id=$_deviceId&platform=${Platform.operatingSystem.toLowerCase()}$sandboxParam';

    Navigator.push(
      context,
      MaterialPageRoute(
        builder: (context) => OfferwallScreen(url: url),
      ),
    );
  }

  Future<int> getBalance() async {
    try {
      final url = '$baseURL/api/balance?api_key=$_apiKey&user_id=$_userId';
      final response = await http.get(Uri.parse(url));

      if (response.statusCode == 200) {
        final data = jsonDecode(response.body);
        return data['balance'] ?? 0;
      }
      return 0;
    } catch (e) {
      print('Error fetching balance: $e');
      return 0;
    }
  }

  Future<Map<String, dynamic>> trackEvent(String eventName, {Map<String, dynamic>? params}) async {
    try {
      final url = Uri.parse('$baseURL/api/events');
      final response = await http.post(
        url,
        headers: {'Content-Type': 'application/json'},
        body: jsonEncode({
          'api_key': _apiKey,
          'user_id': _userId,
          'event_name': eventName,
          'params': params ?? {},
        }),
      );

      if (response.statusCode == 200) {
        return jsonDecode(response.body);
      }
      return {'error': 'Failed to track event'};
    } catch (e) {
      print('Error tracking event: $e');
      return {'error': e.toString()};
    }
  }
}

class OfferwallScreen extends StatelessWidget {
  final String url;

  const OfferwallScreen({Key? key, required this.url}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Earn Rewards'),
        leading: IconButton(
          icon: const Icon(Icons.close),
          onPressed: () => Navigator.pop(context),
        ),
      ),
      body: InAppWebView(
        initialUrlRequest: URLRequest(url: Uri.parse(url)),
        initialOptions: InAppWebViewGroupOptions(
          crossPlatform: InAppWebViewOptions(
            useShouldOverrideUrlLoading: true,
            mediaPlaybackRequiresUserGesture: false,
          ),
        ),
      ),
    );
  }
}

import 'package:flutter/material.dart';
import 'infyclick_sdk.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'InfyClick Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: const HomePage(),
    );
  }
}

class HomePage extends StatefulWidget {
  const HomePage({Key? key}) : super(key: key);

  @override
  State<HomePage> createState() => _HomePageState();
}

class _HomePageState extends State<HomePage> {
  final String apiKey = 'your_api_key_here';
  final String userId = 'user_${DateTime.now().millisecondsSinceEpoch}';
  int balance = 0;

  @override
  void initState() {
    super.initState();
    InfyClickSDK().initialize(apiKey, userId, sandbox: false);
    _updateBalance();
  }

  Future<void> _updateBalance() async {
    final newBalance = await InfyClickSDK().getBalance();
    setState(() => balance = newBalance);
  }

  Future<void> _openOfferwall() async {
    await InfyClickSDK().showOfferwall(context);
    _updateBalance();
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('InfyClick Demo')),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            Text(
              'Coins: $balance',
              style: const TextStyle(fontSize: 24, fontWeight: FontWeight.bold),
            ),
            const SizedBox(height: 20),
            ElevatedButton.icon(
              onPressed: _openOfferwall,
              icon: const Icon(Icons.card_giftcard),
              label: const Text('Earn More Coins'),
            ),
          ],
        ),
      ),
    );
  }
}

<!-- Offerwall Container -->
<div id="offerwall-container" style="width: 100%; height: 600px; display: none;">
  <iframe
    id="offerwall-iframe"
    src="https://infyclick.com/api/offerwall/YOUR_API_KEY?user_id=USER_ID&platform=web"
    style="width: 100%; height: 100%; border: none;"
    allow="fullscreen"
  ></iframe>
</div>

<button onclick="showOfferwall()">Earn Rewards</button>

<script>
const API_KEY = 'your_api_key_here';
const USER_ID = 'user_' + Date.now();
const BASE_URL = 'https://infyclick.com';

function showOfferwall() {
  const container = document.getElementById('offerwall-container');
  const iframe = document.getElementById('offerwall-iframe');

  // Update iframe src with dynamic values
  iframe.src = `${BASE_URL}/api/offerwall/${API_KEY}?user_id=${USER_ID}&platform=web`;

  container.style.display = 'block';
}

function hideOfferwall() {
  document.getElementById('offerwall-container').style.display = 'none';

  // Refresh balance when closing
  updateBalance();
}

async function updateBalance() {
  const response = await fetch(
    `${BASE_URL}/api/balance?api_key=${API_KEY}&user_id=${USER_ID}`
  );
  const data = await response.json();
  document.getElementById('balance').textContent = `Coins: ${data.balance}`;
}
</script>

// infyclick-sdk.js
class InfyClickSDK {
  constructor() {
    this.baseURL = 'https://infyclick.com';
    this.apiKey = '';
    this.userId = '';
    this.modal = null;
  }

  init(apiKey, userId, deviceId = '', sandbox = false) {
    this.apiKey = apiKey;
    this.userId = userId;
    this.deviceId = deviceId;
    this.sandbox = sandbox;
    console.log('InfyClickSDK initialized');
    return this;
  }

  showOfferwall() {
    const sandboxParam = this.sandbox ? '&sandbox=1' : '';
    const url = `${this.baseURL}/api/offerwall/${this.apiKey}?user_id=${this.userId}&device_id=${this.deviceId}&platform=web${sandboxParam}`;

    // Create modal
    this.modal = document.createElement('div');
    this.modal.innerHTML = `
      <div style="
        position: fixed;
        top: 0; left: 0; right: 0; bottom: 0;
        background: rgba(0,0,0,0.8);
        z-index: 9999;
        display: flex;
        justify-content: center;
        align-items: center;
      ">
        <div style="
          width: 90%;
          height: 90%;
          background: white;
          border-radius: 8px;
          overflow: hidden;
          position: relative;
        ">
          <button onclick="this.closest('.infyclick-modal').remove()"
            style="
              position: absolute;
              top: 10px; right: 10px;
              z-index: 10;
              padding: 8px 16px;
              background: #333;
              color: white;
              border: none;
              border-radius: 4px;
              cursor: pointer;
            ">
            Close
          </button>
          <iframe
            src="${url}"
            style="width: 100%; height: 100%; border: none;"
            allow="fullscreen"
          ></iframe>
        </div>
      </div>
    `;
    this.modal.className = 'infyclick-modal';
    document.body.appendChild(this.modal);
  }

  async getBalance() {
    const response = await fetch(
      `${this.baseURL}/api/balance?api_key=${this.apiKey}&user_id=${this.userId}`
    );
    const data = await response.json();
    return data.balance;
  }

  async trackEvent(eventName, params = {}) {
    const response = await fetch(`${this.baseURL}/api/events`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        api_key: this.apiKey,
        user_id: this.userId,
        event_name: eventName,
        params
      })
    });
    return await response.json();
  }
}

// Auto-initialize if config exists
window.InfyClick = new InfyClickSDK();

<!-- Include SDK -->
<script src="infyclick-sdk.js"></script>

<!-- Your HTML -->
<div>
  <span id="balance">Coins: 0</span>
  <button onclick="openOfferwall()">Earn More</button>
</div>

<script>
// Initialize
const API_KEY = 'your_api_key_here';
const USER_ID = 'user_' + Date.now();

InfyClick.init(API_KEY, USER_ID);

function openOfferwall() {
  InfyClick.showOfferwall();
}

// Update balance periodically
async function updateBalance() {
  const balance = await InfyClick.getBalance();
  document.getElementById('balance').textContent = `Coins: ${balance}`;
}

setInterval(updateBalance, 30000); // Update every 30 seconds
updateBalance(); // Initial load
</script>

# Test S2S callback endpoint
curl -X POST https://your-server.com/s2s/callback \
  -d "user_id=test_user_123" \
  -d "offer_id=offer_456" \
  -d "reward=100" \
  -d "currency=coins" \
  -d "timestamp=$(date +%s)" \
  -d "transaction_id=test_$(date +%s)" \
  -d "signature=YOUR_GENERATED_SIGNATURE" \
  -d "sandbox=true"

// Reject callbacks older than 5 minutes
const MAX_DELAY = 300; // seconds
const now = Math.floor(Date.now() / 1000);
if (Math.abs(now - timestamp) > MAX_DELAY) {
    return 400; // Reject stale callback
}

// Check for duplicate
if (database.exists("transactions", transaction_id)) {
    return 409; // Already processed
}

// Process reward
creditUser(user_id, reward);

// Mark as processed
database.insert("transactions", transaction_id);
return 200;

{
  "balance": 1500,
  "currency": "coins",
  "user_id": "user_12345",
  "pending_rewards": 200
}