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

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

คู่มือนี้มีไว้สำหรับผู้เผยแพร่โฆษณาที่ผสานรวมโฆษณาที่เปิดแอปโดยใช้ Google Mobile Ads SDK (เบต้า)

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

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

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

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

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

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

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

ca-app-pub-3940256099942544/9257395921

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

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

ขยายคลาส Application

สร้างคลาสใหม่ที่ขยายคลาส Application ซึ่งเป็นวิธีที่คำนึงถึงวงจรของแอปในการจัดการโฆษณาที่เชื่อมโยงกับสถานะของแอปพลิเคชัน แทนที่จะเป็น Activity:

Kotlin

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

  override fun onCreate() {
    super<Application>.onCreate()
    CoroutineScope(Dispatchers.IO).launch {
      // Initialize the Mobile Ads SDK synchronously on a background thread.
      MobileAds.initialize(this@MyApplication, InitializationConfig.Builder(APP_ID).build()) {}
    }
  }

  private companion object {
    // Sample AdMob App ID.
    const val APP_ID = "ca-app-pub-3940256099942544~3347511713"
  }
}

Java

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

  // Sample AdMob App ID.
  private static final String APP_ID = "ca-app-pub-3940256099942544~3347511713";

  @Override
  public void onCreate() {
    super.onCreate();
    new Thread(
        () -> {
          // Initialize the SDK on a background thread.
          MobileAds.initialize(
              MyApplication.this,
              new InitializationConfig.Builder(APP_ID).build(),
              initializationStatus -> {});
        })
        .start();
  }
}

ซึ่งเป็นโครงสร้างที่คุณจะลงทะเบียนสำหรับเหตุการณ์การทำงานของแอปในเบื้องหน้าในภายหลัง

จากนั้นเพิ่มโค้ดต่อไปนี้ลงใน AndroidManifest.xml

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

ติดตั้งใช้งานคอมโพเนนต์ยูทิลิตี

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

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

Kotlin

/**
* Interface definition for a callback to be invoked when an app open ad is complete (i.e. dismissed
* or fails to show).
*/
fun interface OnShowAdCompleteListener {
  fun onShowAdComplete()
}

/** Singleton object that loads and shows app open ads. */
object AppOpenAdManager {
  private var appOpenAd: AppOpenAd? = null
  private var isLoadingAd = false
  var isShowingAd = false

  /**
  * Load an ad.
  *
  * @param context a context used to perform UI-related operations (e.g. display Toast messages).
  *   Showing the app open ad itself does not require a context.
  */
  fun loadAd(context: Context) {
    // We will implement this later.
  }

  /**
  * Show the ad if one isn't already showing.
  *
  * @param activity the activity that shows the app open ad.
  * @param onShowAdCompleteListener the listener to be notified when an app open ad is complete.
  */
  fun showAdIfAvailable(activity: Activity, onShowAdCompleteListener: OnShowAdCompleteListener?) {
    // We will implement this later.
  }

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

Java

/** Singleton object that loads and shows app open ads. */
public class AppOpenAdManager {

  /**
  * Interface definition for a callback to be invoked when an app open ad is complete (i.e.
  * dismissed or fails to show).
  */
  public interface OnShowAdCompleteListener {
    void onShowAdComplete();
  }

  private static AppOpenAdManager instance;
  private AppOpenAd appOpenAd;
  private boolean isLoadingAd = false;
  private boolean isShowingAd = false;

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

  public static synchronized AppOpenAdManager getInstance() {
    if (instance == null) {
      instance = new AppOpenAdManager();
    }
    return instance;
  }

  /**
  * Load an ad.
  *
  * @param context a context used to perform UI-related operations (e.g. display Toast messages).
  *     Loading the app open ad itself does not require a context.
  */
  public void loadAd(@NonNull Context context) {
    // We will implement this later.
  }

  /**
  * Show the ad if one isn't already showing.
  *
  * @param activity the activity that shows the app open ad.
  * @param onShowAdCompleteListener the listener to be notified when an app open ad is complete.
  */
  public void showAdIfAvailable(
      @NonNull Activity activity, @Nullable OnShowAdCompleteListener onShowAdCompleteListener) {
    // We will implement this later.
  }

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

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

Java

public class MyApplication extends Application {

  private AppOpenAdManager appOpenAdManager;

