Ad Detector - iOS Integration Instructions

http://info.appsmartsite.com/Material_monitor/nochina/1.0.0/MaterialMonitorSDK-1.0.0.zip

MaterialMonitorSDK-1.0.0/
  MaterialMonitorSDK.xcframework/

import MaterialMonitorSDK
import AppTrackingTransparency
import AdSupport

class AppDelegate: UIResponder, UIApplicationDelegate {

    // Recommended: run the ATT authorization flow in applicationDidBecomeActive
    func applicationDidBecomeActive(_ application: UIApplication) {
        if #available(iOS 14, *) {
            ATTrackingManager.requestTrackingAuthorization { _ in
                self.initMaterialMonitor()
            }
        } else {
            initMaterialMonitor()
        }
    }

    private func initMaterialMonitor() {
        let appId      = "your_app_id"
        let appKey     = "your_app_key"
        let idfa       = ASIdentifierManager.shared().advertisingIdentifier.uuidString
        let sdkVersion = "your_host_sdk_version"                   // host aggregator SDK version

        // MARK: - MaterialMonitor SDK initialization (full parameters)
        let config = MaterialMonitorConfig.Builder()
            // -- upload service URL -----------------------------------------
            .baseUploadUrl("https://your-upload-host.com")
            // -- authentication ---------------------------------------------
            .appId(appId)
            .appKey(appKey)
            // -- device identifiers ----------------------------------------
            .idfa(idfa)                 // pass ATTrackingManager.advertisingIdentifier.uuidString after ATT
            .idfv(nil)                  // when nil, SDK reads UIDevice.current.identifierForVendor automatically
            .sdkVersion(sdkVersion)     // host aggregator SDK version, written into meta device_info.sdk_version
            .caid(nil)                  // CAID (China Advertising ID, optional)
            // -- network timeout (ms) --------------------------------------
            .connectTimeoutMs(15_000)   // TCP connect timeout, default 15s, minimum 3s
            .readTimeoutMs(30_000)      // server response timeout, default 30s, minimum 3s
            // -- retry policy ----------------------------------------------
            .maxUploadAttempts(3)              // first send + up to 2 retries, minimum 1
            .retryDelayMs([5_000, 15_000])     // retry delays (Swift only)
            // -- debugging (keep false in production) ----------------------
            .debugPerfLogging(false)
            .build()

        MaterialMonitor.initialize(config: config)
    }
}

#import <MaterialMonitorSDK/MaterialMonitorSDK-Swift.h>
#import <AppTrackingTransparency/AppTrackingTransparency.h>
#import <AdSupport/AdSupport.h>

- (void)applicationDidBecomeActive:(UIApplication *)application {
    if (@available(iOS 14, *)) {
        [ATTrackingManager requestTrackingAuthorizationWithCompletionHandler:^(ATTrackingManagerAuthorizationStatus status) {
            [self initMaterialMonitor];
        }];
    } else {
        [self initMaterialMonitor];
    }
}

- (void)initMaterialMonitor {
    NSString *appId      = @"your_app_id";
    NSString *appKey     = @"your_app_key";
    NSString *idfa       = [[[ASIdentifierManager sharedManager] advertisingIdentifier] UUIDString];
    NSString *sdkVersion = @"6.5.0";

    MMConfigBuilder *builder = [[MMConfigBuilder alloc] init];
    // -- upload service URL --
    [builder baseUploadUrl:@"https://your-upload-host.com"];
    // -- authentication --
    [builder appId:appId];
    [builder appKey:appKey];
    // -- device identifiers --
    [builder idfa:idfa];
    [builder idfv:nil];
    [builder sdkVersion:sdkVersion];
    [builder caid:nil];
    // -- network timeout (ms) --
    [builder connectTimeoutMs:15000];
    [builder readTimeoutMs:30000];
    // -- retry policy (ObjC does not support custom retryDelayMs, use default [5000, 15000]) --
    [builder maxUploadAttempts:3];
    // -- debugging (keep NO in production) --
    [builder debugPerfLogging:NO];

    MaterialMonitorConfig *config = [builder build];
    [MaterialMonitor initializeWithConfig:config];
}

MaterialMonitor.shutdown()

[MaterialMonitor shutdown];

let config = MaterialMonitorConfig.Builder()
    .baseUploadUrl("https://your-upload-host.com")
    .appId(appId)
    .appKey(appKey)
    .idfa(idfa)                          // pass in after ATT authorization
    .idfv(nil)                           // SDK reads automatically when nil
    .sdkVersion(sdkVersion)
    .connectTimeoutMs(15_000)
    .readTimeoutMs(30_000)
    .maxUploadAttempts(3)
    .retryDelayMs([5_000, 15_000])
    .debugPerfLogging(false)
    .build()

public func collectFrameFromAdContainer(
    _ view: UIView,
    adInfo: MMAdInfo,
    timing: AdTimingInput,
    options: FrameOptions,
    callback: FrameCallback
)

func onBannerAdShow(_ bannerView: UIView, extra: [String: Any]) {
    MaterialMonitor.shared.collectFrameFromAdContainer(
        bannerView,
        adInfo: buildMMAdInfo(from: extra),
        timing: buildTiming(extra),
        options: FrameOptions(delayMs: 200),  // Banner can use a shorter delay
        callback: self
    )
}

public func collectFrameFromAdPage(
    adInfo: MMAdInfo,
    timing: AdTimingInput,
    options: FrameOptions,
    callback: FrameCallback
)

