> ## Documentation Index
> Fetch the complete documentation index at: https://docs.adrop.io/llms.txt
> Use this file to discover all available pages before exploring further.

# 스플래시 광고

> Android 앱에서 스플래시 광고를 구현하는 방법을 안내합니다.

## 개요

스플래시 광고(Splash Ad)는 앱 실행 시 스플래시 화면에 표시되는 광고입니다. 앱의 로고와 함께 광고가 표시되어 자연스러운 사용자 경험을 제공합니다.

### 특징

* 앱 시작 시 자연스러운 광고 노출
* 앱 로고와 함께 브랜드 이미지 유지
* 360dp × 270dp 광고 영역, 288dp × 288dp 로고 영역
* 이미지 광고 지원
* Android 12+ 시스템 스플래시 스크린 지원

<Note>
  개발 환경에서는 테스트 유닛 ID를 사용하세요: `PUBLIC_TEST_UNIT_ID_SPLASH`
</Note>

***

## 캐싱 동작

스플래시 광고는 앱 실행과 동시에 즉시 노출되어야 하므로, SDK가 광고를 디바이스에 미리 캐싱하는 구조로 동작합니다. 다음 실행 시점에는 캐싱된 소재가 먼저 노출되고, 동시에 새 광고를 백그라운드로 요청하여 다음 실행에 사용할 캐시를 갱신합니다.

<Warning>
  이 캐싱 구조 때문에, 애드컨트롤 콘솔에서 소재를 **일시정지**하더라도 각 사용자 디바이스의 캐시가 갱신되기 전까지는 이미 캐싱된 소재가 노출될 수 있습니다. 소재 일시정지나 교체가 사용자에게 반영되기까지 시간이 소요될 수 있다는 점을 운영 계획에 반영하세요.
</Warning>

***

## 광고 및 로고 크기

스플래시 광고는 정해진 영역을 사용합니다:

* **로고 영역**: 288dp × 288dp (화면 중앙)
* **광고 영역**: 360dp × 270dp (화면 하단)
* 광고는 화면 하단에 표시되며, 상단에는 앱 로고가 배치됩니다

***

## 구현 방법

스플래시 광고는 앱의 요구사항에 따라 두 가지 방법으로 구현할 수 있습니다:

1. **AdropSplashAd 사용** - 시스템 스플래시 스크린과 통합 (Android 12+)
2. **AdropSplashAdView 사용** - 커스텀 스플래시 화면 구성

***

## 방법 1: AdropSplashAd 사용 (시스템 스플래시 통합)

Android 12 (API 31) 이상에서 시스템 스플래시 스크린과 통합하는 방법입니다. `AdropSplashAdActivity`가 스플래시 화면을 자동으로 관리합니다.

### 1단계: strings.xml 설정

`app/src/main/res/values/strings.xml` 파일에 다음 설정을 추가합니다.

```xml title="res/values/strings.xml" theme={null}
<resources>
    <!-- 앱 이름 -->
    <string name="app_name">My App</string>

    <!-- 스플래시 광고 유닛 ID -->
    <string name="adrop_splash_ad_unit_id" translatable="false">YOUR_SPLASH_UNIT_ID</string>

    <!-- 스플래시 종료 후 이동할 Activity -->
    <string name="adrop_splash_ad_next_activity" translatable="false">com.yourcompany.yourapp.MainActivity</string>
</resources>
```

<Note>
  테스트 시에는 `YOUR_SPLASH_UNIT_ID` 대신 `PUBLIC_TEST_UNIT_ID_SPLASH`를 사용하세요.
</Note>

### 2단계: 스플래시 로고 이미지 추가

앱 로고를 `res/drawable/` 폴더에 추가합니다.

```
app/src/main/res/drawable/splash_logo.png
```

권장 사이즈: 288dp × 288dp (@2x: 576px, @3x: 864px)

### 3단계: AndroidManifest.xml 설정

`AdropSplashAdActivity`를 launcher activity로 설정합니다.