  @Override
  public void onCreate() {
    super.onCreate();
    new Thread(
            () -> {
              // Initialize Google Mobile Ads SDK (beta) 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 Google Mobile Ads SDK (beta) on a background thread.
      MobileAds.initialize(this@MyApplication) {}
    }
    appOpenAdManager = AppOpenAdManager()
  }
}

หากต้องการใช้ AppOpenAdManager ให้เรียกใช้เมธอด Wrapper สาธารณะในอินสแตนซ์ Singleton MyApplication Application คลาสจะเชื่อมต่อกับโค้ดที่เหลือ โดยมอบหมายงานในการโหลดและแสดงโฆษณาให้กับเครื่องมือจัดการ

โหลดโฆษณา

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

Kotlin


/**
 * Load an ad.
 *
 * @param context a context used to perform UI-related operations (e.g. display Toast messages).
 *   Loading the app open ad itself does not require a context.
 */
fun loadAd(context: Context) {
  // Do not load ad if there is an unused ad or one is already loading.
  if (isLoadingAd || isAdAvailable()) {
    Log.d(Constant.TAG, "App open ad is either loading or has already loaded.")
    return
  }

  isLoadingAd = true
  AppOpenAd.load(
    AdRequest.Builder(AppOpenFragment.AD_UNIT_ID).build(),
    object : AdLoadCallback<AppOpenAd> {
      /**
       * Called when an app open ad has loaded.
       *
       * @param ad the loaded app open ad.
       */
      override fun onAdLoaded(ad: AppOpenAd) {
        // Called when an ad has loaded.
        appOpenAd = ad
        isLoadingAd = false
        Log.d(Constant.TAG, "App open ad loaded.")
      }

      /**
       * Called when an app open ad has failed to load.
       *
       * @param loadAdError the error.
       */
      override fun onAdFailedToLoad(loadAdError: LoadAdError) {
        isLoadingAd = false
        Log.w(Constant.TAG, "App open ad failed to load: $loadAdError")
      }
    },
  )
}

Java


/**
 * Load an ad.
 *
 * @param context a context used to perform UI-related operations (e.g. display Toast messages).
 *     Loading the app open ad itself does not require a context.
 */
public void loadAd(@NonNull Context context) {
  // Do not load ad if there is an unused ad or one is already loading.
  if (isLoadingAd || isAdAvailable()) {
    Log.d(Constant.TAG, "App open ad is either loading or has already loaded.");
    return;
  }

  isLoadingAd = true;
  AppOpenAd.load(
      new AdRequest.Builder(AppOpenFragment.AD_UNIT_ID).build(),
      new AdLoadCallback<AppOpenAd>() {
        @Override
        public void onAdLoaded(@NonNull AppOpenAd ad) {
          appOpenAd = ad;
          isLoadingAd = false;
          Log.d(Constant.TAG, "App open ad loaded.");
        }

        @Override
        public void onAdFailedToLoad(@NonNull LoadAdError loadAdError) {
          isLoadingAd = false;
          Log.w(Constant.TAG, "App open ad failed to load: " + loadAdError);
        }
      });
}

แทนที่ AD_UNIT_ID ด้วยรหัสหน่วยโฆษณาของคุณเอง

แสดงโฆษณา

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

โค้ดต่อไปนี้จะแสดงและโหลดโฆษณาซ้ำ

Kotlin

/**
 * Show the ad if one isn't already showing.
 *
 * @param activity the activity that shows the app open ad.
 * @param onShowAdCompleteListener the listener to be notified when an app open ad is complete.
 */
fun showAdIfAvailable(activity: Activity, onShowAdCompleteListener: OnShowAdCompleteListener?) {
  // If the app open ad is already showing, do not show the ad again.
  if (isShowingAd) {
    Log.d(Constant.TAG, "App open ad is already showing.")
    onShowAdCompleteListener?.onShowAdComplete()
    return
  }

  // If the app open ad is not available yet, invoke the callback.
  if (!isAdAvailable()) {
    Log.d(Constant.TAG, "App open ad is not ready yet.")
    onShowAdCompleteListener?.onShowAdComplete()
    return
  }

  appOpenAd?.adEventCallback =
    object : AppOpenAdEventCallback {
      override fun onAdShowedFullScreenContent() {
        Log.d(Constant.TAG, "App open ad showed.")
      }

      override fun onAdDismissedFullScreenContent() {
        Log.d(Constant.TAG, "App open ad dismissed.")
        appOpenAd = null
        isShowingAd = false
        onShowAdCompleteListener?.onShowAdComplete()
        loadAd(activity)
      }

      override fun onAdFailedToShowFullScreenContent(
        fullScreenContentError: FullScreenContentError
      ) {
        appOpenAd = null
        isShowingAd = false
        Log.w(Constant.TAG, "App open ad failed to show: $fullScreenContentError")
        onShowAdCompleteListener?.onShowAdComplete()
        loadAd(activity)
      }

      override fun onAdImpression() {
        Log.d(Constant.TAG, "App open ad recorded an impression.")
      }

      override fun onAdClicked() {
        Log.d(Constant.TAG, "App open ad recorded a click.")
      }
    }

  isShowingAd = true
  appOpenAd?.show(activity)
}

Java

/**
 * Show the ad if one isn't already showing.
 *
 * @param activity the activity that shows the app open ad.
 * @param onShowAdCompleteListener the listener to be notified when an app open ad is complete.
 */
public void showAdIfAvailable(
    @NonNull Activity activity, @Nullable OnShowAdCompleteListener onShowAdCompleteListener) {
  // If the app open ad is already showing, do not show the ad again.
  if (isShowingAd) {
    Log.d(Constant.TAG, "App open ad is already showing.");
    if (onShowAdCompleteListener != null) {
      onShowAdCompleteListener.onShowAdComplete();
    }
    return;
  }

  // If the app open ad is not available yet, invoke the callback.
  if (!isAdAvailable()) {
    Log.d(Constant.TAG, "App open ad is not ready yet.");
    if (onShowAdCompleteListener != null) {
      onShowAdCompleteListener.onShowAdComplete();
    }
    return;
  }

  appOpenAd.setAdEventCallback(
      new AppOpenAdEventCallback() {
        @Override
        public void onAdShowedFullScreenContent() {
          Log.d(Constant.TAG, "App open ad shown.");
        }

        @Override
        public void onAdDismissedFullScreenContent() {
          Log.d(Constant.TAG, "App open ad dismissed.");
          appOpenAd = null;
          isShowingAd = false;
          if (onShowAdCompleteListener != null) {
            onShowAdCompleteListener.onShowAdComplete();
          }
          loadAd(activity);
        }

        @Override
        public void onAdFailedToShowFullScreenContent(
            @NonNull FullScreenContentError fullScreenContentError) {
          appOpenAd = null;
          isShowingAd = false;
          Log.w(Constant.TAG, "App open ad failed to show: " + fullScreenContentError);
          if (onShowAdCompleteListener != null) {
            onShowAdCompleteListener.onShowAdComplete();
          }
          loadAd(activity);
        }

        @Override
        public void onAdImpression() {
          Log.d(Constant.TAG, "App open ad recorded an impression.");
        }

        @Override
        public void onAdClicked() {
          Log.d(Constant.TAG, "App open ad recorded a click.");
        }
      });

  isShowingAd = true;
  appOpenAd.show(activity);
}

AppOpenAdEventCallback จัดการเหตุการณ์ต่างๆ เช่น เมื่อโฆษณาแสดง แสดงไม่สำเร็จ หรือเมื่อมีการปิดโฆษณา

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

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

Kotlin

object AppOpenAdManager {
  // ...
  /** Keep track of the time an app open ad is loaded to make sure you don't show an expired ad. */
  private var loadTime: Long = 0;
  
