android主动进行NTP校时靠谱方案

最新推荐文章于 2025-04-22 14:11:52 发布
最新推荐文章于 2025-04-22 14:11:52 发布
阅读量1.3k 收藏 4
点赞数 4
文章标签： android 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jjdy2006/article/details/143732598
版权

一.需求背景

        我们都知道，如果主板电池没有电了，那么我们的系统时钟肯定是不准确的，对你的整个系统会有很大的影响，比如你获取当前时间戳，一定是获取的错误时间，这样的话，当你对接的一些平台，或者说调用的一些接口，他们如果做了时间验证之类的操作，那您调用的这些接口一定会返回失败。

        其实我们的系统本身就会自动做NTP校时，只不过我们也不知道系统用的NTP服务地址是什么，它稳定不稳定，靠谱不靠谱，而且系统自动触发NTP校时的间隔很长，我们设备的rom差不多要3-5分钟触发一次，时间也是随机的，有些时候单纯靠系统自动校时是不太靠谱的。

二.知识储备

        NTP：Network Time Protocol，网络时间协议

        NTP服务器一般情况是以UDP协议进行通信的

        原理：其实简单说来，你可以理解为请求一个接口，获取当前时间timeNow，在请求接口的时候记录一个时间time1，得到返回结果的时候再记录一个时间time2，将请求得到的时间timeNow+(time2-time1)，说白了就是加上一个请求本身的耗时，计算出真实的当前时间。当然了，真实的NTP算法很复杂，这个不在这里讨论，有兴趣的朋友可以阅读源码来了解。

        我们可以通过shell命令查看系统使用的哪个NTP服务地址，当然能够查看就能够设置：

//查看系统NTP服务地址
settings get global ntp_server

//设置系统NTP服务地址
settings put global ntp_server ntp.aliyun.com

//设置系统时间
date '2024-11-11 02:00:00'

比较常见的NTP服务地址：

阿里NTP服务器：ntp.aliyun.com（阿里流弊！稳定可靠！）

中国科学院国家授时中心NTP服务器：ntp.ntsc.ac.cn（辣鸡，失败率太高）

节目中心NTP服务器：time.dfcc.org.cn（还行，主要是我们必须得首选人家的）

三.代码干货

首先就是搭建一个NTP请求框架，这个东西满世界都是轮子，别自己造了，直接用吧：

/**
 * @Author LiuQN
 * @Date 2024/10/29 19:06
 */
import android.os.SystemClock;
import android.util.Log;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Arrays;

/**
 * Simple SNTP client class for retrieving network time.
 *
 * Sample usage:
 * <pre>SntpClient client = new SntpClient();
 * if (client.requestTime("time.foo.com")) {
 *     long now = client.getNtpTime() + SystemClock.elapsedRealtime() - client.getNtpTimeReference();
 * }
 * </pre>
 */
public class SntpClient {
    private static final String TAG = "SntpClient";
    private static final boolean DBG = true;

    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_MODE_SERVER = 4;
    private static final int NTP_MODE_BROADCAST = 5;
    private static final int NTP_VERSION = 3;

    private static final int NTP_LEAP_NOSYNC = 3;
    private static final int NTP_STRATUM_DEATH = 0;
    private static final int NTP_STRATUM_MAX = 15;

    // 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;

    private static class InvalidServerReplyException extends Exception {
        public InvalidServerReplyException(String message) {
            super(message);
        }
    }

    public boolean host2Address(String host) {
        try {
            InetAddress address = InetAddress.getByName(host);
            if (address != null) {
                Log.d(TAG, "Server address: " + address.toString());
                return true;
            }
        } catch (UnknownHostException e) {
            Log.e(TAG, "UnknownHost: " + host + " ,msg: " + e.getMessage());
            return false;
        }
        return false;
    }

    /**
     * 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;
        InetAddress address = null;
        try {
            address = InetAddress.getByName(host);
            socket = new DatagramSocket();
            socket.setSoTimeout(timeout);
            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
            final long requestTime = System.currentTimeMillis();
            final 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);
            final long responseTicks = SystemClock.elapsedRealtime();
            final long responseTime = requestTime + (responseTicks - requestTicks);

            // extract the results
            final byte leap = (byte) ((buffer[0] >> 6) & 0x3);
            final byte mode = (byte) (buffer[0] & 0x7);
            final int stratum = (int) (buffer[1] & 0xff);
            final long originateTime = readTimeStamp(buffer, ORIGINATE_TIME_OFFSET);
            final long receiveTime = readTimeStamp(buffer, RECEIVE_TIME_OFFSET);
            final long transmitTime = readTimeStamp(buffer, TRANSMIT_TIME_OFFSET);

            /* do sanity check according to RFC */
            // TODO: validate originateTime == requestTime.
            checkValidServerReply(leap, mode, stratum, transmitTime);