```xml title="AndroidManifest.xml" theme={null}
<manifest xmlns:android="http://schemas.android.com/apk/res/android">
    <application
        android:name=".MyApplication"
        android:theme="@style/Theme.App">

        <!-- 스플래시 광고 Activity -->
        <activity
            android:name="io.adrop.ads.splash.AdropSplashAdActivity"
            android:theme="@style/Theme.App.Splash"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <!-- 메인 Activity (스플래시 종료 후 이동) -->
        <activity
            android:name=".MainActivity"
            android:exported="false" />

    </application>
</manifest>
```

<Warning>
  `AdropSplashAdActivity`의 `android:exported="true"` 설정이 필요합니다.
</Warning>

### 4단계: 스플래시 테마 설정

`res/values/themes.xml` 파일에 스플래시 테마를 추가합니다.

```xml title="res/values/themes.xml" theme={null}
<resources>
    <!-- 앱 기본 테마 -->
    <style name="Theme.App" parent="Theme.Material3.DayNight.NoActionBar">
        <!-- 앱 테마 설정 -->
    </style>

    <!-- 스플래시 테마 (Android 12+) -->
    <style name="Theme.App.Splash" parent="Theme.SplashScreen">
        <item name="windowSplashScreenBackground">@color/white</item>
        <item name="windowSplashScreenAnimatedIcon">@drawable/splash_logo</item>
        <item name="postSplashScreenTheme">@style/Theme.App</item>
    </style>
</resources>
```

<Note>
  Android 12 미만 기기에서는 시스템 스플래시가 표시되지 않고 바로 `AdropSplashAdActivity`가 표시됩니다.
</Note>

### 5단계: 레이아웃 커스터마이징 (선택 사항)

기본 레이아웃을 사용하지 않고 커스텀 레이아웃을 원할 경우, 앱의 `res/layout/` 폴더에 `activity_adrop_splash_ad.xml` 파일을 생성합니다.

```xml title="res/layout/activity_adrop_splash_ad.xml" theme={null}
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="#ffffff"
    android:paddingHorizontal="24dp"
    android:fitsSystemWindows="true">

    <!-- 앱 로고 (중앙) -->
    <ImageView
        android:src="@drawable/splash_logo"
        android:layout_width="288dp"
        android:layout_height="288dp"
        android:scaleType="fitXY"
        android:layout_centerInParent="true"/>

    <!-- 광고 영역 (하단) - 필수 -->
    <ImageView
        android:id="@+id/adrop_splash_ad_image"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerHorizontal="true"
        android:layout_alignParentBottom="true"/>
</RelativeLayout>
```

<Warning>
  `android:id="@+id/adrop_splash_ad_image"`를 가진 `ImageView`는 필수입니다. 이 뷰에 광고가 표시됩니다.
</Warning>

### 6단계: Application에서 SDK 초기화

```kotlin title="MyApplication.kt" theme={null}
import android.app.Application
import io.adrop.ads.Adrop

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()

        // SDK 초기화
        Adrop.initialize(this, production = false)
    }
}
```

### 7단계: AdropSplashAd 리스너 구현 (선택 사항)

스플래시 광고 이벤트를 수신하려면 `Application` 클래스에서 리스너를 설정합니다.

