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

package/ios/Tyrads/WebViewController.swift

@@ -0,0 +1,195 @@
+import UIKit
+@preconcurrency import WebKit
+
+class AcmoWebViewController: UIViewController, WKNavigationDelegate, WKScriptMessageHandler, WKUIDelegate {
+
+    var webView: WKWebView!
+    var initialURL: URL
+    private var hasLoadedWithSkipParameter = false
+  
+    private let internalDomains: [String] = ["sdk.tyrads.com", "acmo.in"]
+    
+    private func log(_ message: String) {
+        NSLog("AcmoWebViewController: \(message)")
+    }
+
+    init(url: URL) {
+        self.initialURL = url
+        super.init(nibName: nil, bundle: nil)
+    }
+
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        log("viewDidLoad called")
+
+        let config = WKWebViewConfiguration()
+        let userContentController = WKUserContentController()
+
+        userContentController.add(self, name: "clickHandler")
+        config.userContentController = userContentController
+
+        webView = WKWebView(frame: self.view.bounds, configuration: config)
+        webView.navigationDelegate = self
+        webView.uiDelegate = self
+        self.view.addSubview(webView)
+
+        webView.translatesAutoresizingMaskIntoConstraints = false
+        NSLayoutConstraint.activate([
+            webView.topAnchor.constraint(equalTo: self.view.topAnchor),
+            webView.bottomAnchor.constraint(equalTo: self.view.bottomAnchor),
+            webView.leadingAnchor.constraint(equalTo: self.view.leadingAnchor),
+            webView.trailingAnchor.constraint(equalTo: self.view.trailingAnchor)
+        ])
+
+        if #available(iOS 16.4, *) {
+            webView.isInspectable = true
+        }
+        
+//        webView.load(URLRequest(url: initialURL))
+        loadURL()
+        log("WebView loaded URL: \(initialURL.absoluteString)")
+    }
+  private func loadURL() {
+    var components = URLComponents(url: initialURL, resolvingAgainstBaseURL: false)
+    let skipUserUpdate = Tyrads.instance.getSkipUserUpdate()
+    let skipValue = skipUserUpdate ? "true" : "false"
+    
+    components?.queryItems?.removeAll { $0.name == "skipUserInfo" }
+    components?.queryItems?.append(URLQueryItem(name: "skipUserInfo", value: skipValue))
+    
+    if let updatedURL = components?.url {
+      log("Loading URL with skipUserInfo=\(skipValue): \(updatedURL.absoluteString)")
+      let request = URLRequest(url: updatedURL)
+      webView.load(request)
+      hasLoadedWithSkipParameter = true
+    } else {
+      log("Failed to create updated URL, loading original")
+      webView.load(URLRequest(url: initialURL))
+    }
+  }
+
+  public func userContentController(_ userContentController: WKUserContentController, didReceive message: WKScriptMessage) {
+        guard message.name == "clickHandler",
+              let messageDict = message.body as? [String: Any] else {
+            log("Received unknown message or invalid format.")
+            return
+        }
+        
+        log("Message data from webview: \(messageDict)")
+
+        if let action = messageDict["action"] as? String {
+            switch action {
+            case "closeWebView":
+                log("Action: closeWebView received. Dismissing view controller.")
+                DispatchQueue.main.async {
+                    self.dismiss(animated: true) {
+                        self.log("ViewController dismissed successfully.")
+                    }
+                }
+                
+            case "changeLanguage":
+                if let langCode = messageDict["value"] as? String {
+                    log("Action: changeLanguage received. Language Code: \(langCode)")
+                  Task{
+                    await Tyrads.instance.changeLanguage(langCode)
+                  }
+//                  let value = UserDefaults.standard.string(forKey: "locale")
+                }
+                
+            default:
+                log("Unknown command: \(action)")
+            }
+        }
+    }
+
+    public func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {
+        if let url = webView.url {
+            print("Page loaded successfully. Final URL: \(url.absoluteString)")
+        }
+        
+        let js = """
+        window.addEventListener('message', (event) => {
+            try {
+                // Safely parse JSON if event.data is a string, otherwise use directly
+                const message = typeof event.data === 'string'
+                                ? JSON.parse(event.data)
+                                : event.data;
+                if (message) {
+                    // Post the message to the native side using the registered handler name
+                    window.webkit.messageHandlers.clickHandler.postMessage(message);
+                }
+            } catch (error) {
+                console.error('Error handling message from WebView:', error);
+            }
+        });
+        """
+        
+        webView.evaluateJavaScript(js) { _, error in
+            if let error = error {
+                self.log("JavaScript injection failed: \(error.localizedDescription)")
+            } else {
+                self.log("JavaScript listener injected successfully.")
+            }
+        }
+    }
+  
+    func webView(_ webView: WKWebView, decidePolicyFor navigationAction: WKNavigationAction, decisionHandler: @escaping (WKNavigationActionPolicy) -> Void) {
+          
+        guard let url = navigationAction.request.url, let host = url.host else {
+            decisionHandler(.cancel)
+            return
+        }
+        
+        if host == "about:blank" {
+            decisionHandler(.allow)
+            return
+        }
+        
+        let isInternalDomain = internalDomains.contains(where: { host.hasSuffix($0) })
+        
+        if host != webView.url?.host && !isInternalDomain {
+            log("Intercepted external URL via navigation action: \(url.absoluteString). Opening externally.")
+            UIApplication.shared.open(url, options: [:], completionHandler: nil)
+            decisionHandler(.cancel)
+            return
+        }
+        
+        log("Allowed navigation to: \(url.absoluteString)")
+        decisionHandler(.allow)
+    }
+    
+    func webView(_ webView: WKWebView, createWebViewWith configuration: WKWebViewConfiguration, for navigationAction: WKNavigationAction, windowFeatures: WKWindowFeatures) -> WKWebView? {
+        
+        guard let url = navigationAction.request.url else {
+            return nil
+        }
+        
+        let isInternalDomain = internalDomains.contains(where: { url.host?.hasSuffix($0) ?? false })
+        
+        if !isInternalDomain {
+            log("Intercepted new window via UI delegate: \(url.absoluteString). Opening externally.")
+            UIApplication.shared.open(url, options: [:], completionHandler: nil)
+            return nil
+        }
+        
+        log("Allowed new window for internal domain: \(url.absoluteString)")
+        return nil
+    }
+    
+    public func webView(_ webView: WKWebView, didFail navigation: WKNavigation!, withError error: Error) {
+        log("WebView navigation failed with error: \(error.localizedDescription)")
+    }
+
+    public func webView(_ webView: WKWebView, didFailProvisionalNavigation navigation: WKNavigation!, withError error: Error) {
+        log("WebView provisional navigation failed with error: \(error.localizedDescription)")
+    }
+
+    deinit {
+        webView.configuration.userContentController.removeScriptMessageHandler(forName: "clickHandler")
+        log("AcmoWebViewController deinitialized. Message handler removed.")
+    }
+}

