โฆษณาเปิดแอป

คู่มือนี้มีไว้สำหรับผู้เผยแพร่โฆษณาที่ผสานรวมโฆษณาเปิดแอปโดยใช้ SDK โฆษณาในอุปกรณ์เคลื่อนที่

โฆษณาเปิดแอปเป็นรูปแบบโฆษณาพิเศษที่มีไว้สำหรับผู้เผยแพร่โฆษณาที่ต้องการสร้างรายได้ หน้าจอโหลดแอป โฆษณาเปิดแอปสามารถปิดได้ทุกเมื่อ และออกแบบมาเพื่อ แสดงเมื่อผู้ใช้นำแอปของคุณไปไว้เบื้องหน้า

หมายเหตุ: รูปแบบที่เฉพาะเจาะจงอาจแตกต่างกันไปตามภูมิภาค

โฆษณาเปิดแอปจะแสดงพื้นที่การสร้างแบรนด์ขนาดเล็กโดยอัตโนมัติเพื่อให้ผู้ใช้ทราบว่าตนอยู่ในพื้นที่ แอปของคุณ ต่อไปนี้คือตัวอย่างลักษณะของโฆษณาเปิดแอป

ข้อกำหนดเบื้องต้น

• ทำตามคู่มือเริ่มต้นใช้งานจนจบ

ทดสอบด้วยโฆษณาทดสอบเสมอ

เมื่อสร้างและทดสอบแอป โปรดใช้โฆษณาทดสอบแทนโฆษณาเวอร์ชันที่ใช้งานจริง หากไม่ดำเนินการ บัญชีจะถูกระงับ

วิธีที่ง่ายที่สุดในการโหลดโฆษณาทดสอบคือการใช้รหัสหน่วยโฆษณาทดสอบเฉพาะสําหรับโฆษณาแบบเปิดในแอป ดังนี้

/21775744923/example/app-open

โดยได้รับการกำหนดค่าเป็นพิเศษให้ส่งคืนโฆษณาทดสอบสำหรับทุกคำขอ โดยคุณจะ นำไปใช้ในแอปของคุณเองขณะเขียนโค้ด ทดสอบ และแก้ไขข้อบกพร่องได้ฟรี ทำ อย่าลืมแทนที่ด้วยรหัสหน่วยโฆษณาของคุณเองก่อนที่จะเผยแพร่แอป

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับวิธีการทำงานของโฆษณาทดสอบของ Google Mobile Ads SDK โปรดดู เปิดใช้โฆษณาทดสอบ

ขยายคลาสแอปพลิเคชัน

สร้างชั้นเรียนใหม่ที่ขยายชั้นเรียน Application และเพิ่มรายการต่อไปนี้ เพื่อเริ่มต้นใช้งาน Google Mobile Ads SDK เมื่อแอปของคุณเริ่มทำงาน

Java

/** Application class that initializes, loads and show ads when activities change states. */
public class MyApplication extends Application {

  @Override
  public void onCreate() {
    super.onCreate();
    new Thread(
            () -> {
              // Initialize the Google Mobile Ads SDK on a background thread.
              MobileAds.initialize(this, initializationStatus -> {});
            })
        .start();
  }
}

Kotlin

/** Application class that initializes, loads and show ads when activities change states. */
class MyApplication : Application() {

  override fun onCreate() {
    super.onCreate()
    val backgroundScope = CoroutineScope(Dispatchers.IO)
    backgroundScope.launch {
      // Initialize the Google Mobile Ads SDK on a background thread.
      MobileAds.initialize(this@MyApplication) {}
    }
  }
}

การดำเนินการนี้จะเริ่มต้น SDK และแสดงโครงสร้างสำหรับใช้ลงทะเบียนในภายหลัง สำหรับกิจกรรมที่ทำงานอยู่เบื้องหน้าของแอป

ถัดไป ให้เพิ่มรหัสต่อไปนี้ลงใน AndroidManifest.xml ของคุณ:

<!-- TODO: Update to reference your actual package name. -->
<application
    android:name="com.google.android.gms.example.appopendemo.MyApplication" ...>
...
</application>

ใช้งานองค์ประกอบด้านสาธารณูปโภค

โฆษณาของคุณควรแสดงอย่างรวดเร็ว จึงควรโหลดโฆษณาก่อนที่คุณจะต้อง แสดง วิธีนี้จะทำให้คุณมีโฆษณาพร้อมแสดงผลทันทีที่ผู้ใช้ป้อน ในแอปของคุณ