<CodeGroup>
  ```kotlin Kotlin theme={null}
  import android.app.Application
  import io.adrop.ads.Adrop
  import io.adrop.ads.splash.AdropSplashAd
  import io.adrop.ads.splash.AdropSplashAdListener
  import io.adrop.ads.model.AdropErrorCode

  class MyApplication : Application() {
      private lateinit var splashAd: AdropSplashAd

      override fun onCreate() {
          super.onCreate()

          // SDK 초기화
          Adrop.initialize(this, production = false)

          // 스플래시 광고 설정
          splashAd = AdropSplashAd(this) { splashAd ->
              // shouldSkip: 스플래시 광고를 건너뛸지 결정
              // true 반환 시 광고를 표시하지 않고 바로 메인 화면으로 이동
              checkShouldSkipSplash()
          }

          splashAd.splashAdListener = object : AdropSplashAdListener {
              override fun onAdReceived(ad: AdropSplashAd) {
                  println("스플래시 광고 수신 성공")
              }

              override fun onAdFailedToReceive(ad: AdropSplashAd, errorCode: AdropErrorCode) {
                  println("스플래시 광고 수신 실패: $errorCode")
              }

              override fun onAdImpression(ad: AdropSplashAd) {
                  println("스플래시 광고 노출")
              }

              override fun onAdClose(ad: AdropSplashAd, impressed: Boolean) {
                  println("스플래시 광고 종료 - 노출됨: $impressed")
              }
          }
      }

      private fun checkShouldSkipSplash(): Boolean {
          // 예: 딥링크로 진입하거나 특정 조건에서 스플래시 건너뛰기
          // 푸시 알림으로 앱이 실행된 경우 등
          return false
      }
  }
  ```

  ```java Java theme={null}
  import android.app.Application;
  import io.adrop.ads.Adrop;
  import io.adrop.ads.splash.AdropSplashAd;
  import io.adrop.ads.splash.AdropSplashAdListener;
  import io.adrop.ads.model.AdropErrorCode;

  public class MyApplication extends Application {
      private AdropSplashAd splashAd;

      @Override
      public void onCreate() {
          super.onCreate();

          // SDK 초기화
          Adrop.INSTANCE.initialize(this, false, new String[]{});

          // 스플래시 광고 설정
          splashAd = new AdropSplashAd(this, ad -> checkShouldSkipSplash());

          splashAd.setSplashAdListener(new AdropSplashAdListener() {
              @Override
              public void onAdReceived(AdropSplashAd ad) {
                  System.out.println("스플래시 광고 수신 성공");
              }

              @Override
              public void onAdFailedToReceive(AdropSplashAd ad, AdropErrorCode errorCode) {
                  System.out.println("스플래시 광고 수신 실패: " + errorCode);
              }

              @Override
              public void onAdImpression(AdropSplashAd ad) {
                  System.out.println("스플래시 광고 노출");
              }

              @Override
              public void onAdClose(AdropSplashAd ad, boolean impressed) {
                  System.out.println("스플래시 광고 종료 - 노출됨: " + impressed);
              }
          });
      }

      private boolean checkShouldSkipSplash() {
          // 스플래시 광고를 건너뛸지 결정
          return false;
      }
  }
  ```
</CodeGroup>

### AdropSplashAd 프로퍼티

| 프로퍼티          | 타입        | 설명                    |
| ------------- | --------- | --------------------- |
| `unitId`      | `String`  | 광고 유닛 ID (읽기 전용)      |
| `creativeId`  | `String`  | 광고 크리에이티브 ID (읽기 전용)  |
| `isClosed`    | `Boolean` | 스플래시 광고 종료 여부 (읽기 전용) |
| `isDestroyed` | `Boolean` | 스플래시 광고 파기 여부 (읽기 전용) |

### AdropSplashAd 메서드

| 메서드         | 설명                                                         |
| ----------- | ---------------------------------------------------------- |
| `close()`   | 스플래시 광고를 즉시 종료하고 다음 화면으로 이동                                |
| `destroy()` | 리소스를 해제하고 라이프사이클 콜백을 해제합니다. 스플래시 광고가 더 이상 필요하지 않을 때 호출하세요. |

### shouldSkip 콜백

`AdropSplashAd` 생성자의 `shouldSkip` 콜백을 사용하여 특정 조건에서 스플래시 광고를 건너뛸 수 있습니다.

```kotlin theme={null}
val splashAd = AdropSplashAd(application) { splashAd ->
    // 푸시 알림으로 앱이 실행된 경우 스플래시 건너뛰기
    val isPushNotification = intent?.extras?.containsKey("push_notification") == true

    // 딥링크로 진입한 경우 스플래시 건너뛰기
    val hasDeepLink = intent?.data != null

    isPushNotification || hasDeepLink
}
```

<Note>
  `shouldSkip`이 `true`를 반환하면 스플래시 광고가 즉시 닫히고 다음 화면으로 이동합니다.
</Note>

