> ## 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>
  このキャッシュ構造のため、Ad Controlコンソールでクリエイティブを**一時停止**しても、各ユーザーデバイスのキャッシュが更新されるまでは、すでにキャッシュされているクリエイティブが表示される場合があります。クリエイティブの一時停止や差し替えがユーザーに反映されるまで時間がかかる可能性があることを運用計画に織り込んでください。
</Warning>

***

## 広告とロゴのサイズ

スプラッシュ広告は決まった領域を使用します：

* **ロゴ領域**：288dp × 288dp（画面中央）
* **広告領域**：360dp × 270dp（画面下部）
* 広告は画面下部に表示され、上部にはアプリロゴが配置されます

***

## 実装方法

スプラッシュ広告は、アプリの要件に応じて2つの方法で実装できます：

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`をランチャーアクティビティとして設定します。

```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>
  実際のリリース時には必ずAdropコンソールで作成した実際のユニット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の完全修飾名を確認（例：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="/ja/sdk/android/interstitial">
    画面遷移時にフルスクリーン広告を表示
  </Card>

  <Card title="バナー広告" href="/ja/sdk/android/banner">
    バナー広告を実装
  </Card>

  <Card title="ネイティブ広告" href="/ja/sdk/android/native">
    カスタムデザインのネイティブ広告
  </Card>

  <Card title="リワード広告" href="/ja/sdk/android/rewarded">
    ユーザーリワードを提供
  </Card>
</CardGroup>