package/ios/Tyrads/core/utils/AcmoKeyNames.swift

@@ -0,0 +1,29 @@
+//
+//  AcmoKeyNames.swift
+//  Pods
+//
+//  Created by Basharat Mehdi on 30/09/25.
+//
+
+struct AcmoKeyNames {
+    static let PREFIX = "acmo_tyrads_sdk_"
+    
+    static let INTRODUCTION_COMPLETE = "\(PREFIX)introduction_complete"
+    static let LOGGED_IN = "\(PREFIX)logged_in"
+    static let USER_ID = "\(PREFIX)user_id"
+    static let API_KEY = "\(PREFIX)api_key"
+    static let API_SECRET = "\(PREFIX)api_secret"
+    static let ENCRYPTION_KEY = "\(PREFIX)encryption_key"
+    static let PLAY_INTEGRITY_TOKEN = "\(PREFIX)play_integrity_token"
+    static let USERNAME = "\(PREFIX)username"
+    static let FCM_TOKEN = "\(PREFIX)fcm_token"
+    static let USER_DATA = "\(PREFIX)user_data"
+    static let ADVERTISING_ID = "\(PREFIX)advertising_id"
+    static let TRACKED_CAMPAIGNS_FOR_USER_ID = "\(PREFIX)tracked_campaigns_for_user_id_"
+    static let PLAY_PER_MINUTE_PACKAGES = "\(PREFIX)play_per_minute_packages"
+    static let PRIVACY_ACCEPTED_FOR_USER_ID = "\(PREFIX)privacy_accepted_for_user_id_"
+    static let SKIP_FOR_USER_ID = "\(PREFIX)skip_for_user_id_"
+    static let CUSTOM_AD_ID = "\(PREFIX)custom_ad_id"
+    static let LANGUAGE = "\(PREFIX)language"
+    static let TOKEN = "\(PREFIX)token"
+}

