version:

fix:联网重启时更新时间 update:
2022-03-05 18:05:16 +08:00
parent 5aac5e802b
commit 3ef0e56a08
4 changed files with 245 additions and 2 deletions
--- a/app/src/main/java/com/aoleyun/sn/activity/SplashActivity.java
+++ b/app/src/main/java/com/aoleyun/sn/activity/SplashActivity.java
@@ -1,11 +1,13 @@
 package com.aoleyun.sn.activity;

 import android.annotation.SuppressLint;
+import android.app.AlarmManager;
 import android.app.StatusBarManager;
 import android.content.Context;
 import android.content.Intent;
 import android.content.pm.PackageManager;
 import android.graphics.Bitmap;
+import android.os.AsyncTask;
 import android.os.Build;
 import android.os.Bundle;
 import android.os.Environment;
@@ -32,6 +34,7 @@ import com.aoleyun.sn.service.LogcatService;
 import com.aoleyun.sn.utils.JGYUtils;
 import com.aoleyun.sn.utils.SPUtils;
 import com.aoleyun.sn.utils.ServiceAliveUtils;
+import com.aoleyun.sn.utils.TimeUtils;
 import com.aoleyun.sn.utils.Utils;
 import com.blankj.utilcode.util.PathUtils;
 import com.google.gson.Gson;
@@ -104,6 +107,7 @@ public class SplashActivity extends AppCompatActivity {
    }

    private void debugTest() {
+
 //        if (!BuildConfig.DEBUG) return;
 //        File file = new File("/system/media/bootanimation2.zip");
 //        if (file.exists()){
--- a/app/src/main/java/com/aoleyun/sn/service/main/MainService.java
+++ b/app/src/main/java/com/aoleyun/sn/service/main/MainService.java
@@ -1,6 +1,7 @@
 package com.aoleyun.sn.service.main;

 import android.annotation.SuppressLint;
+import android.app.AlarmManager;
 import android.app.NotificationChannel;
 import android.app.NotificationManager;
 import android.app.Service;
@@ -15,6 +16,7 @@ import android.net.ConnectivityManager;
 import android.net.NetworkInfo;
 import android.net.wifi.WifiInfo;
 import android.net.wifi.WifiManager;
+import android.os.AsyncTask;
 import android.os.Build;
 import android.os.IBinder;
 import android.provider.Settings;
@@ -106,6 +108,23 @@ public class MainService extends Service implements MainSContact.MainView, Netwo
        if (!checkAoleyunApp()){
            mPresenter.checkInfoUpdate();
        }
+        TimeTask task = new TimeTask();
+        task.execute("ntp.aliyun.com");
+    }
+
+    private class TimeTask extends AsyncTask<String, Long, Long> {
+        @Override
+        protected Long doInBackground(String... strings) {
+            return TimeUtils.getTimeFromNtpServer(strings[0]);
+        }
+
+        @Override
+        protected void onPostExecute(Long aLong) {
+            super.onPostExecute(aLong);
+            AlarmManager am = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
+            am.setTime(aLong);
+            Log.e(TAG, "getTimeFromNtpServer: " + aLong);
+        }
    }

    private final BehaviorSubject<ActivityEvent> lifecycleSubject = BehaviorSubject.create();
@@ -245,6 +264,8 @@ public class MainService extends Service implements MainSContact.MainView, Netwo
    public void onCreate() {
        super.onCreate();
        Log.e(TAG, "onCreate: ");
+        TimeTask task = new TimeTask();
+        task.execute("ntp.aliyun.com");
        ApkUtils.UninstallAPP(this, "com.joytv.live");
        ApkUtils.UninstallAPP(this, "com.tencent.android.qqdownloader");
        getPackageManager().setApplicationEnabledSetting("com.android.email", PackageManager.COMPONENT_ENABLED_STATE_DISABLED, 0);
--- a/app/src/main/java/com/aoleyun/sn/utils/TimeUtils.java
+++ b/app/src/main/java/com/aoleyun/sn/utils/TimeUtils.java
@@ -7,6 +7,7 @@ import androidx.annotation.NonNull;
 import androidx.annotation.RequiresApi;

 import android.os.Build;
+import android.os.SystemClock;
 import android.text.TextUtils;
 import android.util.Log;

@@ -14,6 +15,9 @@ import android.util.Log;
 import com.aoleyun.sn.bean.PoweroffBean;
 import com.aoleyun.sn.service.main.MainService;

+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.InetAddress;
 import java.text.DateFormat;
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
@@ -263,4 +267,218 @@ public class TimeUtils {
            return startTime + "\t-\t" + endTime;
        }
    }