ใช้คอมโพเนนต์ยูทิลิตี AppOpenAdManager เพื่อสร้างคำขอโฆษณาก่อน เมื่อต้องการแสดงโฆษณา

Java

public class MyApplication extends Application {
  // ...
  /** Inner class that loads and shows app open ads. */
  private class AppOpenAdManager {
    private static final String LOG_TAG = "AppOpenAdManager";
    private static final String AD_UNIT_ID = "/21775744923/example/app-open";

    private AppOpenAd appOpenAd = null;
    private boolean isLoadingAd = false;
    private boolean isShowingAd = false;

    /** Constructor. */
    public AppOpenAdManager() {}

    /** Request an ad. */
    private void loadAd(Context context) {
      // We will implement this later.
    }

    /** Check if ad exists and can be shown. */
    private boolean isAdAvailable() {
      return appOpenAd != null;
    }
  }
}

Kotlin

private const val String LOG_TAG = "AppOpenAdManager"
private const val String AD_UNIT_ID = "/21775744923/example/app-open"

public class MyApplication extends Application {
  // ...
  /** Inner class that loads and shows app open ads. */
  private inner class AppOpenAdManager {
    private var appOpenAd: AppOpenAd? = null
    private var isLoadingAd = false
    var isShowingAd = false

    /** Request an ad. */
    fun loadAd(context: Context) {
      // We will implement this later.
    }

    /** Check if ad exists and can be shown. */
    private fun isAdAvailable(): Boolean {
      return appOpenAd != null
    }
  }
}

เมื่อคุณมีคลาสยูทิลิตีแล้ว คุณสามารถสร้างอินสแตนซ์ได้ใน MyApplication ชั้นเรียน:

Java

public class MyApplication extends Application {

  private AppOpenAdManager appOpenAdManager;

  @Override
  public void onCreate() {
    super.onCreate();
    new Thread(
            () -> {
              // Initialize the Google Mobile Ads SDK on a background thread.
              MobileAds.initialize(this, initializationStatus -> {});
            })
        .start();
    appOpenAdManager = new AppOpenAdManager(this);
  }
}

Kotlin

class MyApplication : Application() {

  private lateinit var appOpenAdManager: AppOpenAdManager

  override fun onCreate() {
    super.onCreate()
    val backgroundScope = CoroutineScope(Dispatchers.IO)
    backgroundScope.launch {
      // Initialize the Google Mobile Ads SDK on a background thread.
      MobileAds.initialize(this@MyApplication) {}
    }
    appOpenAdManager = AppOpenAdManager()
  }
}

โหลดโฆษณา

ขั้นตอนถัดไปคือการกรอกข้อมูลในloadAd() callback และจัดการการโหลดโฆษณา

Java

private class AppOpenAdManager {
  // ...
  /** Request an ad. */
  public void loadAd(Context context) {
    // Do not load ad if there is an unused ad or one is already loading.
    if (isLoadingAd || isAdAvailable()) {
      return;
    }

    isLoadingAd = true;
    AdRequest request = new AdRequest.Builder().build();
    AppOpenAd.load(
        context, AD_UNIT_ID, request,
        AppOpenAd.APP_OPEN_AD_ORIENTATION_PORTRAIT,
        new AppOpenAdLoadCallback() {
          @Override
          public void onAdLoaded(AppOpenAd ad) {
            // Called when an app open ad has loaded.
            Log.d(LOG_TAG, "Ad was loaded.");
            appOpenAd = ad;
            isLoadingAd = false;
            loadTime = (new Date()).getTime();
          }

          @Override
          public void onAdFailedToLoad(LoadAdError loadAdError) {
            // Called when an app open ad has failed to load.
            Log.d(LOG_TAG, loadAdError.getMessage());
            isLoadingAd = false;
          }
        });
  }
  // ...
}

Kotlin