package/ios/Tyrads/core/utils/ColorExtension.swift

@@ -0,0 +1,55 @@
+//
+//  ColorExtension.swift
+//  Pods
+//
+//  Created by Basharat Mehdi on 01/10/25.
+//
+import SwiftUI
+import UIKit
+
+extension Color {
+  init(hex: String) {
+    let hex = hex.trimmingCharacters(in: CharacterSet.alphanumerics.inverted)
+    var int: UInt64 = 0
+    Scanner(string: hex).scanHexInt64(&int)
+    let r, g, b: UInt64
+    switch hex.count {
+    case 3:
+      (r, g, b) = ((int >> 8) * 17, ((int >> 4) & 0xF) * 17, (int & 0xF) * 17)
+    case 6:
+      (r, g, b) = (int >> 16, (int >> 8) & 0xFF, int & 0xFF)
+    default:
+      (r, g, b) = (0, 0, 0)
+    }
+    self.init(
+      .sRGB,
+      red: Double(r) / 255,
+      green: Double(g) / 255,
+      blue: Double(b) / 255,
+      opacity: 1
+    )
+  }
+}
+
+extension UIColor {
+  convenience init(hex: String, alpha: CGFloat = 1.0) {
+    var hexSanitized = hex.trimmingCharacters(in: .whitespacesAndNewlines)
+    hexSanitized = hexSanitized.hasPrefix("#") ? String(hexSanitized.dropFirst()) : hexSanitized
+    
+    var rgb: UInt64 = 0
+    Scanner(string: hexSanitized).scanHexInt64(&rgb)
+    
+    let length = hexSanitized.count
+    let r, g, b: CGFloat
+    
+    if length == 6 {
+      r = CGFloat((rgb & 0xFF0000) >> 16) / 255.0
+      g = CGFloat((rgb & 0x00FF00) >> 8) / 255.0
+      b = CGFloat(rgb & 0x0000FF) / 255.0
+    } else {
+      r = 0; g = 0; b = 0
+    }
+    
+    self.init(red: r, green: g, blue: b, alpha: alpha)
+  }
+}

package/ios/Tyrads/core/utils/Services/LocalizationService.swift