  /**
   * Load an ad.
   *
   * @param context a context used to perform UI-related operations (e.g. display Toast messages).
   *   Loading the app open ad itself does not require a context.
   */
  fun loadAd(context: Context) {
    // Do not load ad if there is an unused ad or one is already loading.
    if (isLoadingAd || isAdAvailable()) {
      Log.d(Constant.TAG, "App open ad is either loading or has already loaded.")
      return
    }

    isLoadingAd = true
    AppOpenAd.load(
      AdRequest.Builder(AppOpenFragment.AD_UNIT_ID).build(),
      object : AdLoadCallback<AppOpenAd> {
        /**
         * Called when an app open ad has loaded.
         *
         * @param ad the loaded app open ad.
         */
        override fun onAdLoaded(ad: AppOpenAd) {
          // Called when an ad has loaded.
          appOpenAd = ad
          isLoadingAd = false
          loadTime = Date().time
          Log.d(Constant.TAG, "App open ad loaded.")
        }

        /**
         * Called when an app open ad has failed to load.
         *
         * @param loadAdError the error.
         */
        override fun onAdFailedToLoad(loadAdError: LoadAdError) {
          isLoadingAd = false
          Log.w(Constant.TAG, "App open ad failed to load: $loadAdError")
        }
      },
    )
  }

  // ...

  /** 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 {
    // App open ads expire after four hours. Ads rendered more than four hours after request time
    // are no longer valid and may not earn revenue.
    return appOpenAd != null && wasLoadTimeLessThanNHoursAgo(4)
  }
}

Java

public class AppOpenAdManager {
  // ...
  /** Keep track of the time an app open ad is loaded to make sure you don't show an expired ad. */
  private long loadTime = 0;
  