private inner class AppOpenAdManager {
  // ...
  /** Request an ad. */
  fun loadAd(context: Context) {
    // Do not load ad if there is an unused ad or one is already loading.
    if (isLoadingAd || isAdAvailable()) {
      return
    }

    isLoadingAd = true
    val request = AdRequest.Builder().build()
    AppOpenAd.load(
        context, AD_UNIT_ID, request,
        AppOpenAd.APP_OPEN_AD_ORIENTATION_PORTRAIT,
        object : AppOpenAdLoadCallback() {

          override fun onAdLoaded(ad: AppOpenAd) {
            // Called when an app open ad has loaded.
            Log.d(LOG_TAG, "Ad was loaded.")
            appOpenAd = ad
            isLoadingAd = false
            loadTime = Date().time
          }

          override fun onAdFailedToLoad(loadAdError: LoadAdError) {
            // Called when an app open ad has failed to load.
            Log.d(LOG_TAG, loadAdError.message)
            isLoadingAd = false;
          }
        })
  }
  // ...
}

แสดงโฆษณาและจัดการเหตุการณ์ Callback แบบเต็มหน้าจอ

การใช้งานโฆษณาเปิดแอปที่พบบ่อยที่สุดคือการพยายามแสดงโฆษณาเปิดแอป ใกล้กับการเปิดแอป ให้เริ่มเนื้อหาแอปหากโฆษณายังไม่พร้อม และโหลดโฆษณาอื่นล่วงหน้า สำหรับโอกาสการเปิดแอปครั้งต่อไป โปรดดู หลักเกณฑ์สำหรับโฆษณาเปิดแอป เพื่อดูตัวอย่างการติดตั้งใช้งาน

โค้ดต่อไปนี้แสดงวิธีแสดงแล้วโหลดโฆษณาซ้ำในภายหลัง

Java

public class MyApplication extends Application {
  // ...
  /** Interface definition for a callback to be invoked when an app open ad is complete. */
  public interface OnShowAdCompleteListener {
    void onShowAdComplete();
  }

  private class AppOpenAdManager {
    // ...

    /** Shows the ad if one isn't already showing. */
    public void showAdIfAvailable(
        @NonNull final Activity activity,
        @NonNull OnShowAdCompleteListener onShowAdCompleteListener){
      // If the app open ad is already showing, do not show the ad again.
      if (isShowingAd) {
        Log.d(LOG_TAG, "The app open ad is already showing.");
        return;
      }

      // If the app open ad is not available yet, invoke the callback then load the ad.
      if (!isAdAvailable()) {
        Log.d(LOG_TAG, "The app open ad is not ready yet.");
        onShowAdCompleteListener.onShowAdComplete();
        loadAd(activity);
        return;
      }

      appOpenAd.setFullScreenContentCallback(
          new FullScreenContentCallback() {

            @Override
            public void onAdDismissedFullScreenContent() {
              // Called when fullscreen content is dismissed.
              // Set the reference to null so isAdAvailable() returns false.
              Log.d(LOG_TAG, "Ad dismissed fullscreen content.");
              appOpenAd = null;
              isShowingAd = false;

              onShowAdCompleteListener.onShowAdComplete();
              loadAd(activity);
            }

            @Override
            public void onAdFailedToShowFullScreenContent(AdError adError) {
              // Called when fullscreen content failed to show.
              // Set the reference to null so isAdAvailable() returns false.
              Log.d(LOG_TAG, adError.getMessage());
              appOpenAd = null;
              isShowingAd = false;

              onShowAdCompleteListener.onShowAdComplete();
              loadAd(activity);
            }

            @Override
            public void onAdShowedFullScreenContent() {
              // Called when fullscreen content is shown.
              Log.d(LOG_TAG, "Ad showed fullscreen content.");
            }
          });
      isShowingAd = true;
      appOpenAd.show(activity);
    }
    // ...
  }
}

Kotlin

class MyApplication : Application() {
  // ...
  /** Interface definition for a callback to be invoked when an app open ad is complete. */
  interface OnShowAdCompleteListener {
    fun onShowAdComplete()
  }

