@wscsports/blaze-rtn-gam-ads/lib/module/BlazeGAMCustomNativeAdsDelegate.js

WSC Sports Blaze GAM Ads component for React Native

import { BlazeGlobalEvents, BlazeAsyncBridge } from "@wscsports/blaze-rtn-sdk";
export class BlazeCustomNativeAdsDelegateHelper {
  static registerDelegate(delegate) {
    // Register event listeners for regular events
    BlazeCustomNativeAdsDelegateHelper.onGAMAdEvent(delegate?.onGAMAdEvent);
    BlazeCustomNativeAdsDelegateHelper.onGAMAdError(delegate?.onGAMAdError);
    BlazeCustomNativeAdsDelegateHelper.customGAMTargetingProperties(delegate?.customGAMTargetingProperties);
    BlazeCustomNativeAdsDelegateHelper.publisherProvidedId(delegate?.publisherProvidedId);
    BlazeCustomNativeAdsDelegateHelper.networkExtras(delegate?.networkExtras);
  }
  static onGAMAdEvent(callback) {
    const eventName = 'BlazeGAM.onAdEvent';
    if (callback) {
      BlazeGlobalEvents.createEventSubscription(eventName, data => {
        try {
          const eventType = data['eventType'];
          callback({
            eventType
          });
        } catch (e) {
          console.error('onGAMAdEvent', e);
        }
      });
    } else {
      BlazeGlobalEvents.cancelEventSubscription(eventName);
    }
  }
  static onGAMAdError(callback) {
    const eventName = 'BlazeGAM.onAdError';
    if (callback) {
      BlazeGlobalEvents.createEventSubscription(eventName, data => {
        try {
          const errorMessage = data['errorMessage'];
          callback(errorMessage);
        } catch (e) {
          console.error('onGAMAdError', e);
        }
      });
    } else {
      BlazeGlobalEvents.cancelEventSubscription(eventName);
    }
  }
  static customGAMTargetingProperties(callback) {
    const eventName = 'BlazeGAM.customGAMTargetingProperties';
    // Register async method handler
    if (callback) {
      BlazeAsyncBridge.registerJSMethod(eventName, async params => {
        try {
          const result = await callback(params);
          return result;
        } catch (error) {
          console.error(`Error in ${eventName}:`, error);
          return {};
        }
      });
    } else {
      // Unregister the handler if no delegate is provided
      BlazeAsyncBridge.unregisterJSMethod(eventName);
    }
  }
  static publisherProvidedId(callback) {
    const eventName = 'BlazeGAM.publisherProvidedId';
    // Register async method handler
    if (callback) {
      BlazeAsyncBridge.registerJSMethod(eventName, async params => {
        try {
          const result = await callback(params);
          return result;
        } catch (error) {
          console.error(`Error in ${eventName}:`, error);
          return undefined;
        }
      });
    } else {
      // Unregister the handler if no delegate is provided
      BlazeAsyncBridge.unregisterJSMethod(eventName);
    }
  }
  static networkExtras(callback) {
    const eventName = 'BlazeGAM.networkExtras';
    // Register async method handler
    if (callback) {
      BlazeAsyncBridge.registerJSMethod(eventName, async params => {
        try {
          const result = await callback(params);
          return result;
        } catch (error) {
          console.error(`Error in ${eventName}:`, error);
          return {};
        }
      });
    } else {
      // Unregister the handler if no delegate is provided
      BlazeAsyncBridge.unregisterJSMethod(eventName);
    }
  }
}
//# sourceMappingURL=BlazeGAMCustomNativeAdsDelegate.js.map