1.解决开机无网络跟开机首次失败相冲突问题，Service由MXQ_4K代码替换

app/src/main/java/com/ik/mboxlauncher/SystemService.java

@@ -22,16 +22,19 @@ import com.android.device.NetStateChangeObserver;
 import com.android.nebulasdk.bean.ADInfo;
 import com.android.nebulasdk.presenter.AppnetPresenter;
 import com.android.nebulasdk.presenter.callback.AppnetCallback;
+import com.android.util.DeviceUtil;
 import com.android.util.LogUtils;
 import com.android.util.NetUtil;
 import com.android.util.NetworkType;
 
+import java.lang.ref.WeakReference;
 import java.text.SimpleDateFormat;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
 import java.util.Locale;
 import java.util.TimeZone;
+import java.util.UUID;
 
 /**
  * 资源同步后台服务
@@ -43,154 +46,113 @@ import java.util.TimeZone;
  */
 public class SystemService extends Service implements AppnetCallback, NetStateChangeObserver {
 
-    private static final int WHAT_REQUEST_ADMSG = 0;
+    private static final String TAG = SystemService.class.getName();
-    private static final int WHAT_NETWORK_CHANGE = 3;
+    private AppnetPresenter appnetPresenter;
-    private static final int WHAT_PERIODIC_REQUEST = 4;
+    String deviceId = "";
+    /**launcher 资源更新通知*/
+    public static final String NOTIFY_LAUNCHER_UPDATE="com.ik.launcher.res.notify";
+    /**Advert 资源更新通知*/
+    public static final String NOTIFY_ADVERT_UPDATE="com.ik.Advert.res.notify";
+    private static boolean isRunning = false;
 
-    // 请求间隔（8小时，正式环境）
+    //请求launcher资源信息
-//    private static final long REQUEST_INTERVAL = 8 * 60 * 60 * 1000;
+    private static final int WHAT_REQUEST_ADMSG=0;
-    // 测试用短间隔
+
-     private static final long REQUEST_INTERVAL = 5 * 60 * 1000; // 5分钟
+    /**更新资源信息*/
+    private static final int WHAT_REQUEST_UPDATEADINFO=1;
+
+    //开启诊断是否启动任务
+    private static final int WHAT_ASK_CIRCLETASK=2;
+
+    /**网络变化通知*/
+    private static final  int WHAT_NETWORK_CHANGE=3;
+    // -1表示无有效网络
+    private int lastEffectiveNetworkType = -1;
+    //标记当前是否有广告请求在进行（防止并行请求）
+    private boolean isRequesting = false;
+    // 上次网络触发请求的时间戳（毫秒）
+    private long lastNetTriggerTime = 0L;
+    // 网络请求最小间隔（60秒）
+    private static final long NET_REQUEST_INTERVAL = 10*60 * 1000;
+
+    private static final long FIVE_MINUS_DELAY=5*60 * 1000;
+    private static final long ONE_HOUR_DELAY= 60 * 60 * 1000;
+
+    private boolean isFirstRequestDone;
+
+    private boolean hasRequestDone;//请求成功过 更新时间间隔 8h
+    private SharedPreferences sharedPreferences;
     //持久化存储成功请求时间
     private static final String KEY_LAST_SUCCESS_TIME = "last_success_time";
-    private boolean isFirstRequestDone = false; // 首次请求是否完成（重启后重置为false）
+    private static class MyHandler extends Handler{
-    private boolean isRunning = false;
+        WeakReference<SystemService> weakReference;
-    private boolean isRequesting = false;
+        private MyHandler(SystemService service,Looper looper){
-
+            super(looper);
-    private AppnetPresenter appnetPresenter;
+            if(weakReference==null) weakReference= new WeakReference<>(service);
-    private Handler handler;
-    private SharedPreferences sharedPreferences;
-    private PowerManager powerManager;
-
-    @Override
-    public void onCreate() {
-        super.onCreate();
-        if (!isRunning) {
-            isRunning = true;
-            sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
-            powerManager = (PowerManager) getSystemService(POWER_SERVICE);
-            initHandler();
-
-            NetStateChangeReceiver.registerReceiver(this);
-            NetStateChangeReceiver.registerObserver(this);
-
-            // 检查是否是重启后首次启动服务
-            checkRebootStatus();
-
-            // 检查网络并执行首次请求
-            checkNetworkAndInitiateFirstRequest();
-
-            //handler.postDelayed(() -> ADManager.getInstance().restDownloadTask(), 3000);
-        }
         }
 
-    /**
-     * 检查是否是重启后首次启动
-     */
-    private void checkRebootStatus() {
-        if (powerManager != null) {
-            // 判断是否是开机后首次启动服务
-            boolean isReboot = powerManager.isInteractive();
-            if (isReboot) {
-               // LogUtils.loge("检测到设备重启，重置为首次请求状态");
-                isFirstRequestDone = false;
-            }
-        }
-    }
-
-    private void initHandler() {
-        handler = new Handler(Looper.getMainLooper()) {
         @Override
         public void handleMessage(@NonNull Message msg) {
-                switch (msg.what) {
+            super.handleMessage(msg);
+            SystemService systemService = weakReference.get();
+            if(systemService!=null){
+                switch (msg.what){
                     case WHAT_REQUEST_ADMSG:
-                        handleAdRequest();
+                        systemService.isRequesting=true;
+                        try {
+                            if (systemService.appnetPresenter == null) {
+                                systemService.appnetPresenter = new AppnetPresenter(systemService);
+                            }
+                            systemService.appnetPresenter.postLauncherAds(systemService);
+                        } catch (Exception e) {
+                            LogUtils.loge("request exception");
+                            systemService.isRequesting=false;
+                            if(!systemService.isFirstRequestDone){
+                                systemService.isFirstRequestDone=true;
+                            }else {
+                                if(systemService.hasRequestDone){
+                                    systemService.lastNetTriggerTime=System.currentTimeMillis();
+                                    systemService.sharedPreferences.edit().putLong(KEY_LAST_SUCCESS_TIME, systemService.lastNetTriggerTime).apply();
+                                }else {
+                                    if(systemService.lastNetTriggerTime!=0L){
+                                        systemService.handler.removeMessages(WHAT_ASK_CIRCLETASK);
+                                        systemService.handler.sendEmptyMessageDelayed(WHAT_ASK_CIRCLETASK, NET_REQUEST_INTERVAL);
+                                        return;
+                                    }
+                                }
+                            }
+                            systemService.scheduleNextCircleAsk();
+                        }
+                        break;
+                    case WHAT_REQUEST_UPDATEADINFO:
+                        //发送更新广告信息的广播
+                        break;
+
+                    case WHAT_ASK_CIRCLETASK:
+                        if(!systemService.isRequesting&&systemService.shouldRequestImmediately()&& systemService.isNetworkAvailable()){
+                            systemService.handler.removeMessages(WHAT_REQUEST_ADMSG);
+                            systemService.handler.sendEmptyMessage(WHAT_REQUEST_ADMSG);
+                        }else{
+                            systemService.scheduleNextCircleAsk();//刷新定时或启动定时
+                        }
                         break;
                     case WHAT_NETWORK_CHANGE:
-                        notifyNetworkChange();
+                        LogUtils.loge("发送网络变化的通知");
+                        EventBusUtils.postMsg(new MessageEvent(MessageEvent.ACTION_UPADATE_MEDIA_STATUS));  //网络变化刷新图标
                         break;
-                    case WHAT_PERIODIC_REQUEST:
-                        handlePeriodicRequest();
-                        break;
-                }
-            }
-        };
-    }
 
-    private void handlePeriodicRequest() {
-//        boolean should=shouldRequestImmediately();
-//        LogUtils.loge("shouldRequestImmediately()="+should+"isRequesting="+isRequesting);
-        if (isNetworkAvailable() && shouldRequestImmediately() && !isRequesting) {
-            LogUtils.loge("定时任务：满足条件，执行请求,task turn on");
-            handleAdRequest();
-        } else {
-            scheduleNextPeriodicRequest();
                 }
             }
-
-    private void checkNetworkAndInitiateFirstRequest() {
-        if (isFirstRequestDone) {
-            if (shouldRequestImmediately() && !isRequesting) {
-                handler.sendEmptyMessage(WHAT_REQUEST_ADMSG);
-            } else {
-                LogUtils.loge("首次请求已完成，启动定时任务 first request");
-                scheduleNextPeriodicRequest();
-            }
-            return;
-        }
-
-        boolean currentNetworkAvailable = isNetworkAvailable();
-        if (currentNetworkAvailable && !isRequesting) {
-            LogUtils.loge("执行首次请求 first request handler msg");
-            handler.sendEmptyMessage(WHAT_REQUEST_ADMSG);
-        } else {
-            LogUtils.loge("网络不可用，安排首次请求检查 network dont work");
-            scheduleNextPeriodicRequest();
         }
     }
-
+    private MyHandler handler;
-    private void scheduleNextPeriodicRequest() {
-        handler.removeMessages(WHAT_PERIODIC_REQUEST);
-
-        if (!isFirstRequestDone) {
-            LogUtils.loge("首次请求未完成，5分钟后再次检查 first uncompletely");
-            handler.sendEmptyMessageDelayed(WHAT_PERIODIC_REQUEST, 5*60 * 1000);
-            return;
-        }
-
-        long lastSuccessTime = getLastSuccessTime();
-        long currentTime = System.currentTimeMillis();
-
-        // 从未成功过，使用检查间隔
-        if (lastSuccessTime == 0) {
-            LogUtils.loge("从未成功请求过，1个小时后再次尝试,no success,1hour later try");
-            handler.sendEmptyMessageDelayed(WHAT_PERIODIC_REQUEST, 60 * 60 * 1000);
-            return;
-        }
-        if(currentTime<lastSuccessTime){
-            handler.sendEmptyMessage(WHAT_PERIODIC_REQUEST);
-            return;
-        }
-
-        long nextRequestTime = lastSuccessTime + REQUEST_INTERVAL;
-        long delay = Math.max(0, nextRequestTime - currentTime);
-        LogUtils.loge("delay="+delay);
-        handler.sendEmptyMessageDelayed(WHAT_PERIODIC_REQUEST, delay);
-//        if (isNetworkAvailable()){
-//            LogUtils.loge("定时任务安排完成：" +
-//                    "上次成功时间=" + formatTime(lastSuccessTime) +
-//                    "，当前时间=" + formatTime(currentTime) +
-//                    "，延迟=" + (delay / 1000 / 60) + "分钟" +
-//                    "，下次执行=" + formatTime(currentTime + delay));
-//        }
-    }
 
     private boolean shouldRequestImmediately() {
         if (!isFirstRequestDone) {
             return true;
         }
 
-        long lastSuccessTime = getLastSuccessTime();
+        long lastSuccessTime = sharedPreferences.getLong(KEY_LAST_SUCCESS_TIME, 0);
         long currentTime = System.currentTimeMillis();
 
         if (lastSuccessTime == 0) {
@@ -203,7 +165,7 @@ public class SystemService extends Service implements AppnetCallback, NetStateCh
         }
         long timeDiff = currentTime - lastSuccessTime;
 
-        if (timeDiff >= REQUEST_INTERVAL) {
+        if (timeDiff >= NET_REQUEST_INTERVAL) {
             LogUtils.loge("满足8小时间隔条件，应立即请求 delay 8 hour task turn on");
             return true;
         }
@@ -212,137 +174,23 @@ public class SystemService extends Service implements AppnetCallback, NetStateCh
         return false;
     }
 
-    private void markFirstRequestDone() {
-        isFirstRequestDone = true;
-      //  LogUtils.loge("标记首次请求已完成");
-    }
-
-    private void handleAdRequest() {
-        if (isRequesting) {
-            return;
-        }
-
-        if (appnetPresenter == null) {
-            try {
-                appnetPresenter = new AppnetPresenter(this);
-            } catch (Exception e) {
-                isRequesting = false;
-                if (!isFirstRequestDone) {
-                    markFirstRequestDone();
-                }
-                // 失败时不保存时间
-                // saveLastSuccessTime();
-                LogUtils.loge("请求异常 request exception");
-                scheduleNextPeriodicRequest();
-                return;
-            }
-        }
-
-        isRequesting = true;
-        appnetPresenter.postLauncherAds(this);
-    }
-
-    private void notifyNetworkChange() {
-        EventBusUtils.postMsg(new MessageEvent(MessageEvent.ACTION_UPADATE_MEDIA_STATUS));
-    }
-
-    private boolean isNetworkAvailable() {
-        int netState = NetUtil.getNetWorkState(this);
-        return netState == NetUtil.NETWORK_MOBILE
-                || netState == NetUtil.NETWORK_WIFI
-                || netState == NetUtil.NETWORK_ETHERNET;
-    }
-
-    private long getLastSuccessTime() {
-        return sharedPreferences.getLong(KEY_LAST_SUCCESS_TIME, 0);
-    }
-
-    private void saveLastSuccessTime() {
-        long currentTime = System.currentTimeMillis();
-        sharedPreferences.edit()
-                .putLong(KEY_LAST_SUCCESS_TIME, currentTime)
-                .apply();
-        LogUtils.loge("已保存本次成功请求时间：refresh" + formatTime(currentTime));
-    }
-
     @Override
-    public void onNetDisconnected() {
+    public void onCreate() {
-        LogUtils.loge("网络断开 netdisconnect");
+        super.onCreate();
-        handler.sendEmptyMessage(WHAT_NETWORK_CHANGE);
+        if(!isRunning){
+            isRunning =true;
+            handler=new MyHandler(SystemService.this,Looper.getMainLooper());
+            sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
+            deviceId= DeviceUtil.getEthernetMac();
+            LogUtils.loge( "onCreate: systemservice is start :"+deviceId);
+            NetStateChangeReceiver.registerReceiver(this);
+            NetStateChangeReceiver.registerObserver(this);
+            lastNetTriggerTime = sharedPreferences.getLong(KEY_LAST_SUCCESS_TIME, 0);
+            handler.removeMessages(WHAT_ASK_CIRCLETASK);
+            handler.sendEmptyMessage(WHAT_ASK_CIRCLETASK);
         }
 
-    @RequiresApi(api = Build.VERSION_CODES.O)
-    @Override
-    public void onNetConnected(NetworkType networkType) {
-        LogUtils.loge("网络连接恢复：netconnect" + networkType.name());
-        scheduleNextPeriodicRequest();
-        handler.sendEmptyMessage(WHAT_NETWORK_CHANGE);
-    }
 
-    @Override
-    public void onResult(Object data) {
-        isRequesting = false;
-        List<ADInfo> adInfoList = (data instanceof List<?>) ? (List<ADInfo>) data : new ArrayList<>();
-        ADManager.getInstance().updateADInfo(adInfoList);
-
-        if (!isFirstRequestDone) {
-            markFirstRequestDone();
-        }
-
-        // 成功时保存时间
-        saveLastSuccessTime();
-
-        scheduleNextPeriodicRequest();
-    }
-
-    @Override
-    public void onViewFailureString(int code, String message) {
-        isRequesting = false;
-        LogUtils.loge("接口请求失败（视图层）：错误码= code" + code + "，错误信息= viewmsg" + message);
-        handleRequestFailure();
-    }
-
-    @Override
-    public void onExceptionFailure(String message) {
-        isRequesting = false;
-        LogUtils.loge("接口请求异常：异常信息= exceptionmsg" + message);
-        handleRequestFailure();
-    }
-
-    @Override
-    public void onServerFailure(int code, String message) {
-        isRequesting = false;
-        LogUtils.loge("接口请求失败（服务端）：错误码= code" + code + "，错误信息= servermsg" + message);
-      //  handleRequestFailure();
-        // 仅保留首次请求完成标记（必须保留，避免无限重复首次请求）
-        if (!isFirstRequestDone) {
-            scheduleNextPeriodicRequest();
-            markFirstRequestDone();
-            return;
-        }
-        boolean isTimeout = code==0 || message.contains("The server is busy");
-        if (isTimeout) {
-            long lastSuccessTime = getLastSuccessTime();
-            if (lastSuccessTime == 0) {
-                scheduleNextPeriodicRequest();
-            } else {
-                handler.removeMessages(WHAT_PERIODIC_REQUEST);
-                handler.sendEmptyMessageDelayed(WHAT_PERIODIC_REQUEST, REQUEST_INTERVAL);
-            }
-        } else {
-            //保留原逻辑
-            scheduleNextPeriodicRequest();
-        }
-    }
-
-    private void handleRequestFailure() {
-        if (!isFirstRequestDone) {
-            markFirstRequestDone();
-        }
-
-        // 失败时不保存时间
-        // saveLastSuccessTime();
-        scheduleNextPeriodicRequest();
     }
 
     @RequiresApi(api = Build.VERSION_CODES.O)
@@ -351,6 +199,9 @@ public class SystemService extends Service implements AppnetCallback, NetStateCh
         return START_STICKY;
     }
 
+
+
+
     @Override
     public IBinder onBind(Intent intent) {
         return null;
@@ -358,26 +209,177 @@ public class SystemService extends Service implements AppnetCallback, NetStateCh
 
     @Override
     public void onDestroy() {
-        super.onDestroy();
-        isRunning = false;
-        isRequesting = false;
-
         NetStateChangeReceiver.unRegisterObserver(this);
         NetStateChangeReceiver.unRegisterReceiver(this);
-
+        isRunning = false;
-        if (handler != null) {
+        super.onDestroy();
-            handler.removeCallbacksAndMessages(null);
     }
 
-        if (appnetPresenter != null) {
+    @Override
-            appnetPresenter = null;
+    public void onResult(Object data) {
+        isRequesting=false;
+        List<ADInfo> adInfoList;
+        if(data==null){
+            adInfoList = new ArrayList<>();
+        }else {
+            adInfoList = (List<ADInfo>) data;
         }
+        ADManager.getInstance().updateADInfo(adInfoList);
+        if(!isFirstRequestDone){
+            isFirstRequestDone=true;
+        }
+        hasRequestDone=true;
+        lastNetTriggerTime=System.currentTimeMillis();
+        sharedPreferences.edit().putLong(KEY_LAST_SUCCESS_TIME,lastNetTriggerTime).apply();
+        scheduleNextCircleAsk();
     }
 
-    private String formatTime(long timestamp) {
+    @Override
-        if (timestamp == 0) return "未记录 no record";
+    public void onViewFailureString(int code, String message) {
-        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss.SSS", Locale.getDefault());
+        LogUtils.loge("onViewFailureString()"+message);
-        sdf.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
+        isRequesting=false;
-        return sdf.format(new Date(timestamp));
+        if(!isFirstRequestDone){
+            isFirstRequestDone=true;
+        }else {
+            if(hasRequestDone){
+                lastNetTriggerTime=System.currentTimeMillis();
+                sharedPreferences.edit().putLong(KEY_LAST_SUCCESS_TIME,lastNetTriggerTime).apply();
+            }else {
+                if(lastNetTriggerTime!=0L){
+                    handler.removeMessages(WHAT_ASK_CIRCLETASK);
+                    handler.sendEmptyMessageDelayed(WHAT_ASK_CIRCLETASK, NET_REQUEST_INTERVAL);
+                    return;
+                }
+            }
+        }
+        scheduleNextCircleAsk();
+    }
+
+    @Override
+    public void onExceptionFailure(String message) {
+        LogUtils.loge("onExceptionFailure()"+message);
+        isRequesting=false;
+        if(!isFirstRequestDone){
+            isFirstRequestDone=true;
+        }else {
+            if(hasRequestDone){
+                lastNetTriggerTime=System.currentTimeMillis();
+                sharedPreferences.edit().putLong(KEY_LAST_SUCCESS_TIME,lastNetTriggerTime).apply();
+            }else {
+                if(lastNetTriggerTime!=0L){
+                    handler.removeMessages(WHAT_ASK_CIRCLETASK);
+                    handler.sendEmptyMessageDelayed(WHAT_ASK_CIRCLETASK, NET_REQUEST_INTERVAL);
+                    return;
+                }
+            }
+        }
+        scheduleNextCircleAsk();
+    }
+
+    @Override
+    public void onServerFailure(int code, String message) {
+        LogUtils.loge("onServerFailure()"+message);
+        isRequesting=false;
+        if(!isFirstRequestDone){
+            isFirstRequestDone=true;
+        }else {
+            if(hasRequestDone){
+                lastNetTriggerTime=System.currentTimeMillis();
+                sharedPreferences.edit().putLong(KEY_LAST_SUCCESS_TIME,lastNetTriggerTime).apply();
+            }else {
+                if(lastNetTriggerTime!=0L){
+                    handler.removeMessages(WHAT_ASK_CIRCLETASK);
+                    handler.sendEmptyMessageDelayed(WHAT_ASK_CIRCLETASK, NET_REQUEST_INTERVAL);
+                    return;
+                }
+            }
+        }
+        scheduleNextCircleAsk();
+    }
+
+
+    @Override
+    public void onNetDisconnected() {
+        handler.sendEmptyMessage(WHAT_NETWORK_CHANGE);
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.O)
+    @Override
+    public void onNetConnected(NetworkType networkType) {
+        int netWorkState = NetUtil.getNetWorkState(this);
+        if (netWorkState == NetUtil.NETWORK_MOBILE || netWorkState == NetUtil.NETWORK_WIFI||netWorkState==NetUtil.NETWORK_ETHERNET) {
+            LogUtils.loge("network is ok");
+//            if(!isRequesting){
+//                handler.removeMessages(WHAT_REQUEST_ADMSG);
+//                handler.sendEmptyMessage(WHAT_REQUEST_ADMSG);
+//            }
+            handler.removeMessages(WHAT_ASK_CIRCLETASK);
+            handler.sendEmptyMessage(WHAT_ASK_CIRCLETASK);
+        } else {
+            LogUtils.loge("network is not ok");
+        }
+        handler.sendEmptyMessage(WHAT_NETWORK_CHANGE);
+
+    }
+
+
+    private  String createUUID(){
+        String timems =System.currentTimeMillis()+"";
+        return timems+"-"+ UUID.randomUUID().toString();
+    }
+
+    private void scheduleNextRequest() {
+        handler.removeMessages(WHAT_REQUEST_ADMSG);
+
+        if (!isFirstRequestDone) {
+            LogUtils.loge("first uncompletely,5mins later");
+            handler.sendEmptyMessageDelayed(WHAT_REQUEST_ADMSG, FIVE_MINUS_DELAY);
+            return;
+        }
+
+        long currentTime = System.currentTimeMillis();
+
+        // 从未成功过，使用检查间隔
+        if (lastNetTriggerTime == 0) {
+            LogUtils.loge("no success,1hour later try");
+            handler.sendEmptyMessageDelayed(WHAT_REQUEST_ADMSG, ONE_HOUR_DELAY);
+            return;
+        }
+
+        long nextRequestTime = lastNetTriggerTime + NET_REQUEST_INTERVAL;
+        long delay = Math.max(0, nextRequestTime - currentTime);
+        LogUtils.loge("delay="+delay);
+        handler.sendEmptyMessageDelayed(WHAT_REQUEST_ADMSG, delay);
+    }
+
+    private void scheduleNextCircleAsk() {
+        handler.removeMessages(WHAT_ASK_CIRCLETASK);
+
+        if (!isFirstRequestDone) {
+            LogUtils.loge("first uncompletely,5mins later try");
+            handler.sendEmptyMessageDelayed(WHAT_ASK_CIRCLETASK, FIVE_MINUS_DELAY);
+            return;
+        }
+
+        long currentTime = System.currentTimeMillis();
+
+        // 从未成功过，使用检查间隔
+        if (lastNetTriggerTime == 0) {
+            LogUtils.loge("no success,1hour later try");
+            handler.sendEmptyMessageDelayed(WHAT_ASK_CIRCLETASK, ONE_HOUR_DELAY);
+            return;
+        }
+
+        long nextRequestTime = lastNetTriggerTime + NET_REQUEST_INTERVAL;
+        long delay = Math.max(0, nextRequestTime - currentTime);
+        LogUtils.loge("delay="+delay);
+        handler.sendEmptyMessageDelayed(WHAT_ASK_CIRCLETASK, delay);
+    }
+
+    private boolean isNetworkAvailable() {
+        int netState = NetUtil.getNetWorkState(this);
+        return netState == NetUtil.NETWORK_MOBILE
+                || netState == NetUtil.NETWORK_WIFI
+                || netState == NetUtil.NETWORK_ETHERNET;
     }
 }