  private inner class AppOpenAdManager {
    // ...

    /** Shows the ad if one isn't already showing. */
    fun showAdIfAvailable(
        activity: Activity,
        onShowAdCompleteListener: OnShowAdCompleteListener) {
      // If the app open ad is already showing, do not show the ad again.
      if (isShowingAd) {
        Log.d(LOG_TAG, "The app open ad is already showing.")
        return
      }

      // If the app open ad is not available yet, invoke the callback then load the ad.
      if (!isAdAvailable()) {
        Log.d(LOG_TAG, "The app open ad is not ready yet.")
        onShowAdCompleteListener.onShowAdComplete()
        loadAd(activity)
        return
      }

      appOpenAd?.setFullScreenContentCallback(
          object : FullScreenContentCallback() {

            override fun onAdDismissedFullScreenContent() {
              // Called when full screen content is dismissed.
              // Set the reference to null so isAdAvailable() returns false.
              Log.d(LOG_TAG, "Ad dismissed fullscreen content.")
              appOpenAd = null
              isShowingAd = false

              onShowAdCompleteListener.onShowAdComplete()
              loadAd(activity)
            }

            override fun onAdFailedToShowFullScreenContent(adError: AdError) {
              // Called when fullscreen content failed to show.
              // Set the reference to null so isAdAvailable() returns false.
              Log.d(LOG_TAG, adError.message)
              appOpenAd = null
              isShowingAd = false

              onShowAdCompleteListener.onShowAdComplete()
              loadAd(activity)
            }

            override fun onAdShowedFullScreenContent() {
              // Called when fullscreen content is shown.
              Log.d(LOG_TAG, "Ad showed fullscreen content.")
            }
          })
      isShowingAd = true
      appOpenAd?.show(activity)
    }
    // ...
  }
}

FullScreenContentCallback จะจัดการเหตุการณ์ต่างๆ เช่น เมื่อโฆษณาแสดง ไม่แสดง หรือถูกปิด

ประเด็นหลัก: หากผู้ใช้กลับมาที่แอปของคุณหลังจากออกจากแอป การคลิก โฆษณาเปิดแอป ก็ต้องตรวจสอบว่าไม่ได้ ด้วยโฆษณาเปิดแอปอีกรายการหนึ่ง

พิจารณาการหมดอายุของโฆษณา

ประเด็นสำคัญ: โฆษณาเปิดแอปจะหมดเวลาหลังจากผ่านไป 4 ชั่วโมง โฆษณาแสดงมากกว่า 4 ชั่วโมงหลังจากส่งคำขอจะใช้งานไม่ได้อีกต่อไปและอาจไม่สร้างรายได้

เพิ่มเมธอดลงใน AppOpenAdManager เพื่อให้มั่นใจว่าคุณจะไม่แสดงโฆษณาที่หมดอายุแล้ว ที่ใช้ตรวจสอบว่าข้อมูลอ้างอิงโฆษณาโหลดมานานเท่าใดแล้ว จากนั้นให้ใช้ ในการตรวจสอบว่าโฆษณายังคงใช้ได้หรือไม่

Java

private class AppOpenAdManager {
  // ...
  /** Keep track of the time an app open ad is loaded to ensure you don't show an expired ad. */
  private long loadTime = 0;

  // ...

  /** Utility method to check if ad was loaded more than n hours ago. */
  private boolean wasLoadTimeLessThanNHoursAgo(long numHours) {
    long dateDifference = (new Date()).getTime() - this.loadTime;
    long numMilliSecondsPerHour = 3600000;
    return (dateDifference < (numMilliSecondsPerHour * numHours));
  }

  /** Check if ad exists and can be shown. */
  public boolean isAdAvailable() {
    return appOpenAd != null && wasLoadTimeLessThanNHoursAgo(4);
  }
}

Kotlin

private inner class AppOpenAdManager {
  // ...
  /** Keep track of the time an app open ad is loaded to ensure you don't show an expired ad. */
  private var loadTime: Long = 0;

  // ...

  /** Utility method to check if ad was loaded more than n hours ago. */
  private fun wasLoadTimeLessThanNHoursAgo(numHours: Long): Boolean {
    val dateDifference: Long = Date().time - loadTime
    val numMilliSecondsPerHour: Long = 3600000
    return dateDifference < numMilliSecondsPerHour * numHours
  }

  /** Check if ad exists and can be shown. */
  private fun isAdAvailable(): Boolean {
    return appOpenAd != null && wasLoadTimeLessThanNHoursAgo(4)
  }
}

ติดตามกิจกรรมปัจจุบัน

คุณต้องมีบริบทActivityจึงจะแสดงโฆษณาได้ เพื่อติดตามเหตุการณ์สำคัญๆ กิจกรรมในปัจจุบันที่ใช้ ลงทะเบียน และติดตั้งใช้งาน Application.ActivityLifecycleCallbacks

Java

public class MyApplication extends Application implements ActivityLifecycleCallbacks {

  private Activity currentActivity;

  @Override
  public void onCreate() {
    super.onCreate();
    this.registerActivityLifecycleCallbacks(this);
    // ...
  }

