adwhale-sdk-react-native 2.7.100

package/android/src/main/java/com/adwhalesdkreactnative/AdwhaleSdkReactNativePackage.java

@@ -0,0 +1,130 @@
+package com.adwhalesdkreactnative;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.BaseReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.model.ReactModuleInfo;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * React Native New Architecture 적용
+ * TurboModule(code gen 모듈) + 기존 NativeModule(전면/보상형) + ViewManager 혼용 구조
+ */
+public class AdwhaleSdkReactNativePackage extends BaseReactPackage {
+
+  @Override
+  public NativeModule getModule(String name, ReactApplicationContext reactContext) {
+    // TurboModule (New Arch용) – initialize 모듈
+    if (RNAdWhaleMediationAdSettingModule.REACT_CLASS_NAME.equals(name)) {
+      return new RNAdWhaleMediationAdSettingModule(reactContext);
+    }
+
+    // 로거 Old Architecture를 따르지만 등록은 TurboModule로 등록
+    if (RNAdWhaleMediationLoggerModule.REACT_CLASS_NAME.equals(name)) {
+      return new RNAdWhaleMediationLoggerModule(reactContext);
+    }
+
+    // 전면 Old Architecture를 따르지만 등록은 TurboModule로 등록
+    if (RNAdWhaleMediationInterstitialAd.REACT_CLASS_NAME.equals(name)) {
+      return new RNAdWhaleMediationInterstitialAd(reactContext);
+    }
+
+    // 보상형 Old Architecture를 따르지만 등록은 TurboModule로 등록
+    if (RNAdWhaleMediationRewardAd.REACT_CLASS_NAME.equals(name)) {
+      return new RNAdWhaleMediationRewardAd(reactContext);
+    }
+    return null;
+  }
+
+  @NonNull
+  @Override
+  public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+    // Old Arch + New Arch 브리지에서 사용할 전면/보상형 모듈 등록
+    // Old Architecture 앱도 지원하기 위해 그대로 유지
+    return Arrays.<NativeModule>asList(
+      new RNAdWhaleMediationLoggerModule(reactContext),
+      new RNAdWhaleMediationInterstitialAd(reactContext),
+      new RNAdWhaleMediationRewardAd(reactContext)
+      // RNAdWhaleMediationAdSettingModule는 TurboModule로 등록되므로 여기서 굳이 추가 안 해도 됨
+    );
+  }
+
+  @NonNull
+  @Override
+  public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+    // 배너 ViewManager
+    return Arrays.<ViewManager>asList(
+      new RNAdWhaleMediationAdView(),
+      new RNAdWhaleMediationTemplateNativeAdView(),
+      new RNAdWhaleMediationCustomNativeAdView());
+  }
+
+  @Override
+  public ReactModuleInfoProvider getReactModuleInfoProvider() {
+    return () -> {
+      Map<String, ReactModuleInfo> moduleInfos = new HashMap<>();
+
+      // TurboModule: RNAdWhaleMediationAdSettingModule
+      moduleInfos.put(
+        RNAdWhaleMediationAdSettingModule.REACT_CLASS_NAME,
+        new ReactModuleInfo(
+          RNAdWhaleMediationAdSettingModule.REACT_CLASS_NAME,
+          RNAdWhaleMediationAdSettingModule.REACT_CLASS_NAME,
+          false, // canOverrideExistingModule
+          false, // needsEagerInit
+          false, // isCxxModule
+          true   // isTurboModule
+        )
+      );
+
+      // 로거/전면/보상형은 legacy 모듈로 사용 (isTurboModule = false)
+      moduleInfos.put(
+        RNAdWhaleMediationLoggerModule.REACT_CLASS_NAME,
+        new ReactModuleInfo(
+          RNAdWhaleMediationLoggerModule.REACT_CLASS_NAME,
+          RNAdWhaleMediationLoggerModule.REACT_CLASS_NAME,
+          false,
+          false,
+          false,
+          false
+        )
+      );
+
+      // 로거/전면/보상형은 legacy 모듈로 사용 (isTurboModule = false)
+      moduleInfos.put(
+        RNAdWhaleMediationInterstitialAd.REACT_CLASS_NAME,
+        new ReactModuleInfo(
+          RNAdWhaleMediationInterstitialAd.REACT_CLASS_NAME,
+          RNAdWhaleMediationInterstitialAd.REACT_CLASS_NAME,
+          false,
+          false,
+          false,
+          false
+        )
+      );
+
+      // 로거/전면/보상형은 legacy 모듈로 사용 (isTurboModule = false)
+      moduleInfos.put(
+        RNAdWhaleMediationRewardAd.REACT_CLASS_NAME,
+        new ReactModuleInfo(
+          RNAdWhaleMediationRewardAd.REACT_CLASS_NAME,
+          RNAdWhaleMediationRewardAd.REACT_CLASS_NAME,
+          false,
+          false,
+          false,
+          false
+        )
+      );
+
+      return moduleInfos;
+    };
+  }
+}