@@ -0,0 +1,175 @@
+//
+//  LocalizationService.swift
+//  Pods
+//
+//  Created by Basharat Mehdi on 02/10/25.
+//
+
+import Foundation
+
+final class LocalizationService {
+  
+  static let shared = LocalizationService()
+  private init() {}
+  
+  private var translations: [String: Any] = [:]
+  private var supportedLocales: [String] = []
+  
+  private let userDefaults = UserDefaults.standard
+  private let fallbackLocale = "en"
+  
+  // MARK: - Public Interface
+  func initialize(locale: String) async {
+    await loadTranslations(locale: locale)
+  }
+  
+  func changeLanguage(locale: String, force: Bool = false) async {
+    await loadTranslations(locale: locale, force: force)
+  }
+  
+  func translate(_ key: String, args: [String: String]? = nil) -> String {
+    let keys = key.split(separator: ".").map { String($0) }
+    var current: Any? = translations
+    
+    for k in keys {
+      if let dict = current as? [String: Any], let next = dict[k] {
+        current = next
+      } else {
+        return key
+      }
+    }
+    
+    guard var result = current as? String else {
+      return key
+    }
+    
+    if let args = args {
+      for (argKey, argValue) in args {
+        let regex = try? NSRegularExpression(pattern: "\\{\(argKey)\\}", options: .caseInsensitive)
+        if let regex = regex {
+          result = regex.stringByReplacingMatches(in: result, range: NSRange(result.startIndex..., in: result), withTemplate: argValue)
+        }
+      }
+    }
+    
+    return result
+  }
+  
+  // MARK: - Private Loading Methods
+  private func loadTranslations(locale: String, force: Bool = false) async {
+    let hasUpdate = await checkForUpdate(locale: locale, force: force)
+    
+    if !hasUpdate {
+      if let cachedData = userDefaults.data(forKey: "translations_\(locale)"),
+         let json = try? JSONSerialization.jsonObject(with: cachedData, options: []) as? [String: Any] {
+        translations = json
+        return
+      }
+    }
+    
+    await fetchTranslations(locale: locale, force: force)
+  }
+  
+  private func fetchTranslations(locale: String, force: Bool) async {
+    var currentLocale = locale
+    if !supportedLocales.contains(currentLocale) {
+      currentLocale = fallbackLocale
+    }
+    
+    
+    let urlString = "\(AcmoConfig.BASE_URL)translations/\(currentLocale)?force=\(force)&format=nested"
+    guard let url = URL(string: urlString) else {
+      print("LocalizationService: Invalid URL for translations")
+      return
+    }
+    
+    var request = URLRequest(url: url)
+    request.httpMethod = "GET"
+    request.setTyradsHeaders(with: Tyrads.instance)
+    
+    do {
+      let (data, response) = try await URLSession.shared.data(for: request)
+      
+      guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
+        print("LocalizationService: Failed to load translations: \((response as? HTTPURLResponse)?.statusCode ?? -1)")
+        return
+      }
+      
+      if let jsonResponse = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any] {
+        translations = jsonResponse
+        
+        userDefaults.set(data, forKey: "translations_\(currentLocale)")
+      } else {
+        print("LocalizationService: Failed to parse JSON response.")
+      }
+    } catch {
+      print("LocalizationService: Network error fetching translations: \(error)")
+    }
+  }
+  
+  private func checkForUpdate(locale: String, force: Bool) async -> Bool {
+    let urlString = "\(AcmoConfig.BASE_URL)translations/version?force=\(force)"
+    guard let url = URL(string: urlString) else {
+      print("LocalizationService: Invalid URL for version check")
+      return false
+    }
+    var request = URLRequest(url: url)
+    request.httpMethod = "GET"
+    request.setTyradsHeaders(with: Tyrads.instance)
+    
+    do {
+      let (data, response) = try await URLSession.shared.data(for: request)
+      
+      guard (response as? HTTPURLResponse)?.statusCode == 200 else {
+        print("LocalizationService: Failed to get version check response.")
+        return false
+      }
+      
+      struct VersionData: Decodable {
+        let code: String
+        let sha256: String
+      }
+      struct VersionResponse: Decodable {
+        let data: [VersionData]
+      }
+      
+      let jsonResponse = try JSONDecoder().decode(VersionResponse.self, from: data)
+      let versionData = jsonResponse.data
+      
+      supportedLocales = versionData.map { $0.code }
+      
+      guard supportedLocales.contains(locale) else {
+        return false
+      }
+      
+      guard let currentLocaleVersion = versionData.first(where: { $0.code == locale }) else {
+        return false
+      }
+      
+      let currentSha256 = currentLocaleVersion.sha256
+      let cachedVersion = userDefaults.string(forKey: "cached_version_\(locale)")
+      
+      if currentSha256 != cachedVersion {
+        userDefaults.set(currentSha256, forKey: "cached_version_\(locale)")
+        return true
+      }
+      
+    } catch {
+      print("LocalizationService: Error checking for update: \(error)")
+    }
+    
+    return false
+  }
+}
+
+extension URLRequest {
+  mutating func setTyradsHeaders(with sdk: Tyrads) {
+    self.setValue("application/json", forHTTPHeaderField: "Content-Type")
+    
+    self.setValue(sdk.apiKey, forHTTPHeaderField: "X-API-Key")
+    self.setValue(sdk.apiSecret, forHTTPHeaderField: "X-API-Secret")
+    
+    self.setValue(AcmoConfig.SDK_PLATFORM, forHTTPHeaderField: "X-SDK-Platform")
+    self.setValue(AcmoConfig.SDK_VERSION, forHTTPHeaderField: "X-SDK-Version")
+  }
+}