  /** ActivityLifecycleCallback methods. */
  @Override
  public void onActivityCreated(Activity activity, Bundle savedInstanceState) {}

  @Override
  public void onActivityStarted(Activity activity) {
    currentActivity = activity
  }

  @Override
  public void onActivityResumed(Activity activity) {}

  @Override
  public void onActivityStopped(Activity activity) {}

  @Override
  public void onActivityPaused(Activity activity) {}

  @Override
  public void onActivitySaveInstanceState(Activity activity, Bundle bundle) {}

  @Override
  public void onActivityDestroyed(Activity activity) {}
}

Kotlin

class MyApplication : Application(), Application.ActivityLifecycleCallbacks {

  private var currentActivity: Activity? = null

  override fun onCreate() {
    super.onCreate()
    registerActivityLifecycleCallbacks(this)
    // ...
  }

  /** ActivityLifecycleCallback methods. */
  override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {}

  override fun onActivityStarted(activity: Activity) {
    currentActivity = activity
  }

  override fun onActivityResumed(activity: Activity) {}

  override fun onActivityPaused(activity: Activity) {}

  override fun onActivityStopped(activity: Activity) {}

  override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {}

  override fun onActivityDestroyed(activity: Activity) {}
}

registerActivityLifecycleCallbacks ช่วยให้คุณสามารถฟังเหตุการณ์ของ Activity ทั้งหมด ฟังเมื่อมีกิจกรรม เริ่มต้นและถูกทำลาย คุณจะสามารถติดตามการอ้างอิงถึง Activity ซึ่งคุณจะนำไปใช้ในการนำเสนอโฆษณาเปิดแอป

ฟังเหตุการณ์เบื้องหน้าของแอป

เพิ่มไลบรารีไปยังไฟล์ Gradle

หากต้องการรับการแจ้งเตือนเหตุการณ์เบื้องหน้าของแอป คุณต้องลงทะเบียน DefaultLifecycleObserver เพิ่มทรัพยากร Dependency ในไฟล์บิลด์ระดับแอปดังนี้

Kotlin

  dependencies {
    implementation("com.google.android.gms:play-services-ads:23.3.0")
    implementation("androidx.lifecycle:lifecycle-process:2.8.3")
  }

ดึงดูด

  dependencies {
    implementation 'com.google.android.gms:play-services-ads:23.3.0'
    implementation 'androidx.lifecycle:lifecycle-process:2.8.3'
  }

ใช้อินเทอร์เฟซผู้สังเกตการณ์วงจรชีวิต

คุณเฝ้าติดตามเหตุการณ์เบื้องหน้าได้โดยการติดตั้งใช้งาน อินเทอร์เฟซของ DefaultLifecycleObserver

ติดตั้งใช้งานเหตุการณ์ onStart เพื่อแสดงโฆษณาเปิดแอป

Java

public class MyApplication extends Application
    implements ActivityLifecycleCallbacks, LifecycleObserver {
  // ...
  @Override
  public void onCreate() {
    super.onCreate();
    this.registerActivityLifecycleCallbacks(this);
    new Thread(
            () -> {
              // Initialize the Google Mobile Ads SDK on a background thread.
              MobileAds.initialize(this, initializationStatus -> {});
            })
        .start();
    ProcessLifecycleOwner.get().getLifecycle().addObserver(this);
    appOpenAdManager = new AppOpenAdManager();
  }

  /** LifecycleObserver method that shows the app open ad when the app moves to foreground. */
  @OnLifecycleEvent(Event.ON_START)
  protected void onMoveToForeground() {
    // Show the ad (if available) when the app moves to foreground.
    appOpenAdManager.showAdIfAvailable(currentActivity);
  }

  /** Show the ad if one isn't already showing. */
  private void showAdIfAvailable(@NonNull final Activity activity) {
      showAdIfAvailable(
          activity,
          new OnShowAdCompleteListener() {
            @Override
            public void onShowAdComplete() {
              // Empty because the user will go back to the activity that shows the ad.
            }
          });
  }
}

Kotlin