package/android/src/main/java/com/adwhalesdkreactnative/RNAdWhaleMediationAdSettingModule.java

@@ -0,0 +1,64 @@
+package com.adwhalesdkreactnative;
+
+import android.app.Activity;
+import android.util.Log;
+
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.module.annotations.ReactModule;
+
+import net.adwhale.sdk.mediation.ads.AdWhaleMediationAds;
+import net.adwhale.sdk.mediation.ads.AdWhaleMediationOnInitCompleteListener;
+import net.adwhale.sdk.utils.AdWhaleLog;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 초기화 모듈은 최신 TurboModule을 적용
+ * JS <--> 네이티브 호출이 더 빠르고 타입 안정성이 제공되기 때문
+ */
+@ReactModule(name = RNAdWhaleMediationAdSettingModule.REACT_CLASS_NAME)
+public class RNAdWhaleMediationAdSettingModule extends NativeAdwhaleSdkReactNativeSpec {
+  public static final String REACT_CLASS_NAME = "AdwhaleSdkReactNative";
+
+  public RNAdWhaleMediationAdSettingModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  public String getName() {
+    return REACT_CLASS_NAME;
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public void initialize(final Promise promise) {
+    Log.i(REACT_CLASS_NAME, ".initialize()");
+    Activity currentActivity = getCurrentActivity();
+    if (currentActivity == null) {
+      promise.reject("NO_ACTIVITY", "Unable to initialize AdWhale SDK: No activity available");
+      return;
+    }
+
+    AdWhaleLog.setLogLevel(AdWhaleLog.LogLevel.Verbose);
+
+    AdWhaleMediationAds.init(currentActivity, new AdWhaleMediationOnInitCompleteListener() {
+      @Override
+      public void onInitComplete(int statusCode, String message) {
+        Log.i(REACT_CLASS_NAME, ".onInitComplete(" + statusCode + ", " + message + ")");
+        promise.resolve(statusCode);
+      }
+    });
+  }
+
+  @Nullable
+  @Override
+  public Map<String, Object> getConstants() {
+    final Map<String, Object> constants = new HashMap<>();
+    return constants;
+  }
+}
+

package/android/src/main/java/com/adwhalesdkreactnative/RNAdWhaleMediationAdView.java

@@ -0,0 +1,172 @@
+package com.adwhalesdkreactnative;
+
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+import android.widget.LinearLayout;
+import android.widget.RelativeLayout;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.common.MapBuilder;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.ViewGroupManager;
+import com.facebook.react.uimanager.annotations.ReactProp;
+import com.facebook.react.uimanager.events.RCTEventEmitter;
+
+import net.adwhale.sdk.mediation.ads.ADWHALE_AD_SIZE;
+import net.adwhale.sdk.mediation.ads.AdWhaleMediationAdView;
+import net.adwhale.sdk.mediation.ads.AdWhaleMediationAdViewListener;
+
+import java.util.Map;
+
+public class RNAdWhaleMediationAdView extends ViewGroupManager<RNWrapperView> {
+
+    public static final String REACT_CLASS_NAME = RNAdWhaleMediationAdView.class.getSimpleName();
+
+    public RNAdWhaleMediationAdView(){
+    }
+
+    @NonNull
+    @Override
+    public String getName() {
+      return REACT_CLASS_NAME;
+    }
+
+    @NonNull
+    @Override
+    protected RNWrapperView createViewInstance(@NonNull ThemedReactContext themedReactContext) {
+      final RNWrapperView wrapperView = new RNWrapperView(themedReactContext);
+      Log.e(REACT_CLASS_NAME, "wrapperView created.");
+      Log.i(REACT_CLASS_NAME, "getCurrentActivity(): " + themedReactContext.getCurrentActivity());
+
+      final AdWhaleMediationAdView adWhaleMediationAdView = new AdWhaleMediationAdView(themedReactContext.getCurrentActivity());
+
+      adWhaleMediationAdView.setAdWhaleMediationAdViewListener(new AdWhaleMediationAdViewListener() {
+        @Override
+        public void onAdLoaded() {
+          Log.e(REACT_CLASS_NAME, "onAdLoaded()");
+          ReactContext context = (ReactContext) wrapperView.getContext();
+          if (context != null) {
+            context.getJSModule(RCTEventEmitter.class)
+              .receiveEvent(wrapperView.getId(),
+                "onAdLoaded", null);
+          }
+        }
+
+        @Override
+        public void onAdLoadFailed(int statusCode, String message) {
+          Log.e(REACT_CLASS_NAME, "onAdLoadFailed(" + statusCode + "," + message + ")");
+          ReactContext context = (ReactContext) wrapperView.getContext();
+          if (context != null) {
+            WritableMap params = Arguments.createMap();
+            params.putInt("statusCode", statusCode);
+            params.putString("message", message);
+            context.getJSModule(RCTEventEmitter.class)
+              .receiveEvent(wrapperView.getId(),
+                "onAdLoadFailed", params);
+          }
+        }
+
+        @Override
+        public void onAdClicked() {
+          Log.e(REACT_CLASS_NAME, "onAdClicked()");
+          ReactContext context = (ReactContext) wrapperView.getContext();
+          if (context != null) {
+            context.getJSModule(RCTEventEmitter.class)
+              .receiveEvent(wrapperView.getId(),
+                "onAdClicked", null);
+          }
+        }
+      });
+
+      RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(
+        LinearLayout.LayoutParams.WRAP_CONTENT, LinearLayout.LayoutParams.WRAP_CONTENT);
+      params.addRule(RelativeLayout.CENTER_HORIZONTAL);
+      wrapperView.addView(adWhaleMediationAdView, params);
+      Log.e(REACT_CLASS_NAME, "adWhaleMediationAdView is attached to wrapperView.");
+
+      return wrapperView;
+    }
+
+    @ReactProp(name = "placementUid")
+    public void setPlacementUid(RNWrapperView view, String placementUid) {
+      AdWhaleMediationAdView adView = getAdWhaleMediationAdView(view);
+      if (adView != null) {
+        adView.setPlacementUid(placementUid);
+      }
+    }
+
+    @ReactProp(name = "adSize")
+    public void setAdSize(RNWrapperView view, String adSizeName) {
+      AdWhaleMediationAdView adView = getAdWhaleMediationAdView(view);
+      if (adView == null) return;
+
+      ADWHALE_AD_SIZE adSize = ADWHALE_AD_SIZE.DEFAULT;
+      if ("320x50".equals(adSizeName)) {
+        adSize = ADWHALE_AD_SIZE.BANNER320x50;
+      } else if ("320x100".equals(adSizeName)) {
+        adSize = ADWHALE_AD_SIZE.BANNER320x100;
+      } else if ("300x250".equals(adSizeName)) {
+        adSize = ADWHALE_AD_SIZE.BANNER300x250;
+      } else if ("250x250".equals(adSizeName)) {
+        adSize = ADWHALE_AD_SIZE.BANNER250x250;
+      } else if ("ADAPTIVE_ANCHOR".equals(adSizeName)) {
+        adSize = ADWHALE_AD_SIZE.ADAPTIVE_ANCHOR;
+      }
+      adView.setAdwhaleAdSize(adSize);
+      Log.d(REACT_CLASS_NAME, "Ad size set to: " + adSize.name());
+    }
+
+    @ReactProp(name = "loadAd")
+    public void setLoadAd(RNWrapperView view, boolean loadAd) {
+      if (loadAd) {
+        AdWhaleMediationAdView adView = getAdWhaleMediationAdView(view);
+        if (adView != null) {
+          // Delay slightly to ensure placementUid is set
+          new Handler(Looper.getMainLooper()).postDelayed(adView::loadAd, 100);
+        }
+      }
+    }
+
+    private AdWhaleMediationAdView getAdWhaleMediationAdView(RNWrapperView parent) {
+      if (parent != null && parent.getChildCount() > 0 && parent.getChildAt(0) instanceof AdWhaleMediationAdView) {
+        return (AdWhaleMediationAdView) parent.getChildAt(0);
+      }
+      return null;
+    }
+
+    @Override
+    public void onDropViewInstance(@NonNull RNWrapperView view) {
+      Log.e(REACT_CLASS_NAME, "onDropViewInstance() - cleaning up AdView");
+      super.onDropViewInstance(view);
+      AdWhaleMediationAdView adView = getAdWhaleMediationAdView(view);
+      if (adView != null) {
+        adView.destroy();
+      }
+    }
+
+    // The listener methods are now implemented in an anonymous class within createViewInstance
+    // and are no longer part of this class, so they are removed from here.
+
+
+    @Nullable
+    @Override
+    public Map<String, Object> getExportedCustomDirectEventTypeConstants() {
+      Log.e(REACT_CLASS_NAME, "getExportedCustomDirectEventTypeConstants()");
+      return MapBuilder.<String, Object>builder()
+        .put("onAdLoaded",
+          MapBuilder.of("registrationName", "onAdLoaded"))
+        .put("onAdLoadFailed",
+          MapBuilder.of("registrationName", "onAdLoadFailed"))
+        .put("onAdClicked",
+          MapBuilder.of("registrationName", "onAdClicked"))
+        .build();
+
+    }
+}
+

package/android/src/main/java/com/adwhalesdkreactnative/RNAdWhaleMediationCustomNativeAdView.java

@@ -0,0 +1,197 @@
+package com.adwhalesdkreactnative;
+
+import android.app.Activity;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.View;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.common.MapBuilder;
+import com.facebook.react.uimanager.SimpleViewManager;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.annotations.ReactProp;
+import com.facebook.react.uimanager.events.RCTEventEmitter;
+
+import net.adwhale.sdk.mediation.ads.AdWhaleMediationNativeAdView;
+import net.adwhale.sdk.mediation.ads.AdWhaleMediationNativeAdViewListener;
+import net.adwhale.sdk.mediation.ads.AdWhaleNativeAdBinder;
+
+import java.util.Map;
+
+public class RNAdWhaleMediationCustomNativeAdView extends SimpleViewManager<RNWrapperView> {
+    private static final String REACT_CLASS_NAME = RNAdWhaleMediationCustomNativeAdView.class.getSimpleName();
+
+    public static final int COMMAND_LOAD_AD = 1;
+    public static final int COMMAND_SHOW_AD = 2;
+
+    private String placementUid;
+    private String layoutName;
+
+    @NonNull
+    @Override
+    public String getName() {
+        return REACT_CLASS_NAME;
+    }
+
+    @NonNull
+    @Override
+    protected RNWrapperView createViewInstance(@NonNull ThemedReactContext reactContext) {
+        return new RNWrapperView(reactContext);
+    }
+
+    @ReactProp(name = "placementUid")
+    public void setPlacementUid(RNWrapperView view, @Nullable String pid) {
+        this.placementUid = pid;
+    }
+
+    @ReactProp(name = "layoutName")
+    public void setLayoutName(RNWrapperView view, @Nullable String name) {
+        this.layoutName = name;
+    }
+
+    @Nullable
+    @Override
+    public Map<String, Integer> getCommandsMap() {
+        return MapBuilder.of(
+            "loadAd", COMMAND_LOAD_AD,
+            "showAd", COMMAND_SHOW_AD
+        );
+    }
+
+    @Nullable
+    @Override
+    public Map<String, Object> getExportedCustomDirectEventTypeConstants() {
+        return MapBuilder.of(
+                "onAdLoaded", MapBuilder.of("registrationName", "onAdLoaded"),
+                "onAdFailedToLoad", MapBuilder.of("registrationName", "onAdFailedToLoad")
+        );
+    }
+
+    @Override
+    public void receiveCommand(@NonNull RNWrapperView root, int commandId, @Nullable ReadableArray args) {
+        super.receiveCommand(root, commandId, args);
+        switch (commandId) {
+            case COMMAND_LOAD_AD:
+                loadAd(root);
+                break;
+            case COMMAND_SHOW_AD:
+                showAd(root);
+                break;
+        }
+    }
+
+    private void loadAd(RNWrapperView root) {
+        if (placementUid == null || placementUid.isEmpty()) {
+            Log.e(REACT_CLASS_NAME, "Placement UID is not set.");
+            dispatchEvent(root, "onAdFailedToLoad", createErrorEvent(-1, "Placement UID is not set."));
+            return;
+        }
+
+        if (layoutName == null || layoutName.isEmpty()) {
+            Log.e(REACT_CLASS_NAME, "Layout name is not provided from JS.");
+            dispatchEvent(root, "onAdFailedToLoad", createErrorEvent(-1, "Layout name is not provided from JS."));
+            return;
+        }
+
+        ReactContext reactContext = (ReactContext) root.getContext();
+        Activity currentActivity = reactContext.getCurrentActivity();
+
+        if (currentActivity == null) {
+            Log.e(REACT_CLASS_NAME, "Could not get current Activity.");
+            dispatchEvent(root, "onAdFailedToLoad", createErrorEvent(-1, "Could not get current Activity."));
+            return;
+        }
+
+        int layoutId = currentActivity.getResources().getIdentifier(this.layoutName, "layout", currentActivity.getPackageName());
+
+        if (layoutId == 0) {
+            String errorMessage = "Layout file not found: " + this.layoutName;
+            Log.e(REACT_CLASS_NAME, errorMessage);
+            dispatchEvent(root, "onAdFailedToLoad", createErrorEvent(-1, errorMessage));
+            return;
+        }
+
+        currentActivity.runOnUiThread(() -> {
+            // Clean up previous ad view if any
+            root.removeAllViews();
+
+            AdWhaleMediationNativeAdView adView = new AdWhaleMediationNativeAdView(currentActivity);
+            root.addView(adView); // Add the SDK's view to our wrapper view
+
+            adView.setAdWhaleMediationNativeAdViewListener(new AdWhaleMediationNativeAdViewListener() {
+                @Override
+                public void onNativeAdLoaded() {
+                    Log.d(REACT_CLASS_NAME, "Ad loaded successfully. Ready to show.");
+                    dispatchEvent(root, "onAdLoaded", null);
+                }
+
+                @Override
+                public void onNativeAdFailedToLoad(int errorCode, String errorMessage) {
+                    Log.e(REACT_CLASS_NAME, "Ad failed to load: " + errorMessage);
+                    dispatchEvent(root, "onAdFailedToLoad", createErrorEvent(errorCode, errorMessage));
+                }
+                @Override public void onNativeAdClicked() {}
+                @Override public void onNativeAdClosed() {}
+                @Override public void onNativeAdShowFailed(int i, @NonNull String s) {}
+            });
+
+            String packageName = currentActivity.getPackageName();
+            AdWhaleNativeAdBinder binder = new AdWhaleNativeAdBinder.Builder(currentActivity, layoutId)
+                .setIconViewId(currentActivity.getResources().getIdentifier("view_icon", "id", packageName))
+                .setTitleViewId(currentActivity.getResources().getIdentifier("view_title", "id", packageName))
+                .setBodyTextViewId(currentActivity.getResources().getIdentifier("view_body", "id", packageName))
+                .setCallToActionViewId(currentActivity.getResources().getIdentifier("button_cta", "id", packageName))
+                .setMediaViewGroupId(currentActivity.getResources().getIdentifier("view_media", "id", packageName))
+                .build();
+
+            adView.setPlacementUid(placementUid);
+            adView.loadAdWithBinder(binder);
+        });
+    }
+
+    private void showAd(RNWrapperView root) {
+        AdWhaleMediationNativeAdView adView = getAdWhaleMediationNativeAdView(root);
+        if (adView != null) {
+            Log.d(REACT_CLASS_NAME, "Calling show().");
+            adView.show();
+            root.requestLayout();
+        } else {
+            Log.e(REACT_CLASS_NAME, "AdView not found. Cannot show ad.");
+        }
+    }
+
+    @Override
+    public void onDropViewInstance(@NonNull RNWrapperView view) {
+        super.onDropViewInstance(view);
+        AdWhaleMediationNativeAdView adView = getAdWhaleMediationNativeAdView(view);
+        if (adView != null) {
+            adView.destroy();
+        }
+    }
+
+    private AdWhaleMediationNativeAdView getAdWhaleMediationNativeAdView(RNWrapperView parent) {
+        if (parent != null && parent.getChildCount() > 0 && parent.getChildAt(0) instanceof AdWhaleMediationNativeAdView) {
+            return (AdWhaleMediationNativeAdView) parent.getChildAt(0);
+        }
+        return null;
+    }
+
+    private WritableMap createErrorEvent(int errorCode, String errorMessage) {
+        WritableMap event = Arguments.createMap();
+        event.putInt("errorCode", errorCode);
+        event.putString("errorMessage", errorMessage);
+        return event;
+    }
+
+    private void dispatchEvent(View view, String eventName, @Nullable WritableMap event) {
+        ReactContext reactContext = (ReactContext) view.getContext();
+        reactContext.getJSModule(RCTEventEmitter.class).receiveEvent(view.getId(), eventName, event);
+    }
+}
+

package/android/src/main/java/com/adwhalesdkreactnative/RNAdWhaleMediationInterstitialAd.java

@@ -0,0 +1,134 @@
+package com.adwhalesdkreactnative;
+
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.UiThreadUtil;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.facebook.react.uimanager.events.RCTEventEmitter;
+
+import net.adwhale.sdk.mediation.ads.AdWhaleMediationInterstitialAd;
+import net.adwhale.sdk.mediation.ads.AdWhaleMediationInterstitialAdListener;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Old Architecture 를 사용한다.
+ * JS <--> 네이티브 모듈 간 왕복 호출이 많지도 않고 성능 상 TurboModule이 꼭 필요하진 않음
+ */
+public class RNAdWhaleMediationInterstitialAd extends ReactContextBaseJavaModule implements AdWhaleMediationInterstitialAdListener {
+
+    public static final String REACT_CLASS_NAME = RNAdWhaleMediationInterstitialAd.class.getSimpleName();
+    private AdWhaleMediationInterstitialAd adWhaleMediationInterstitialAd;
+    private String placementUid;
+
+    public RNAdWhaleMediationInterstitialAd(ReactApplicationContext context) {
+        super(context);
+    }
+
+    @NonNull
+    @Override
+    public String getName() {
+        return REACT_CLASS_NAME;
+    }
+
+    @ReactMethod
+    public void loadAd(String placementUid) {
+        Log.e(REACT_CLASS_NAME, ".loadAd()");
+      this.placementUid = placementUid;
+        adWhaleMediationInterstitialAd = new AdWhaleMediationInterstitialAd(placementUid);
+        adWhaleMediationInterstitialAd.setAdWhaleMediationInterstitialAdListener(this);
+
+        UiThreadUtil.runOnUiThread(() -> {
+            adWhaleMediationInterstitialAd.loadAd();
+        });
+    }
+
+    @ReactMethod
+    public void showAd() {
+        Log.e(REACT_CLASS_NAME, "showAd()");
+        if (adWhaleMediationInterstitialAd == null) {
+            Log.e(REACT_CLASS_NAME, "adWhaleMediationInterstitialAd is null");
+            return;
+        }
+
+        UiThreadUtil.runOnUiThread(() -> {
+            adWhaleMediationInterstitialAd.showAd();
+        });
+    }
+
+    @Override
+    public void onAdLoaded() {
+        Log.i(REACT_CLASS_NAME, "onAdLoaded()");
+        sendEvent("onInterstitialAdLoaded", null);
+
+    }
+
+    @Override
+    public void onAdLoadFailed(int statusCode, String message) {
+        Log.i(REACT_CLASS_NAME, "onAdLoadFailed(" + statusCode + ", " + message + ")");
+        WritableMap params = Arguments.createMap();
+        params.putInt("statusCode", statusCode);
+        params.putString("message", message);
+        sendEvent("onInterstitialAdLoadFailed", params);
+    }
+
+    @Override
+    public void onAdShowed() {
+        Log.i(REACT_CLASS_NAME, "onAdShowed()");
+        sendEvent("onInterstitialAdShowed", null);
+    }
+
+    @Override
+    public void onAdShowFailed(int statusCode, String message) {
+        Log.i(REACT_CLASS_NAME, "onAdShowFailed(" + statusCode + ", " + message + ")");
+        WritableMap params = Arguments.createMap();
+        params.putInt("statusCode", statusCode);
+        params.putString("message", message);
+        sendEvent("onInterstitialAdShowFailed", params);
+    }
+
+    @Override
+    public void onAdClosed() {
+        Log.i(REACT_CLASS_NAME, "onAdClosed()");
+        sendEvent("onInterstitialAdClosed", null);
+    }
+
+    @Override
+    public void onAdClicked() {
+        Log.i(REACT_CLASS_NAME, "onAdClicked()");
+        sendEvent("onInterstitialAdClicked", null);
+    }
+
+    @Nullable
+    @Override
+    public Map<String, Object> getConstants() {
+        final Map<String, Object> constants = new HashMap<>();
+        return constants;
+    }
+
+    private void sendEvent(String eventName, @Nullable WritableMap params) {
+        getReactApplicationContext()
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                .emit(eventName, params);
+    }
+
+    @ReactMethod
+    public void addListener(String eventName) {
+        //TODO NOTHING
+    }
+
+     @ReactMethod
+     public void removeListeners(Integer count) {
+        //TODO NOTHING
+     }
+}