func splashAdDidShow() {
    MaterialMonitor.shared.collectFrameFromAdPage(
        adInfo: adInfo,
        timing: timing,
        options: FrameOptions(delayMs: 3000),  // give splash video enough render time, in ms
        callback: self
    )
}

public func reportFrameRecord(
    _ record: FrameRecord,
    adInfo: MMAdInfo,
    callback: ReportCallback?
)

MaterialMonitor.shared.flushPendingUploads()

// Swift
let records = MaterialMonitor.shared.getRecords(style: .banner)

// ObjC (by adType integer)
NSArray<FrameRecord *> *records = [[MaterialMonitor shared] getRecordsForAdType:2];

MaterialMonitor.shared.deleteRecord(record)

let config = MaterialMonitor.shared.getConfig()

@objc public protocol FrameCallback: AnyObject {
    func onCollectSuccess(_ record: FrameRecord)
    func onCollectFailure(errorCode: Int, errorName: String, message: String)
    func onReportSuccess(_ record: FrameRecord)
    func onReportSkip(_ record: FrameRecord, reason: String)
    func onReportFailure(errorCode: Int, errorName: String, message: String, record: FrameRecord?)
}

public init(requestTimeMs: Int64, fillTimeMs: Int64, showTimeMs: Int64)

let timing = AdTimingInput.sameWallClockMs(Int64(Date().timeIntervalSince1970 * 1000))

public init(
    delayMs: Int           = 500,
    maxSizeKb: Int         = 300,
    maxLongEdge: Int       = 1080,
    keepQualityFirst: Bool = true,
    excludeViews: [UIView] = []
)

import MaterialMonitorSDK
import AppTrackingTransparency
import AdSupport

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(_ application: UIApplication,
                     didFinishLaunchingWithOptions launchOptions: [...]?) -> Bool {
        // Initialize after ATT authorization (recommended)
        if #available(iOS 14, *) {
            ATTrackingManager.requestTrackingAuthorization { status in
                DispatchQueue.main.async {
                    self.setupMaterialMonitor()
                }
            }
        } else {
            setupMaterialMonitor()
        }
        return true
    }

    private func setupMaterialMonitor() {
        let idfa = ASIdentifierManager.shared().advertisingIdentifier.uuidString

        let config = MaterialMonitorConfig.Builder()
            .baseUploadUrl("https://your-upload-host.com")
            .appId("your_app_id")
            .appKey("your_app_key")
            .idfa(idfa)
            .sdkVersion("6.5.0")
            .debugPerfLogging(false)
            .build()

        MaterialMonitor.initialize(config: config)
    }
}

extension MyViewController: FrameCallback {

    func onBannerAdShow(_ bannerView: UIView, extra: [String: Any]) {
        let adInfo = buildMMAdInfo(from: extra)

        MaterialMonitor.shared.collectFrameFromAdContainer(
            bannerView,
            adInfo: adInfo,
            timing: adInfo.timingInput,
            options: FrameOptions(delayMs: 200),
            callback: self
        )
    }

    // MARK: FrameCallback
    func onCollectSuccess(_ record: FrameRecord) {
        print("Success: captured taskId=\(record.uploadTaskId)")
    }
    func onCollectFailure(errorCode: Int, errorName: String, message: String) {
        print("Failure: [\(errorName)] \(message)")
    }
    func onReportSuccess(_ record: FrameRecord) {
        print("Success: reported showId=\(record.showId)")
    }
    func onReportSkip(_ record: FrameRecord, reason: String) {
        print("Skipped: \(reason)")
    }
    func onReportFailure(errorCode: Int, errorName: String,
                        message: String, record: FrameRecord?) {
        print("Failure: [\(errorName)] \(message)")
    }
}

#import <MaterialMonitorSDK/MaterialMonitorSDK-Swift.h>

@interface MyViewController () <FrameCallback>
@end

@implementation MyViewController

- (void)onBannerAdShow:(UIView *)bannerView extra:(NSDictionary *)extra {
    MMAdInfo *adInfo = [self buildMMAdInfoFromExtra:extra];
    AdTimingInput *timing = [[AdTimingInput alloc]
        initWithRequestTimeMs:adInfo.requestTimestamp
                   fillTimeMs:adInfo.fillTimestamp
                   showTimeMs:adInfo.showTimestamp];
    FrameOptions *options = [[FrameOptions alloc] init];

    [[MaterialMonitor shared] collectFrameFromAdContainer:bannerView
                                                   adInfo:adInfo
                                                   timing:timing
                                                  options:options
                                                 callback:self];
}

#pragma mark - FrameCallback
- (void)onCollectSuccess:(FrameRecord *)record {
    NSLog(@"Success: %@", record.uploadTaskId);
}
- (void)onCollectFailureWithErrorCode:(NSInteger)code
                            errorName:(NSString *)name
                              message:(NSString *)msg {
    NSLog(@"Failure: [%@] %@", name, msg);
}
- (void)onReportSuccess:(FrameRecord *)record { /* ... */ }
- (void)onReportSkip:(FrameRecord *)record reason:(NSString *)reason { /* ... */ }
- (void)onReportFailureWithErrorCode:(NSInteger)code
                           errorName:(NSString *)name
                             message:(NSString *)msg
                              record:(FrameRecord *)record { /* ... */ }
@end

func nativeAdDidShow(_ nativeView: UIView) {
    MaterialMonitor.shared.collectFrameFromAdContainer(
        nativeView,
        adInfo: adInfo,
        timing: timing,
        options: FrameOptions(delayMs: 300),   // native creative usually renders a bit slower
        callback: self
    )
}