### 스플래시 표시 시간 설정 (선택 사항)

기본 표시 시간(2초)을 변경하려면 `res/values/integers.xml` 파일을 생성하고 설정합니다.

```xml title="res/values/integers.xml" theme={null}
<resources>
    <!-- 광고 요청 타임아웃 (밀리초, 500~3000) -->
    <integer name="adrop_splash_ad_request_timeout">1000</integer>

    <!-- 광고 표시 시간 (밀리초, 500~3000) -->
    <integer name="adrop_splash_ad_max_timeout">2000</integer>
</resources>
```

<Note>
  설정 가능한 범위는 500ms \~ 3000ms입니다. 범위를 벗어난 값은 자동으로 보정됩니다.
</Note>

### 푸시 알림 딥링크 시 스플래시 건너뛰기 (선택 사항)

푸시 알림을 통해 앱이 실행될 때 딥링크가 있으면 스플래시 광고를 건너뛰도록 설정할 수 있습니다.

```xml title="res/values/bools.xml" theme={null}
<resources>
    <!-- 푸시 알림 딥링크 시 스플래시 건너뛰기 -->
    <bool name="adrop_splash_ad_skip_push_notification_clicked">true</bool>
</resources>
```

***

## 방법 2: AdropSplashAdView 사용 (커스텀 스플래시)

커스텀 스플래시 화면을 직접 구성하고 싶을 때 사용합니다. 자체 스플래시 Activity를 만들고 `AdropSplashAdView`를 배치합니다.

### 1단계: 레이아웃 작성

```xml title="activity_splash.xml" theme={null}
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="#ffffff"
    android:padding="24dp">

    <!-- 앱 로고 -->
    <ImageView
        android:id="@+id/logo"
        android:layout_width="288dp"
        android:layout_height="288dp"
        android:layout_centerInParent="true"
        android:src="@drawable/splash_logo"
        android:scaleType="fitXY"/>

    <!-- 스플래시 광고 컨테이너 -->
    <FrameLayout
        android:id="@+id/splash_ad_container"
        android:layout_width="match_parent"
        android:layout_height="270dp"
        android:layout_alignParentBottom="true"/>

</RelativeLayout>
```

### 2단계: SplashActivity 구현