            long roundTripTime = responseTicks - requestTicks - (transmitTime - receiveTime);
            // receiveTime = originateTime + transit + skew
            // responseTime = transmitTime + transit - skew
            long 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
            Log.d(TAG, "Request time form ntp server success, " + address.toString() + " ,roundTripTime: " + roundTripTime);
            if (DBG) {
                Log.d(TAG, "round trip: " + roundTripTime + "ms, " +
                        "clock offset: " + clockOffset + "ms");
            }

            // save our results - use the times on this side of the network latency
            // (response rather than request time)
            mNtpTime = responseTime + clockOffset;
            mNtpTimeReference = responseTicks;
            mRoundTripTime = roundTripTime;
        } catch (Exception e) {
//            if (DBG) {
//                Log.e(TAG, "Error address: " + address.toString());
//            }
            Log.e(TAG, "Request time from ntp server failed ,msg: " + e.getMessage());
            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;
    }

    private static void checkValidServerReply(
            byte leap, byte mode, int stratum, long transmitTime)
            throws InvalidServerReplyException {
        if (leap == NTP_LEAP_NOSYNC) {
            throw new InvalidServerReplyException("unsynchronized server");
        }
        if ((mode != NTP_MODE_SERVER) && (mode != NTP_MODE_BROADCAST)) {
            throw new InvalidServerReplyException("untrusted mode: " + mode);
        }
        if ((stratum == NTP_STRATUM_DEATH) || (stratum > NTP_STRATUM_MAX)) {
            throw new InvalidServerReplyException("untrusted stratum: " + stratum);
        }
        if (transmitTime == 0) {
            throw new InvalidServerReplyException("zero transmitTime");
        }
    }

    /**
     * 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);
        // Special case: zero means zero.
        if (seconds == 0 && fraction == 0) {
            return 0;
        }
        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) {
        // Special case: zero means zero.
        if (time == 0) {
            Arrays.fill(buffer, offset, offset + 8, (byte) 0x00);
            return;
        }

        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);
    }
}

直接抄下来直接用，好使的一批。

如何使用：

    public static final String ntp_ali_server = "ntp.aliyun.com";

    /
        //这段代码放到你需要掉用的地方
        SntpClient sntpClient = new SntpClient();
        try {
            if (sntpClient.requestTime(ntp_ali_server, 3000)) {
                long ntpTime = sntpClient.getNtpTime() + SystemClock.elapsedRealtime() - sntpClient.getNtpTimeReference();
                String str = Utils.formatNtpTime(ntpTime);
                if (!StringUtils.isEmpty(str)) {
                    Utils.customCommand("date '" + str + "'");
                    return;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    


   public static String formatNtpTime(long time) {
        return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date(time));
    }

ok,至此，你可以随时随地的主动进行NTP时间校准了~

jjdy2006
关注
android GPS / SNTP 校时工具修正版
05-10
gj-online-SignFile.apk android GPS / SNTP 校时工具修正版，修正了GPS时区错误，同时去掉了广告条。亲自修改、重新签名打包。
android ntp时间服务器同步时间,android NTP时间同步
weixin_39607837的博客
05-25 1040
android NTP时间同步相关文件：frameworks/base/services/java/com/android/server/SystemServer.javaframeworks/base/services/java/com/android/server/NetworkTimeUpdateService.javaframeworks/base/core/java/android/ut...
Android NTP获取时间demo
最新发布
gitblog_06756的博客
04-22 530
Android NTP获取时间demo 【下载地址】AndroidNTP获取时间demo 这是一个专为Android开发者设计的NTP时间获取示例项目，帮助您快速掌握如何在应用中实现网络时间同步。项目提供了完整的源代码和编译好的APK，方便直接运行或二次开发。通过独立实现的NTP协议处理，您可以深入了解时间请求的发送与响...
NTP时间同步在Android平台的应用
03-03
随着全球信息化和通络通讯技术的迅速发展，人们对时间的精准性要求越来越高。本文通过对NTP 网络时间同步协议和原理的研究，分析了时间同步的架构与流程，提出了NTP 网络时间同步在Android 平台的实现方案。
Android系统 关于ntp的修改（网络时间同步）
Y在想什麽的博客
03-14 7189
NTP：网络时间协议，英文名称：Network Time Protocol（NTP）是用来使计算机时间同步化的一种协议，它可以使计算机对其服务器或时钟源（如石英钟，GPS等等)做同步化，它可以提供高精准度的时间校正（LAN上与标准间差小于1毫秒，WAN上几十毫秒），且可介由加密确认的方式来防止恶毒的协议攻击。NTP的目的是在无序的Internet环境中提供精确和健壮的时间服务。
Android11 使用NTP同步时间
wenzhi的博客
10-23 9545
前段时间遇到同样的版本和相关的产线的产品，存在有的设备可以同步时间，有的设备无法同步时间问题。存在问题的设备不仅无法同步时间，而且无法使用浏览器搜索百度，但是可以ping同百度，报错：system.err: Caused by: java.security.cert.CertPathValidatorException: timestamp check failed；意外的是修改到当天的日期时间后是可以正常同步时间和正常浏览网页。
Android NTP机制详解(基于Android 9.0)
lrh517的博客
12-26 2757
Android NTP机制详细分析（基于Android 9.0）
自动校准时间软件安卓版
06-30
自动校准时间软件安卓版，无广告，占内存小，root后非常好用，需要的拿去吧。
基于Qt的Ntp校时实例程序源码
10-05
**基于Qt的NTP校时实例程序源码详解** 在计算机网络中，时间同步是一个至关重要的环节，尤其是在分布式系统和多设备协作中。NTP（Network Time Protocol）是一种用于同步网络中不同计算机时间的协议。Qt是一个跨...
基于Qt和C++实现的Ntp校时类+源码
04-10
用法链接：... 基于Qt和C++实现的Ntp校时类+源码 该项目实现了 Ntp校时类 ，包含如下功能： 可设置Ntp服务器IP地址。 推荐用默认的阿里云时间服务器 ntp1.aliyun.com 收到时间信号发出。 时间精确到秒。
ntp校时软件windows版本-abouttime
03-31
ntp校时软件windows版本，AboutTime 是一款比较古老的软件了，尽管如此，它以其强大的功能和精巧高效，仍被很多人喜爱和使用。它既可作为校时客户端为本机校时，也可在局域网中作为校时服务器运行。常用于windows...
Android NTP时间库。 获得不受设备时钟时间变化影响的真实当前时间-Android开发
05-26
适用于Android的TrueTime请确保也检查我们的对应产品：TrueTime，这是Swift的NTP库。 适用于Android的NTP客户端。 计算手动更改设备时钟时间后不可更改的日期和时间“现在”。 在某些适用于Android的TrueTime应用程序中，请确保也检查我们的对应产品：TrueTime，这是Swift的NTP库。 适用于Android的NTP客户端。 计算手动更改设备时钟时间后不可更改的日期和时间“现在”。 在某些应用中，获取真实或“真实”的日期和时间变得很重要。 在大多数设备上，如果时钟已手动更改，则新的Date（）实例将为您提供受本地设置影响的时间。 用户可能出于多种原因执行此操作，例如处于不同的时间段
SNTPCLient
02-16
SNTP客户端服务器模式下的客户端程序，是源码。我在网上下的，希望对想学SNTP校时的人有帮助。
Delphi-控件实现NTP客户端校时功能
05-06
Delphi-控件实现NTP客户端校时功能Delphi-控件实现NTP客户端校时功能Delphi-控件实现NTP客户端校时功能Delphi-控件实现NTP客户端校时功能Delphi-控件实现NTP客户端校时功能Delphi-控件实现NTP客户端校时功能Delphi-...
ntp校时文档
01-12
以下是如何在CentOS系统上配置NTP服务器，使其能够与上级标准时间源进行校时，并向下属服务器和摄像机提供校时服务的详细步骤： 1. **停止ntpd服务**： 在进行时间同步之前，需要先停止正在运行的ntpd服务，因为...
【Android 应用】简单实测可行的获取NTP时间实例
看图的博客
11-22 1747
最近在做一个应用，涉及到数据上报，数据上报就涉及到时间，如果时间不对，服务器可能会拒绝你的数据。就算不拒绝，你上报的数据也是不正确的，我们采取的是宁可不要数据，也用错误的数据。这就体现到NTP获取数据的重要性了。 但是查询了大半天，发现网上的ntp请求都是过时的，获取格式不正确，很难读懂。自己重新弄了一下，就记录下来以防以后在用到查询。 一、可用的NTP地址 "ntp1.aliyun...
【一键校时】Ntp校时程序
qq_67689815的博客
07-03 383
软件功能：测试多个Ntp服务器延迟，进行校时操作，支持自定义Ntp服务器！
Ntp校时客户端小工具
lightspear的专栏
08-21 7724
Ntp校对时间是常用的计算机时间同步的方式之一，但是网上偏偏下载不到一个不带广告，且操作简单暴力的软件，其实我要的功能无非就是1：开机自动校对时间 2：每隔一段时间校对时间 3：可配置ntp服务器地址和校对间隔 但是就是找不到一款合适自己用的工具，无奈啊，只好自己手写一个 配置文件是ini，一看就懂 软件下载地址：https://download.csdn.net/download/li...
Android 通过NTP服务器自动获取时间的方法
bcghgfr的博客
11-05 1691
分享一下我老师大神的人工智能教程！零基础，通俗易懂！http://blog.csdn.net/jiangjunshow也欢迎大家转载本篇文章。分享知识，造福人民，实现我们中华民族伟大复兴！&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 对于手机，如果有SIM
CentOS NTP校时服务器配置指南
"本文档详细介绍了在 CentOS 操作系统中如何搭建 NTP 服务器，以实现与上级标准时间源同步，并向下级服务器和摄像...需要注意的是，在 ntpd 服务启动后，可能需要等待大约5分钟，下级服务器才能开始与其进行 NTP 校时。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值