+
+    private static SntpClient mNtpClient;
+
+    public static long getTimeFromNtpServer(String hostAddress) {
+        if (TextUtils.isEmpty(hostAddress)) {
+            Log.e("getTimeFromNtpServer", "Ntp host is null.");
+            return -1;
+        }
+        if (mNtpClient == null) {
+            mNtpClient = new SntpClient();
+        }
+        boolean isSuccessful = mNtpClient.requestTime(hostAddress, 20000);
+        Log.e("getTimeFromNtpServer", "requestTime:" + isSuccessful);
+        if (isSuccessful) {
+            long now = mNtpClient.getNtpTime();//now就是获取的时间
+            return now;
+        } else {
+            Log.e("getTimeFromNtpServer",  "  failed");
+        }
+        return -1;
+    }
+
+    public static class SntpClient {
+        private static final String TAG = "SntpClient";
+
+        private static final int REFERENCE_TIME_OFFSET = 16;
+        private static final int ORIGINATE_TIME_OFFSET = 24;
+        private static final int RECEIVE_TIME_OFFSET = 32;
+        private static final int TRANSMIT_TIME_OFFSET = 40;
+        private static final int NTP_PACKET_SIZE = 48;
+
+        private static final int NTP_PORT = 123;
+        private static final int NTP_MODE_CLIENT = 3;
+        private static final int NTP_VERSION = 3;
+
+        // Number of seconds between Jan 1, 1900 and Jan 1, 1970
+        // 70 years plus 17 leap days
+        private static final long OFFSET_1900_TO_1970 = ((365L * 70L) + 17L) * 24L * 60L * 60L;
+
+        // system time computed from NTP server response
+        private long mNtpTime;
+
+        // value of SystemClock.elapsedRealtime() corresponding to mNtpTime
+        private long mNtpTimeReference;
+
+        // round trip time in milliseconds
+        private long mRoundTripTime;
+
+        /**
+         * Sends an SNTP request to the given host and processes the response.
+         *
+         * @param host    host name of the server.
+         * @param timeout network timeout in milliseconds.
+         * @return true if the transaction was successful.
+         */
+        public boolean requestTime(String host, int timeout) {
+            DatagramSocket socket = null;
+            try {
+                socket = new DatagramSocket();
+                socket.setSoTimeout(timeout);
+                InetAddress address = InetAddress.getByName(host);
+                byte[] buffer = new byte[NTP_PACKET_SIZE];
+                DatagramPacket request = new DatagramPacket(buffer,
+                        buffer.length, address, NTP_PORT);
+
+                // set mode = 3 (client) and version = 3
+                // mode is in low 3 bits of first byte
+                // version is in bits 3-5 of first byte
+                buffer[0] = NTP_MODE_CLIENT | (NTP_VERSION << 3);
+
+                // get current time and write it to the request packet
+                long requestTime = System.currentTimeMillis();
+                Log.d(TAG, "RequestTime:" + new Date(requestTime));
+                long requestTicks = SystemClock.elapsedRealtime();
+                writeTimeStamp(buffer, TRANSMIT_TIME_OFFSET, requestTime);
+
+                socket.send(request);
+
+                // read the response
+                DatagramPacket response = new DatagramPacket(buffer,
+                        buffer.length);
+                socket.receive(response);
+                long responseTicks = SystemClock.elapsedRealtime();
+                long responseTime = requestTime
+                        + (responseTicks - requestTicks);
+
+                // extract the results
+                long originateTime = readTimeStamp(buffer,
+                        ORIGINATE_TIME_OFFSET);
+                long receiveTime = readTimeStamp(buffer, RECEIVE_TIME_OFFSET);
+                long transmitTime = readTimeStamp(buffer, TRANSMIT_TIME_OFFSET);
+                long roundTripTime = responseTicks - requestTicks
+                        - (transmitTime - receiveTime);
+                // receiveTime = originateTime + transit + skew
+                // responseTime = transmitTime + transit - skew
+                // clockOffset = ((receiveTime - originateTime) + (transmitTime
+                // - responseTime))/2
+                // = ((originateTime + transit + skew - originateTime) +
+                // (transmitTime - (transmitTime + transit - skew)))/2
+                // = ((transit + skew) + (transmitTime - transmitTime - transit
+                // + skew))/2
+                // = (transit + skew - transit + skew)/2
+                // = (2 * skew)/2 = skew
+                long clockOffset = ((receiveTime - requestTime) + (transmitTime - System.currentTimeMillis())) / 2;
+                // if (false) Log.d(TAG, "round trip: " + roundTripTime +
+                // " ms");
+                // if (false) Log.d(TAG, "clock offset: " + clockOffset +
+                // " ms");
+
+                // save our results - use the times on this side of the network
+                // latency
+                // (response rather than request time)
+                mNtpTime = System.currentTimeMillis() + clockOffset;
+//              mNtpTime = transmitTime;
+                mNtpTimeReference = responseTicks;
+                mRoundTripTime = roundTripTime;
+            } catch (Exception e) {
+                if (false)
+                    Log.e(TAG, "request time failed:" + e);
+                e.printStackTrace();
+                return false;
+            } finally {
+                if (socket != null) {
+                    socket.close();
+                }
+            }
+
+            return true;
+        }
+
+        /**
+         * Returns the time computed from the NTP transaction.
+         *
+         * @return time value computed from NTP server response.
+         */
+        public long getNtpTime() {
+            return mNtpTime;
+        }
+
+        /**
+         * Returns the reference clock value (value of
+         * SystemClock.elapsedRealtime()) corresponding to the NTP time.
+         *
+         * @return reference clock corresponding to the NTP time.
+         */
+        public long getNtpTimeReference() {
+            return mNtpTimeReference;
+        }
+
+        /**
+         * Returns the round trip time of the NTP transaction
+         *
+         * @return round trip time in milliseconds.
+         */
+        public long getRoundTripTime() {
+            return mRoundTripTime;
+        }
+
+        /**
+         * Reads an unsigned 32 bit big endian number from the given offset in
+         * the buffer.
+         */
+        private long read32(byte[] buffer, int offset) {
+            byte b0 = buffer[offset];
+            byte b1 = buffer[offset + 1];
+            byte b2 = buffer[offset + 2];
+            byte b3 = buffer[offset + 3];
+
+            // convert signed bytes to unsigned values
+            int i0 = ((b0 & 0x80) == 0x80 ? (b0 & 0x7F) + 0x80 : b0);
+            int i1 = ((b1 & 0x80) == 0x80 ? (b1 & 0x7F) + 0x80 : b1);
+            int i2 = ((b2 & 0x80) == 0x80 ? (b2 & 0x7F) + 0x80 : b2);
+            int i3 = ((b3 & 0x80) == 0x80 ? (b3 & 0x7F) + 0x80 : b3);
+
+            return ((long) i0 << 24) + ((long) i1 << 16) + ((long) i2 << 8)
+                    + (long) i3;
+        }
+
+        /**
+         * Reads the NTP time stamp at the given offset in the buffer and
+         * returns it as a system time (milliseconds since January 1, 1970).
+         */
+        private long readTimeStamp(byte[] buffer, int offset) {
+            long seconds = read32(buffer, offset);
+            long fraction = read32(buffer, offset + 4);
+            return ((seconds - OFFSET_1900_TO_1970) * 1000)
+                    + ((fraction * 1000L) / 0x100000000L);
+        }
+
+        /**
+         * Writes system time (milliseconds since January 1, 1970) as an NTP
+         * time stamp at the given offset in the buffer.
+         */
+        private void writeTimeStamp(byte[] buffer, int offset, long time) {
+            long seconds = time / 1000L;
+            long milliseconds = time - seconds * 1000L;
+            seconds += OFFSET_1900_TO_1970;
+
+            // write seconds in big endian format
+            buffer[offset++] = (byte) (seconds >> 24);
+            buffer[offset++] = (byte) (seconds >> 16);
+            buffer[offset++] = (byte) (seconds >> 8);
+            buffer[offset++] = (byte) (seconds >> 0);
+
+            long fraction = milliseconds * 0x100000000L / 1000L;
+            // write fraction in big endian format
+            buffer[offset++] = (byte) (fraction >> 24);
+            buffer[offset++] = (byte) (fraction >> 16);
+            buffer[offset++] = (byte) (fraction >> 8);
+            // low order bits should be random data
+            buffer[offset++] = (byte) (Math.random() * 255.0);
+        }
+    }
+
 }