<CodeGroup>
  ```kotlin Kotlin theme={null}
  import android.content.Intent
  import android.os.Bundle
  import android.widget.FrameLayout
  import androidx.appcompat.app.AppCompatActivity
  import io.adrop.ads.splash.AdropSplashAdView
  import io.adrop.ads.splash.AdropSplashAdViewListener
  import io.adrop.ads.model.AdropErrorCode

  class SplashActivity : AppCompatActivity() {
      private lateinit var splashAdView: AdropSplashAdView

      override fun onCreate(savedInstanceState: Bundle?) {
          super.onCreate(savedInstanceState)
          setContentView(R.layout.activity_splash)

          // 스플래시 광고 뷰 초기화
          splashAdView = AdropSplashAdView(
              context = this,
              unitId = "YOUR_SPLASH_UNIT_ID",
              adRequestTimeout = 1000L  // 광고 요청 타임아웃 (밀리초)
          )

          // 리스너 설정
          splashAdView.listener = object : AdropSplashAdViewListener {
              override fun onAdReceived(ad: AdropSplashAdView) {
                  println("스플래시 광고 수신 성공")
              }

              override fun onAdFailedToReceive(ad: AdropSplashAdView, errorCode: AdropErrorCode) {
                  println("스플래시 광고 수신 실패: $errorCode")
              }

              override fun onAdImpression(ad: AdropSplashAdView) {
                  println("스플래시 광고 노출")
              }

              override fun onAdClose(ad: AdropSplashAdView, impressed: Boolean) {
                  println("스플래시 광고 종료 - 노출됨: $impressed")
                  goToMainActivity()
              }
          }

          // 광고 로드 및 표시
          findViewById<FrameLayout>(R.id.splash_ad_container).addView(splashAdView)
          splashAdView.load()
      }

      private fun goToMainActivity() {
          startActivity(Intent(this, MainActivity::class.java))
          finish()
      }
  }
  ```

  ```java Java theme={null}
  import android.content.Intent;
  import android.os.Bundle;
  import android.widget.FrameLayout;
  import androidx.appcompat.app.AppCompatActivity;
  import io.adrop.ads.splash.AdropSplashAdView;
  import io.adrop.ads.splash.AdropSplashAdViewListener;
  import io.adrop.ads.model.AdropErrorCode;

  public class SplashActivity extends AppCompatActivity {
      private AdropSplashAdView splashAdView;

      @Override
      protected void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          setContentView(R.layout.activity_splash);

          // 스플래시 광고 뷰 초기화
          splashAdView = new AdropSplashAdView(
              this,
              "YOUR_SPLASH_UNIT_ID",
              1000L  // 광고 요청 타임아웃 (밀리초)
          );

          // 리스너 설정
          splashAdView.setListener(new AdropSplashAdViewListener() {
              @Override
              public void onAdReceived(AdropSplashAdView ad) {
                  System.out.println("스플래시 광고 수신 성공");
              }

              @Override
              public void onAdFailedToReceive(AdropSplashAdView ad, AdropErrorCode errorCode) {
                  System.out.println("스플래시 광고 수신 실패: " + errorCode);
              }

              @Override
              public void onAdImpression(AdropSplashAdView ad) {
                  System.out.println("스플래시 광고 노출");
              }

              @Override
              public void onAdClose(AdropSplashAdView ad, boolean impressed) {
                  System.out.println("스플래시 광고 종료 - 노출됨: " + impressed);
                  goToMainActivity();
              }
          });

          // 광고 로드 및 표시
          FrameLayout container = findViewById(R.id.splash_ad_container);
          container.addView(splashAdView);
          splashAdView.load();
      }

      private void goToMainActivity() {
          startActivity(new Intent(this, MainActivity.class));
          finish();
      }
  }
  ```
</CodeGroup>

### 3단계: AndroidManifest.xml 설정

```xml title="AndroidManifest.xml" theme={null}
<manifest xmlns:android="http://schemas.android.com/apk/res/android">
    <application>
        <!-- 커스텀 스플래시 Activity -->
        <activity
            android:name=".SplashActivity"
            android:theme="@style/Theme.App.Splash"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <!-- 메인 Activity -->
        <activity
            android:name=".MainActivity"
            android:exported="false" />
    </application>
</manifest>
```

### AdropSplashAdView 프로퍼티

| 프로퍼티         | 타입        | 설명                    |
| ------------ | --------- | --------------------- |
| `unitId`     | `String`  | 광고 유닛 ID (읽기 전용)      |
| `creativeId` | `String`  | 광고 크리에이티브 ID (읽기 전용)  |
| `isClosed`   | `Boolean` | 스플래시 광고 종료 여부 (읽기 전용) |
| `txId`       | `String`  | 거래 ID (읽기 전용)         |
| `campaignId` | `String`  | 캠페인 ID (읽기 전용)        |

### AdropSplashAdView 메서드

| 메서드         | 설명                                                               |
| ----------- | ---------------------------------------------------------------- |
| `load()`    | 광고를 로드하고 표시                                                      |
| `destroy()` | 리소스를 해제합니다 (타이머, 가시성 트래커, 리스너). 스플래시 광고 뷰가 더 이상 필요하지 않을 때 호출하세요. |

***

## 리스너

### AdropSplashAdListener

`AdropSplashAd`를 사용할 때의 리스너입니다.

| 메서드                                  | 필수     | 설명                |
| ------------------------------------ | ------ | ----------------- |
| `onAdReceived(ad)`                   | 선택     | 광고 수신 성공 시 호출     |
| `onAdFailedToReceive(ad, errorCode)` | 선택     | 광고 수신 실패 시 호출     |
| `onAdImpression(ad)`                 | 선택     | 광고 노출이 기록되었을 때 호출 |
| `onAdClose(ad, impressed)`           | **필수** | 스플래시 광고 종료 시 호출   |

