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

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

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

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

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

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

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

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

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

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

ca-app-pub-3940256099942544/9257395921

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

ดูข้อมูลเพิ่มเติมเกี่ยวกับวิธีการทำงานของโฆษณาทดสอบของ 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 = "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 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 = "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 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;
          }
        })
  }
  // ...
}

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

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

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

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 จะจัดการเหตุการณ์ต่างๆ เช่น เมื่อโฆษณาแสดง ไม่แสดง หรือถูกปิด

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

เพิ่มเมธอดลงใน 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 เพิ่มการพึ่งพาลงในไฟล์บิลด์ระดับแอป

Kotlin

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

ดึงดูด

  dependencies {
    implementation 'com.google.android.gms:play-services-ads:23.5.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 จะไม่มีโฆษณาเปิดแอปที่โหลดไว้ก่อนหน้านี้ซึ่งพร้อมแสดงทันที ความล่าช้าระหว่างที่คุณขอโฆษณาและได้รับโฆษณาอาจทําให้ผู้ใช้ใช้แอปได้เพียงช่วงสั้นๆ ก่อนที่จะเห็นโฆษณาที่ไม่ตรงบริบท ไม่ควรใช้วิธีนี้เนื่องจากเป็นประสบการณ์ที่ไม่ดีสำหรับผู้ใช้

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

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

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

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

ตัวอย่างใน GitHub

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

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

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