class MyApplication : Application(),
    Application.ActivityLifecycleCallbacks, LifecycleObserver {
  // ...
  override fun onCreate() {
    super.onCreate()
    registerActivityLifecycleCallbacks(this)
    val backgroundScope = CoroutineScope(Dispatchers.IO)
    backgroundScope.launch {
      // Initialize the Google Mobile Ads SDK on a background thread.
      MobileAds.initialize(this@MyApplication) {}
    }
    ProcessLifecycleOwner.get().lifecycle.addObserver(this)
    appOpenAdManager = AppOpenAdManager()
  }

  /** LifecycleObserver method that shows the app open ad when the app moves to foreground. */
  @OnLifecycleEvent(Lifecycle.Event.ON_START)
  fun onMoveToForeground() {
    // Show the ad (if available) when the app moves to foreground.
    currentActivity?.let {
      appOpenAdManager.showAdIfAvailable(it)
    }
  }

  /** Show the ad if one isn't already showing. */
  fun showAdIfAvailable(activity: Activity) {
    showAdIfAvailable(
        activity,
        object : OnShowAdCompleteListener {
          override fun onShowAdComplete() {
            // Empty because the user will go back to the activity that shows the ad.
          }
        })
  }
}

Cold Start และหน้าจอกำลังโหลด

เอกสารประกอบนี้มีสมมติฐานว่าคุณจะแสดงโฆษณาเปิดแอปเฉพาะเมื่อผู้ใช้ เบื้องหน้าแอปของคุณเมื่อถูกระงับในหน่วยความจำ "Cold Start" เกิดขึ้นเมื่อ แอปของคุณเปิดขึ้นแต่ไม่ได้ถูกระงับในหน่วยความจำก่อนหน้านี้

ตัวอย่างของ Cold Start ได้แก่ เมื่อผู้ใช้เปิดแอปของคุณเป็นครั้งแรก เมื่อใช้ Cold Start จะไม่มีโฆษณาเปิดแอปที่โหลดไว้ก่อนหน้านี้ซึ่งพร้อมแสดงทันที ระยะเวลาระหว่างที่คุณขอโฆษณาและรับโฆษณา อาจสร้างสถานการณ์ที่ผู้ใช้ สามารถใช้แอปของคุณเป็นเวลาสั้นๆ โดยโฆษณาที่อยู่นอกบริบท ไม่ควรใช้วิธีนี้เนื่องจากเป็นประสบการณ์ที่ไม่ดีสำหรับผู้ใช้

วิธีที่ควรใช้โฆษณาเปิดแอปเมื่อ Cold Start คือการใช้หน้าจอการโหลด เพื่อโหลดเนื้อหาเกมหรือแอป และแสดงเฉพาะโฆษณาจากการโหลดเท่านั้น บนหน้าจอ หากแอปโหลดเสร็จแล้วและส่งผู้ใช้ไปยังหน้าหลัก ในเนื้อหาของแอป คุณต้องแสดงโฆษณานั้นๆ

ประเด็นสำคัญ: เพื่อโหลดชิ้นงานแอปต่อไปในขณะที่โฆษณาเปิดแอป ให้โหลดเนื้อหาในชุดข้อความเบื้องหลังเสมอ

แนวทางปฏิบัติแนะนำ

โฆษณาเปิดแอปช่วยให้คุณสร้างรายได้จากหน้าจอโหลดของแอปเมื่อแอปเริ่ม เปิดตัวและระหว่างการเปลี่ยนแอป แต่ควรให้แนวทางปฏิบัติแนะนำ เพื่อให้ผู้ใช้เพลิดเพลินไปกับการใช้แอปของคุณ คุณควรทำดังนี้

• แสดงโฆษณาเปิดแอปแรกของคุณหลังจากที่ผู้ใช้ใช้แอปของคุณ 2-3 ครั้ง
• แสดงโฆษณาเปิดแอปในช่วงเวลาที่ผู้ใช้จะต้องรอให้แอปโหลด
• หากคุณมีหน้าจอการโหลดใต้โฆษณาเปิดแอป และหน้าจอการโหลด เสร็จสมบูรณ์ก่อนที่จะปิดโฆษณา คุณอาจต้อง หน้าจอการโหลดในเมธอด onAdDismissedFullScreenContent()

ตัวอย่างใน GitHub

• ตัวอย่างโฆษณาเปิดแอป Java | Kotlin

ขั้นตอนถัดไป

สำรวจหัวข้อต่อไปนี้

• ความเป็นส่วนตัวของผู้ใช้
• การเริ่มต้น SDK และการโหลดโฆษณาที่ได้รับการเพิ่มประสิทธิภาพ (เบต้า)