### AdropSplashAdViewListener

`AdropSplashAdView`를 사용할 때의 리스너입니다.

| 메서드                                  | 필수     | 설명                              |
| ------------------------------------ | ------ | ------------------------------- |
| `onAdReceived(ad)`                   | 선택     | 광고 수신 성공 시 호출                   |
| `onAdFailedToReceive(ad, errorCode)` | 선택     | 광고 수신 실패 시 호출                   |
| `onAdImpression(ad)`                 | 선택     | 광고 노출이 기록되었을 때 호출               |
| `onAdClose(ad, impressed)`           | **필수** | 스플래시 광고 종료 시 호출. 메인 화면 전환 처리 필요 |

<Warning>
  `AdropSplashAdView`를 사용할 때는 `onAdClose` 메서드를 반드시 구현하여 메인 화면으로 전환 처리를 해야 합니다.
</Warning>

***

## impressed 파라미터

`onAdClose(ad, impressed)` 메서드의 `impressed` 파라미터는 광고가 실제로 노출되었는지 여부를 나타냅니다.

```kotlin theme={null}
override fun onAdClose(ad: AdropSplashAdView, impressed: Boolean) {
    if (impressed) {
        println("광고가 사용자에게 노출되었습니다")
        // 광고 노출 후 처리 로직
    } else {
        println("광고가 노출되지 않았습니다 (로드 실패 또는 스킵)")
        // 광고 미노출 처리 로직
    }

    // 메인 화면으로 전환
    goToMainActivity()
}
```

### impressed가 false인 경우

* 광고 로드 실패
* 네트워크 오류
* 사용자가 광고를 보기 전에 스킵
* 광고 인벤토리 부족

***

## 모범 사례

### 1. 적절한 타이머 설정

스플래시 광고는 너무 짧거나 길지 않게 표시해야 합니다.

```xml theme={null}
<!-- 권장 설정 -->
<integer name="adrop_splash_ad_request_timeout">1000</integer>  <!-- 1초 -->
<integer name="adrop_splash_ad_max_timeout">2000</integer>       <!-- 2초 -->
```

### 2. 로고 이미지 최적화

앱 로고는 적절한 크기로 준비하여 로딩 시간을 최소화하세요.

```
drawable-mdpi/splash_logo.png    (192px × 192px)
drawable-hdpi/splash_logo.png    (288px × 288px)
drawable-xhdpi/splash_logo.png   (384px × 384px)
drawable-xxhdpi/splash_logo.png  (576px × 576px)
drawable-xxxhdpi/splash_logo.png (768px × 768px)
```

### 3. 실패 처리

광고 로드 실패 시에도 앱이 정상적으로 시작되도록 처리하세요.

```kotlin theme={null}
override fun onAdFailedToReceive(ad: AdropSplashAdView, errorCode: AdropErrorCode) {
    println("광고 로드 실패: $errorCode")
    // 실패해도 메인 화면으로 전환
    goToMainActivity()
}
```

### 4. 테스트 환경 구분

개발과 배포 환경을 구분하여 테스트하세요.

```kotlin theme={null}
val splashUnitId = if (BuildConfig.DEBUG) {
    "PUBLIC_TEST_UNIT_ID_SPLASH"
} else {
    "YOUR_PRODUCTION_SPLASH_UNIT_ID"
}

// SDK 초기화
Adrop.initialize(application, production = !BuildConfig.DEBUG)
```

### 5. 메모리 누수 방지

Activity 종료 시 리스너를 정리하세요.

```kotlin theme={null}
override fun onDestroy() {
    splashAdView.destroy()
    super.onDestroy()
}
```

***

## 테스트

### 테스트 유닛 ID

개발 중에는 테스트 유닛 ID를 사용하세요.

```kotlin theme={null}
// 테스트 유닛 ID
val testUnitId = "PUBLIC_TEST_UNIT_ID_SPLASH"
```

<Warning>
  실제 배포 시에는 반드시 애드컨트롤 콘솔에서 생성한 실제 유닛 ID를 사용하세요. 테스트 유닛 ID로 배포하면 광고 수익이 발생하지 않습니다.