package/ios/Tyrads/helpers/device_details.swift

@@ -0,0 +1,160 @@
+//
+//  device_details.swift
+//  Pods
+//
+//  Created by Basharat Mehdi on 01/08/25.
+//
+import UIKit
+import Foundation
+
+func getDeviceDetails() -> [String: Any] {
+  var fd = [String: Any]()
+  
+  let device = UIDevice.current
+  let bundle = Bundle.main
+  let locale = Locale.current
+  
+  // Device basic info
+  fd["deviceId"] = device.identifierForVendor?.uuidString ?? "Unknown"
+  fd["device"] = device.model.lowercased().contains("ipad") ? "iPad" : "iPhone"
+  fd["deviceName"] = device.name
+  fd["brand"] = "Apple"
+  fd["model"] = device.model
+  fd["baseOs"] = device.systemName
+  fd["releaseVersion"] = device.systemVersion
+  fd["modelName"] = getModelName()
+  
+  fd["product"] = "Darwin"
+  fd["platform"] = "iOS"
+  fd["apiVersion"] = AcmoConfig.API_VERSION
+  fd["sdkVersion"] = AcmoConfig.SDK_VERSION
+  fd["sdkPlatform"] = AcmoConfig.SDK_PLATFORM
+  
+  // App info
+  fd["version"] = bundle.infoDictionary?["CFBundleShortVersionString"] as? String ?? "Unknown"
+  fd["build"] = bundle.infoDictionary?["CFBundleVersion"] as? String ?? "Unknown"
+  fd["package"] = bundle.bundleIdentifier ?? "Unknown"
+  fd["installerStore"] = "App Store"
+  
+  fd["osLang"] = locale.languageCode ?? "en"
+  
+  // security and virtual check
+  fd["rooted"] = isJailBroken()
+  fd["virtual"] = isRunningOnSimulator()
+  
+  return fd
+}
+
+func isRunningOnSimulator() -> Bool {
+  return ProcessInfo().environment["SIMULATOR_DEVICE_NAME"] != nil
+}
+
+func isJailBroken() -> Bool {
+#if targetEnvironment(simulator)
+  return false
+#else
+  let paths = [
+    "/Applications/Cydia.app",
+    "/Library/MobileSubstrate/MobileSubstrate.dylib",
+    "/bin/bash",
+    "/usr/sbin/sshd",
+    "/etc/apt",
+    "/private/var/lib/apt/"
+  ]
+  for path in paths {
+    if FileManager.default.fileExists(atPath: path) {
+      return true
+    }
+  }
+  return false
+#endif
+}
+
+func deviceIdentifier() -> String {
+#if targetEnvironment(simulator)
+  if let simIdentifier = ProcessInfo().environment["SIMULATOR_MODEL_IDENTIFIER"] {
+    return simIdentifier
+  }
+  return "Simulator"
+#else
+  var systemInfo = utsname()
+  uname(&systemInfo)
+  let machineMirror = Mirror(reflecting: systemInfo.machine)
+  let identifier = machineMirror.children.reduce("") { identifier, element in
+    guard let value = element.value as? Int8, value != 0 else { return identifier }
+    return identifier + String(UnicodeScalar(UInt8(value)))
+  }
+  return identifier
+#endif
+}
+
+
+func getModelName() -> String {
+  let identifier = deviceIdentifier()
+  
+  let iphoneModelMapping: [String: String] = [
+    "iPhone1,1": "iPhone",
+    "iPhone1,2": "iPhone 3G",
+    "iPhone2,1": "iPhone 3GS",
+    "iPhone3,1": "iPhone 4",
+    "iPhone3,2": "iPhone 4 GSM Rev A",
+    "iPhone3,3": "iPhone 4 CDMA",
+    "iPhone4,1": "iPhone 4S",
+    "iPhone5,1": "iPhone 5 (GSM)",
+    "iPhone5,2": "iPhone 5 (GSM+CDMA)",
+    "iPhone5,3": "iPhone 5C (GSM)",
+    "iPhone5,4": "iPhone 5C (Global)",
+    "iPhone6,1": "iPhone 5S (GSM)",
+    "iPhone6,2": "iPhone 5S (Global)",
+    "iPhone7,1": "iPhone 6 Plus",
+    "iPhone7,2": "iPhone 6",
+    "iPhone8,1": "iPhone 6s",
+    "iPhone8,2": "iPhone 6s Plus",
+    "iPhone8,4": "iPhone SE (1st Gen)",
+    "iPhone9,1": "iPhone 7",
+    "iPhone9,2": "iPhone 7 Plus",
+    "iPhone9,3": "iPhone 7",
+    "iPhone9,4": "iPhone 7 Plus",
+    "iPhone10,1": "iPhone 8",
+    "iPhone10,2": "iPhone 8 Plus",
+    "iPhone10,3": "iPhone X Global",
+    "iPhone10,4": "iPhone 8",
+    "iPhone10,5": "iPhone 8 Plus",
+    "iPhone10,6": "iPhone X GSM",
+    "iPhone11,2": "iPhone XS",
+    "iPhone11,4": "iPhone XS Max",
+    "iPhone11,6": "iPhone XS Max Global",
+    "iPhone11,8": "iPhone XR",
+    "iPhone12,1": "iPhone 11",
+    "iPhone12,3": "iPhone 11 Pro",
+    "iPhone12,5": "iPhone 11 Pro Max",
+    "iPhone12,8": "iPhone SE (2nd Gen)",
+    "iPhone13,1": "iPhone 12 Mini",
+    "iPhone13,2": "iPhone 12",
+    "iPhone13,3": "iPhone 12 Pro",
+    "iPhone13,4": "iPhone 12 Pro Max",
+    "iPhone14,2": "iPhone 13 Pro",
+    "iPhone14,3": "iPhone 13 Pro Max",
+    "iPhone14,4": "iPhone 13 Mini",
+    "iPhone14,5": "iPhone 13",
+    "iPhone14,6": "iPhone SE (3rd Gen)",
+    "iPhone14,7": "iPhone 14",
+    "iPhone14,8": "iPhone 14 Plus",
+    "iPhone15,2": "iPhone 14 Pro",
+    "iPhone15,3": "iPhone 14 Pro Max",
+    "iPhone15,4": "iPhone 15",
+    "iPhone15,5": "iPhone 15 Plus",
+    "iPhone16,1": "iPhone 15 Pro",
+    "iPhone16,2": "iPhone 15 Pro Max",
+    "iPhone17,1": "iPhone 16 Pro",
+    "iPhone17,2": "iPhone 16 Pro Max",
+    "iPhone17,3": "iPhone 16",
+    "iPhone17,4": "iPhone 16 Plus",
+    "iPhone17,5": "iPhone 16e",
+    "iPhone18,1": "iPhone 17 Pro",
+    "iPhone18,2": "iPhone 17 Pro Max",
+    "iPhone18,3": "iPhone 17",
+    "iPhone18,4": "iPhone Air"
+  ]
+  return iphoneModelMapping[identifier] ?? identifier
+}