我在问为什么我在 apppopenmanager 中放置了应用程序开放广告以及在MyApplication上添加的一些其他代码同样的文章，谷歌Admob建议使用，但我仍然困惑，为什么当我启动我的应用:
开机画面:先开放然后是App Open Ads打开并在后台运行，而MainActivity打开上方的应用程序开放广告
如果你知道如何解决这个问题，请帮助我…
提前感谢。
这是我用来向你展示app Open Ads的应用程序的动图
试试这个:
gradle:
implementation 'com.google.android.gms:play-services-ads:20.1.0'
def lifecycle_version = "2.2.0"
def lifecycle_version1 = "2.3.1"
implementation "androidx.lifecycle:lifecycle-extensions:$lifecycle_version"
implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version1"
annotationProcessor "androidx.lifecycle:lifecycle-compiler:$lifecycle_version1"
android:name=".MyApplication"
AppOpenManager.java
import android.app.Activity;
import android.app.Application;
import android.os.Bundle;
import android.util.Log;
import androidx.lifecycle.LifecycleObserver;
import androidx.lifecycle.OnLifecycleEvent;
import androidx.lifecycle.ProcessLifecycleOwner;
import com.google.android.gms.ads.AdError;
import com.google.android.gms.ads.AdRequest;
import com.google.android.gms.ads.FullScreenContentCallback;
import com.google.android.gms.ads.LoadAdError;
import com.google.android.gms.ads.appopen.AppOpenAd;
import java.util.Date;
import static androidx.lifecycle.Lifecycle.Event.ON_START;
public class AppOpenManager implements LifecycleObserver, Application.ActivityLifecycleCallbacks {
private long loadTime = 0;
private static final String LOG_TAG = "AppOpenManager";
private static String AD_UNIT_ID = "abc";
private AppOpenAd appOpenAd = null;
private Activity currentActivity;
private AppOpenAd.AppOpenAdLoadCallback loadCallback;
private static boolean isShowingAd = false;
private final MyApplication myApplication;
/** Constructor */
public AppOpenManager(MyApplication myApplication) {
this.myApplication = myApplication;
this.AD_UNIT_ID = myApplication.getString(R.string.app_open_id);
this.myApplication.registerActivityLifecycleCallbacks(this);
ProcessLifecycleOwner.get().getLifecycle().addObserver(this);
}
/** LifecycleObserver methods */
@OnLifecycleEvent(ON_START)
public void onStart() {
showAdIfAvailable();
Log.d(LOG_TAG, "onStart");
}
/** Request an ad */
public void fetchAd() {
// Have unused ad, no need to fetch another.
if (isAdAvailable()) {
return;
}
loadCallback =
new AppOpenAd.AppOpenAdLoadCallback() {
/**
* Called when an app open ad has loaded.
*
* @param ad the loaded app open ad.
*/
@Override
public void onAdLoaded(AppOpenAd ad) {
AppOpenManager.this.appOpenAd = ad;
AppOpenManager.this.loadTime = (new Date()).getTime();
}
/**
* Called when an app open ad has failed to load.
*
* @param loadAdError the error.
*/
@Override
public void onAdFailedToLoad(LoadAdError loadAdError) {
// Handle the error.
}
};
AdRequest request = getAdRequest();
AppOpenAd.load(
myApplication, AD_UNIT_ID, request,
AppOpenAd.APP_OPEN_AD_ORIENTATION_PORTRAIT, loadCallback);
}
/** Creates and returns ad request. */
private AdRequest getAdRequest() {
return new AdRequest.Builder().build();
}
/** 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));
}
/** Utility method that checks if ad exists and can be shown. */
public boolean isAdAvailable() {
return appOpenAd != null && wasLoadTimeLessThanNHoursAgo(4);
}
/** ActivityLifecycleCallback methods */
@Override
public void onActivityCreated(Activity activity, Bundle savedInstanceState) {}
@Override
public void onActivityStarted(Activity activity) {
currentActivity = activity;
}
@Override
public void onActivityResumed(Activity activity) {
currentActivity = 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) {
currentActivity = null;
}
/** Shows the ad if one isn't already showing. */
public void showAdIfAvailable() {
// Only show ad if there is not already an app open ad currently showing
// and an ad is available.
if (!isShowingAd && isAdAvailable()) {
Log.d(LOG_TAG, "Will show ad.");
FullScreenContentCallback fullScreenContentCallback =
new FullScreenContentCallback() {
@Override
public void onAdDismissedFullScreenContent() {
// Set the reference to null so isAdAvailable() returns false.
AppOpenManager.this.appOpenAd = null;
isShowingAd = false;
fetchAd();
}
@Override
public void onAdFailedToShowFullScreenContent(AdError adError) {}
@Override
public void onAdShowedFullScreenContent() {
isShowingAd = true;
}
};
appOpenAd.show(currentActivity);
} else {
Log.d(LOG_TAG, "Can not show ad.");
fetchAd();
}
}
}
MyApplication.java
import android.app.Application;
import com.google.android.gms.ads.MobileAds;
import com.google.android.gms.ads.initialization.InitializationStatus;
import com.google.android.gms.ads.initialization.OnInitializationCompleteListener;
/** The Application class that manages AppOpenManager. */
public class MyApplication extends Application {
private static AppOpenManager appOpenManager;
@Override
public void onCreate() {
super.onCreate();
MobileAds.initialize(
this,
new OnInitializationCompleteListener() {
@Override
public void onInitializationComplete(InitializationStatus initializationStatus) {}
});
appOpenManager = new AppOpenManager(this);
}
}
正如Google在">中提到的，冷启动和加载屏幕";Section中，当用户将应用挂起在内存中时，应用打开广告会显示。"冷starts">
应用启动时发生，但之前没有挂起在内存中。我们应该做的是避免在onBackPressed()中使用System.exit(0)退出应用程序，因为它会使应用程序在打开时处于Cold starts模式。请使用finishAffinity()退出应用程序。
代替
@OnLifecycleEvent(ON_START)
public void onStart() {
showAdIfAvailable();
}
与
@OnLifecycleEvent(ON_START)
public void onStart() {
if (!(currentActivity instanceof SplashActivity)) {
showAdIfAvailable();
}
}