</Warning>

### 디버깅

광고 이벤트를 로그로 확인하세요.

```kotlin theme={null}
splashAdView.listener = object : AdropSplashAdViewListener {
    override fun onAdReceived(ad: AdropSplashAdView) {
        Log.d("AdropSplash", "광고 수신 성공")
        Log.d("AdropSplash", "  - unitId: ${ad.unitId}")
        Log.d("AdropSplash", "  - creativeId: ${ad.creativeId}")
    }

    override fun onAdFailedToReceive(ad: AdropSplashAdView, errorCode: AdropErrorCode) {
        Log.e("AdropSplash", "광고 수신 실패: $errorCode")
        Log.e("AdropSplash", "  - 네트워크 상태 확인")
        Log.e("AdropSplash", "  - 유닛 ID 확인: ${ad.unitId}")
    }

    override fun onAdImpression(ad: AdropSplashAdView) {
        Log.d("AdropSplash", "광고 노출")
        Log.d("AdropSplash", "  - txId: ${ad.txId}")
        Log.d("AdropSplash", "  - campaignId: ${ad.campaignId}")
    }

    override fun onAdClose(ad: AdropSplashAdView, impressed: Boolean) {
        Log.d("AdropSplash", "광고 종료")
        Log.d("AdropSplash", "  - impressed: $impressed")
        Log.d("AdropSplash", "  - isClosed: ${ad.isClosed}")
    }
}
```

***

## 문제 해결

<AccordionGroup>
  <Accordion title="스플래시 화면이 표시되지 않음">
    * AndroidManifest.xml에서 `AdropSplashAdActivity` 또는 커스텀 SplashActivity가 LAUNCHER로 설정되었는지 확인
    * `android:exported="true"` 설정 확인
    * SDK 초기화가 완료되었는지 확인 (Application 클래스)
    * `adrop_service.json` 파일이 `assets` 폴더에 있는지 확인
  </Accordion>

  <Accordion title="광고가 로드되지 않음">
    * 네트워크 연결 상태 확인
    * 유닛 ID가 올바른지 확인 (strings.xml 또는 코드)
    * 테스트 환경에서는 `production = false` 설정 확인
    * `onAdFailedToReceive` 에러 코드 확인
    * `adrop_service.json` 파일 내용이 올바른지 확인
  </Accordion>

  <Accordion title="메인 화면으로 전환되지 않음">
    * `adrop_splash_ad_next_activity` 설정이 올바른지 확인 (전체 패키지 경로)
    * `AdropSplashAdView` 사용 시 `onAdClose` 구현 확인
    * Activity의 full qualified name 확인 (예: com.myapp.MainActivity)
  </Accordion>

  <Accordion title="커스텀 레이아웃이 적용되지 않음">
    * 파일명이 정확히 `activity_adrop_splash_ad.xml`인지 확인
    * `android:id="@+id/adrop_splash_ad_image"` ID를 가진 ImageView가 있는지 확인
    * 앱을 클린 빌드 후 재실행 (Build > Clean Project > Rebuild Project)
  </Accordion>

  <Accordion title="Android 12 미만에서 시스템 스플래시가 보이지 않음">
    이는 정상입니다. Android 12 미만 기기에서는 시스템 스플래시 스크린이 지원되지 않으며, 바로 `AdropSplashAdActivity`가 표시됩니다.
  </Accordion>
</AccordionGroup>

***

## 다음 단계

<CardGroup cols={2}>
  <Card title="전면 광고" href="/ko/sdk/android/interstitial">
    화면 전환 시 전면 광고 표시하기
  </Card>

  <Card title="배너 광고" href="/ko/sdk/android/banner">
    배너 광고 구현하기
  </Card>

  <Card title="네이티브 광고" href="/ko/sdk/android/native">
    커스텀 디자인 네이티브 광고
  </Card>

  <Card title="보상형 광고" href="/ko/sdk/android/rewarded">
    사용자 리워드 제공하기
  </Card>
</CardGroup>