หน้านี้ได้รับการแปลโดย Cloud Translation API

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

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

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

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

ขั้นตอนสำคัญในภาพรวมมีดังนี้

ขยายคลาส Application เพื่อเริ่มต้นใช้งาน SDK โฆษณาในอุปกรณ์เคลื่อนที่ของ Google
สร้างคลาสยูทิลิตีที่โหลดโฆษณาก่อนที่คุณจะต้องแสดงโฆษณา
โหลดโฆษณา
ฟังภาษาActivityLifecycleCallbacks.
แสดงโฆษณาและจัดการ Callback
ใช้งานและลงทะเบียนอินเทอร์เฟซ LifecycleObserver เพื่อแสดงโฆษณาระหว่างเหตุการณ์ที่ทำงานอยู่เบื้องหน้า

สิ่งที่ต้องดำเนินการก่อน

SDK โฆษณาในอุปกรณ์เคลื่อนที่ของ Google เวอร์ชัน 19.4.0 ขึ้นไป
ทำตามวิธีการตั้งค่าในคู่มือเริ่มต้นใช้งาน

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

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

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

ca-app-pub-3940256099942544/9257395921

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

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับวิธีการทำงานของโฆษณาทดสอบของ SDK โฆษณาบนอุปกรณ์เคลื่อนที่ โปรดดูโฆษณาทดสอบ

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

สร้างคลาสใหม่ที่ขยายคลาส Application และเพิ่มโค้ดต่อไปนี้เพื่อเริ่มต้น SDK โฆษณาในอุปกรณ์เคลื่อนที่ของ Google

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 ของคุณ:

<application
    android:name="com.google.android.gms.example.appopendemo.MyApplication" ...>
...
</application>

โปรดอ้างอิงชื่อแพ็กเกจจริง

ใช้คลาสยูทิลิตีของคุณ

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

สร้างชั้นเรียนใหม่ชื่อ AppOpenAdManager ภายในชั้นเรียน MyApplication และกรอกข้อมูลดังนี้

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 = "ca-app-pub-3940256099942544/9257395921";

    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 below.
    }

    /** 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 = "ca-app-pub-3940256099942544/9257395921"

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 below.
    }

    /** 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()

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;
          }

          @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
          }

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

AppOpenAdLoadCallback มีเมธอดที่เรียกใช้เมื่อ AppOpenAd โหลดเสร็จ

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

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

Java

public class MyApplication extends Application implements ActivityLifecycleCallbacks {

  private Activity currentActivity;

  ...

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

  @Override
  public void onActivityStarted(Activity activity) {
    // Updating the currentActivity only when an ad is not showing.
    if (!appOpenAdManager.isShowingAd) {
      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

  ...

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

  override fun onActivityStarted(activity: Activity) {
    // Updating the currentActivity only when an ad is not showing.
    if (!appOpenAdManager.isShowingAd) {
      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

Java

public class MyApplication extends Application {
  ...
  @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();
    appOpenAdManager = new AppOpenAdManager();
  }
}

Kotlin

class MyApplication : Application() {
  ...
  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) {}
    }
    appOpenAdManager = AppOpenAdManager()
  }
}

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

แสดงโฆษณาและจัดการเหตุการณ์ 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 จะจัดการเหตุการณ์ต่างๆ เช่น เมื่อโฆษณาแสดง ไม่นำเสนอ หรือเมื่อมีการปิด หากผู้ใช้กลับมาที่แอปของคุณหลังจากออกจากแอป โดยการคลิกโฆษณาเปิดแอป ระบบจะไม่นำเสนอผู้ใช้ด้วยโฆษณาเปิดแอปอีกรายการหนึ่ง

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

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

คุณต้องลงทะเบียน LifecycleObserver เพื่อรับการแจ้งเตือนเกี่ยวกับเหตุการณ์ที่ทำงานอยู่เบื้องหน้าของแอป ก่อนอื่น ให้แก้ไขไฟล์ build.gradle ระดับแอปพลิเคชันให้รวมไลบรารี LifecycleObserver ดังนี้

apply plugin: 'com.android.application'

dependencies {
   implementation 'androidx.appcompat:appcompat:1.3.0'
   implementation 'androidx.constraintlayout:constraintlayout:2.0.4'

   implementation 'com.google.android.gms:play-services-ads:23.2.0'

   def lifecycle_version = "2.3.1"
   implementation "androidx.lifecycle:lifecycle-extensions:$lifecycle_version"
   implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version"
   annotationProcessor "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
}

ใช้อินเทอร์เฟซ LifecycleObserver

คุณฟังเหตุการณ์เบื้องหน้าในชั้นเรียน Application ได้โดยใช้อินเทอร์เฟซ LifecycleObserver

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.
          }
        })
  }
}

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

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

เพื่อให้มั่นใจว่าคุณจะไม่แสดงโฆษณาที่หมดอายุแล้ว ให้เพิ่มเมธอดลงใน 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;

  /** 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;
          }
        });
  }
  ...

  /** 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

  /** 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;
          }
        })
  }
  ...

  private fun wasLoadTimeLessThanNHoursAgo(numHours: Long): Boolean {
    val dateDifference: Long = Date().time - loadTime
    val numMilliSecondsPerHour: Long = 3600000
    return dateDifference < numMilliSecondsPerHour * numHours
  }

  private fun isAdAvailable(): Boolean {
    return appOpenAd != null && wasLoadTimeLessThanNHoursAgo(4)
  }
}

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

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

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

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

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

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

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

ตัวอย่างใน GitHub

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

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

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