  /**
   * Load an ad.
   *
   * @param context a context used to perform UI-related operations (e.g. display Toast messages).
   *     Loading the app open ad itself does not require a context.
   */
  public void loadAd(@NonNull Context context) {
    // Do not load ad if there is an unused ad or one is already loading.
    if (isLoadingAd || isAdAvailable()) {
      Log.d(Constant.TAG, "App open ad is either loading or has already loaded.");
      return;
    }

    isLoadingAd = true;
    AppOpenAd.load(
        new AdRequest.Builder(AppOpenFragment.AD_UNIT_ID).build(),
        new AdLoadCallback<AppOpenAd>() {
          @Override
          public void onAdLoaded(@NonNull AppOpenAd ad) {
            appOpenAd = ad;
            isLoadingAd = false;
            loadTime = new Date().getTime();
            Log.d(Constant.TAG, "App open ad loaded.");
          }

          @Override
          public void onAdFailedToLoad(@NonNull LoadAdError loadAdError) {
            isLoadingAd = false;
            Log.w(Constant.TAG, "App open ad failed to load: " + loadAdError);
          }
        });
  }

  // ...

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

  /** Check if ad exists and can be shown. */
  private boolean isAdAvailable() {
    // App open ads expire after four hours. Ads rendered more than four hours after request time
    // are no longer valid and may not earn revenue.
    return appOpenAd != null && wasLoadTimeLessThanNHoursAgo(4);
  }
}

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

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

Kotlin

class MyApplication : Application(), Application.ActivityLifecycleCallbacks {

  private var currentActivity: Activity? = null

  override fun onCreate() {
    super<Application>.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) {}

  // ...
}

Java

public class MyApplication extends Application
  implements Application.ActivityLifecycleCallbacks {

  private Activity currentActivity;

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

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

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

  @Override
  public void onActivityResumed(@NonNull Activity activity) {}

  @Override
  public void onActivityPaused(@NonNull Activity activity) {}

  @Override
  public void onActivityStopped(@NonNull Activity activity) {}

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

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

  // ...
}

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

รอเหตุการณ์การนำแอปไปไว้เบื้องหน้า

หากต้องการฟังเหตุการณ์ที่แอปทำงานอยู่เบื้องหน้า ให้ทำตามขั้นตอนต่อไปนี้

เพิ่มไลบรารีลงในไฟล์ Gradle

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

Kotlin

  dependencies {
    implementation("com.google.android.libraries.ads.mobile.sdk:ads-mobile-sdk:0.21.0-beta01")
    implementation("androidx.lifecycle:lifecycle-process:2.8.3")
  }

ดึงดูด

  dependencies {
    implementation 'com.google.android.libraries.ads.mobile.sdk:ads-mobile-sdk:0.21.0-beta01'
    implementation 'androidx.lifecycle:lifecycle-process:2.8.3'
  }

ใช้การเชื่อมต่อ Lifecycle Observer

คุณสามารถรอเหตุการณ์การเปลี่ยนไปใช้เบื้องหน้าได้โดยการใช้ อินเทอร์เฟซ DefaultLifecycleObserver

ใช้ onStart() เพื่อแสดงโฆษณาเปิดแอป

Kotlin

class MyApplication :
  Application(), Application.ActivityLifecycleCallbacks, DefaultLifecycleObserver {

  private var currentActivity: Activity? = null

  override fun onCreate() {
    super<Application>.onCreate()
    registerActivityLifecycleCallbacks(this)
    ProcessLifecycleOwner.get().lifecycle.addObserver(this)
  }

  /**
  * DefaultLifecycleObserver method that shows the app open ad when the app moves to foreground.
  */
  override fun onStart(owner: LifecycleOwner) {
    currentActivity?.let { activity ->
      AppOpenAdManager.showAdIfAvailable(activity, null)
    }
  }

  // ...
}

Java

public class MyApplication extends Application
  implements Application.ActivityLifecycleCallbacks, DefaultLifecycleObserver {

  private Activity currentActivity;

  @Override
  public void onCreate() {
    super.onCreate();
    registerActivityLifecycleCallbacks(this);
    ProcessLifecycleOwner.get().getLifecycle().addObserver(this);
  }

  /**
  * DefaultLifecycleObserver method that shows the app open ad when the app moves to foreground.
  */
  @Override
  public void onStart(@NonNull LifecycleOwner owner) {
    if (currentActivity == null) {
      return;
    }

    AppOpenAdManager.getInstance().showAdIfAvailable(currentActivity, null);
  }

  // ...
}

การเริ่มแอปแบบ Cold Start และหน้าจอการโหลด

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

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

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

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

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

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

ตัวอย่าง

ดาวน์โหลดและเรียกใช้แอปตัวอย่าง ที่แสดงการใช้ Google Mobile Ads SDK (เบต้า)