登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›Android车载系统时间同步方案具体实现

Android车载系统时间同步方案具体实现

归筠溪 2025-7-17 17:04:23
Android车载系统时间同步方案具体实现

下面我将详细介绍各种时间同步方案的具体实现代码，包括完整的实现逻辑和关键代码片段。
一、NTP时间同步实现

完整实现类
  1. public class NtpTimeSync {
  2.     private static final String TAG = "NtpTimeSync";
  3.     private static final String NTP_SERVER = "pool.ntp.org";
  4.     private static final int TIMEOUT_MS = 10_000;
  6.     public interface TimeSyncCallback {
  7.         void onSuccess(long newTime);
  8.         void onFailure(String error);
  9.     }
  11.     public static void syncSystemTime(Context context, TimeSyncCallback callback) {
  12.         if (!isNetworkAvailable(context)) {
  13.             callback.onFailure("Network not available");
  14.             return;
  15.         }
  17.         new AsyncTask<Void, Void, Long>() {
  18.             @Override
  19.             protected Long doInBackground(Void... voids) {
  20.                 SntpClient client = new SntpClient();
  21.                 try {
  22.                     if (client.requestTime(NTP_SERVER, TIMEOUT_MS)) {
  23.                         long now = client.getNtpTime() + SystemClock.elapsedRealtime() -
  24.                                  client.getNtpTimeReference();
  25.                         return now;
  26.                     }
  27.                 } catch (Exception e) {
  28.                     Log.e(TAG, "NTP sync failed", e);
  29.                 }
  30.                 return null;
  31.             }
  33.             @Override
  34.             protected void onPostExecute(Long result) {
  35.                 if (result != null) {
  36.                     if (hasSetTimePermission(context)) {
  37.                         SystemClock.setCurrentTimeMillis(result);
  38.                         callback.onSuccess(result);
  39.                     } else {
  40.                         callback.onFailure("No SET_TIME permission");
  41.                     }
  42.                 } else {
  43.                     callback.onFailure("NTP sync failed");
  44.                 }
  45.             }
  46.         }.execute();
  47.     }
  49.     private static boolean isNetworkAvailable(Context context) {
  50.         ConnectivityManager cm = (ConnectivityManager)
  51.             context.getSystemService(Context.CONNECTIVITY_SERVICE);
  52.         NetworkInfo netInfo = cm.getActiveNetworkInfo();
  53.         return netInfo != null && netInfo.isConnected();
  54.     }
  56.     private static boolean hasSetTimePermission(Context context) {
  57.         return context.checkSelfPermission(android.Manifest.permission.SET_TIME) ==
  58.                PackageManager.PERMISSION_GRANTED;
  59.     }
  60. }
复制代码
使用示例
  1. NtpTimeSync.syncSystemTime(context, new NtpTimeSync.TimeSyncCallback() {
  2.     @Override
  3.     public void onSuccess(long newTime) {
  4.         Log.d(TAG, "Time synchronized successfully: " + new Date(newTime));
  5.     }
  7.     @Override
  8.     public void onFailure(String error) {
  9.         Log.e(TAG, "Time sync failed: " + error);
  10.     }
  11. });
复制代码
二、GPS时间同步实现

完整实现类
  1. public class GpsTimeSync {
  2.     private static final String TAG = "GpsTimeSync";
  3.     private LocationManager locationManager;
  4.     private GpsTimeListener listener;
  5.     private Context context;
  7.     public interface GpsTimeListener {
  8.         void onGpsTimeReceived(long gpsTime);
  9.         void onGpsStatusChanged(boolean available);
  10.     }
  12.     public GpsTimeSync(Context context, GpsTimeListener listener) {
  13.         this.context = context.getApplicationContext();
  14.         this.listener = listener;
  15.         this.locationManager = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
  16.     }
  18.     public void startListening() {
  19.         if (hasLocationPermission()) {
  20.             try {
  21.                 locationManager.requestLocationUpdates(
  22.                     LocationManager.GPS_PROVIDER,
  23.                     0,
  24.                     0,
  25.                     locationListener
  26.                 );
  27.             
  28.                 // 检查GPS状态变化
  29.                 locationManager.addGpsStatusListener(gpsStatusListener);
  30.             } catch (Exception e) {
  31.                 Log.e(TAG, "Failed to request location updates", e);
  32.             }
  33.         } else {
  34.             Log.w(TAG, "Location permission not granted");
  35.         }
  36.     }
  38.     public void stopListening() {
  39.         locationManager.removeUpdates(locationListener);
  40.         locationManager.removeGpsStatusListener(gpsStatusListener);
  41.     }
  43.     private final LocationListener locationListener = new LocationListener() {
  44.         @Override
  45.         public void onLocationChanged(Location location) {
  46.             if (location != null) {
  47.                 long gpsTime = location.getTime();
  48.                 listener.onGpsTimeReceived(gpsTime);
  49.             }
  50.         }
  52.         @Override public void onStatusChanged(String provider, int status, Bundle extras) {}
  53.         @Override public void onProviderEnabled(String provider) {}
  54.         @Override public void onProviderDisabled(String provider) {}
  55.     };
  57.     private final GpsStatus.Listener gpsStatusListener = new GpsStatus.Listener() {
  58.         @Override
  59.         public void onGpsStatusChanged(int event) {
  60.             boolean gpsFixed = false;
  61.             if (event == GpsStatus.GPS_EVENT_SATELLITE_STATUS) {
  62.                 GpsStatus status = locationManager.getGpsStatus(null);
  63.                 Iterable<GpsSatellite> satellites = status.getSatellites();
  64.                 int satellitesCount = 0;
  65.                 for (GpsSatellite satellite : satellites) {
  66.                     if (satellite.usedInFix()) {
  67.                         satellitesCount++;
  68.                     }
  69.                 }
  70.                 gpsFixed = satellitesCount >= 3;
  71.             }
  72.             listener.onGpsStatusChanged(gpsFixed);
  73.         }
  74.     };
  76.     private boolean hasLocationPermission() {
  77.         return ContextCompat.checkSelfPermission(context,
  78.                Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED;
  79.     }
  80. }
复制代码
使用示例
  1. GpsTimeSync gpsTimeSync = new GpsTimeSync(context, new GpsTimeSync.GpsTimeListener() {
  2.     @Override
  3.     public void onGpsTimeReceived(long gpsTime) {
  4.         // 同步系统时间
  5.         if (hasSetTimePermission()) {
  6.             SystemClock.setCurrentTimeMillis(gpsTime);
  7.         }
  8.     }
  10.     @Override
  11.     public void onGpsStatusChanged(boolean available) {
  12.         Log.d(TAG, "GPS availability changed: " + available);
  13.     }
  14. });
  16. // 开始监听
  17. gpsTimeSync.startListening();
  19. // 停止监听（在适当的时候调用）
  20. // gpsTimeSync.stopListening();
复制代码
三、CAN总线时间同步实现

JNI部分实现 (C代码)
  1. #include <jni.h>
  2. #include
  3. #include <canbus/can.h>
  5. #define TAG "CANTimeSync"
  7. // CAN接收回调
  8. void can_receive_callback(can_frame_t *frame) {
  9.     if (frame->can_id == 0x123) { // 假设0x123是时间信息帧ID
  10.         uint64_t vehicle_time = 0;
  11.         memcpy(&vehicle_time, frame->data, sizeof(uint64_t));
  12.    
  13.         // 调用Java层方法
  14.         JNIEnv *env;
  15.         (*g_vm)->AttachCurrentThread(g_vm, &env, NULL);
  16.    
  17.         jclass cls = (*env)->GetObjectClass(env, g_java_obj);
  18.         jmethodID method = (*env)->GetMethodID(env, cls, "onCanTimeReceived", "(J)V");
  19.         (*env)->CallVoidMethod(env, g_java_obj, method, (jlong)vehicle_time);
  20.    
  21.         (*g_vm)->DetachCurrentThread(g_vm);
  22.     }
  23. }
  25. // JNI初始化
  26. JNIEXPORT void JNICALL
  27. Java_com_example_CanTimeSync_initCanBus(JNIEnv *env, jobject instance) {
  28.     // 保存Java对象和VM引用
  29.     g_java_obj = (*env)->NewGlobalRef(env, instance);
  30.     (*env)->GetJavaVM(env, &g_vm);
  31.   
  32.     // 初始化CAN总线
  33.     if (can_init() != 0) {
  34.         __android_log_write(ANDROID_LOG_ERROR, TAG, "CAN init failed");
  35.         return;
  36.     }
  37.   
  38.     // 设置接收回调
  39.     can_set_receive_callback(can_receive_callback);
  40. }
  42. // JNI关闭
  43. JNIEXPORT void JNICALL
  44. Java_com_example_CanTimeSync_closeCanBus(JNIEnv *env, jobject instance) {
  45.     can_close();
  46.     (*env)->DeleteGlobalRef(env, g_java_obj);
  47. }
复制代码
Java层实现
  1. public class CanTimeSync {
  2.     private static final String TAG = "CanTimeSync";
  3.   
  4.     static {
  5.         System.loadLibrary("cantimesync");
  6.     }
  7.   
  8.     public interface CanTimeListener {
  9.         void onCanTimeReceived(long vehicleTime);
  10.         void onCanError(String error);
  11.     }
  12.   
  13.     private CanTimeListener listener;
  14.   
  15.     public CanTimeSync(CanTimeListener listener) {
  16.         this.listener = listener;
  17.     }
  18.   
  19.     public void start() {
  20.         try {
  21.             initCanBus();
  22.         } catch (Exception e) {
  23.             listener.onCanError("CAN init failed: " + e.getMessage());
  24.         }
  25.     }
  26.   
  27.     public void stop() {
  28.         closeCanBus();
  29.     }
  30.   
  31.     // 由JNI调用的方法
  32.     private void onCanTimeReceived(long vehicleTime) {
  33.         listener.onCanTimeReceived(vehicleTime);
  34.     }
  35.   
  36.     // Native方法
  37.     private native void initCanBus();
  38.     private native void closeCanBus();
  39. }
复制代码
使用示例
  1. CanTimeSync canTimeSync = new CanTimeSync(new CanTimeSync.CanTimeListener() {
  2.     @Override
  3.     public void onCanTimeReceived(long vehicleTime) {
  4.         // 转换时间格式并同步
  5.         long systemTime = convertCanTimeToSystemTime(vehicleTime);
  6.         if (hasSetTimePermission()) {
  7.             SystemClock.setCurrentTimeMillis(systemTime);
  8.         }
  9.     }
  11.     @Override
  12.     public void onCanError(String error) {
  13.         Log.e(TAG, "CAN error: " + error);
  14.     }
  15. });
  17. // 启动CAN时间同步
  18. canTimeSync.start();
  20. // 停止同步（在适当的时候调用）
  21. // canTimeSync.stop();
复制代码
四、PTP时间同步实现

PTP客户端实现
  1. public class PtpTimeSync {
  2.     private static final String TAG = "PtpTimeSync";
  3.     private static final String PTP_IFACE = "eth0";
  4.   
  5.     public interface PtpSyncListener {
  6.         void onPtpSyncComplete(long offsetNanos);
  7.         void onPtpSyncError(String error);
  8.     }
  9.   
  10.     public static void syncWithPtp(PtpSyncListener listener) {
  11.         new Thread(() -> {
  12.             try {
  13.                 Process process = Runtime.getRuntime().exec("ptp4l -i " + PTP_IFACE + " -m");
  14.                 BufferedReader reader = new BufferedReader(
  15.                     new InputStreamReader(process.getInputStream()));
  16.             
  17.                 String line;
  18.                 while ((line = reader.readLine()) != null) {
  19.                     if (line.contains("offset")) {
  20.                         // 解析偏移量: master offset -1234 s2 freq
  21.                         String[] parts = line.split("\\s+");
  22.                         if (parts.length >= 4) {
  23.                             long offset = Long.parseLong(parts[3]);
  24.                             listener.onPtpSyncComplete(offset);
  25.                         }
  26.                     }
  27.                 }
  28.             
  29.                 int exitCode = process.waitFor();
  30.                 if (exitCode != 0) {
  31.                     listener.onPtpSyncError("PTP process exited with code " + exitCode);
  32.                 }
  33.             } catch (Exception e) {
  34.                 listener.onPtpSyncError("PTP sync failed: " + e.getMessage());
  35.             }
  36.         }).start();
  37.     }
  38.   
  39.     public static void adjustSystemClock(long offsetNanos) {
  40.         long millis = offsetNanos / 1_000_000;
  41.         if (millis != 0) {
  42.             long current = System.currentTimeMillis();
  43.             SystemClock.setCurrentTimeMillis(current + millis);
  44.         }
  45.     }
  46. }
复制代码
使用示例
  1. PtpTimeSync.syncWithPtp(new PtpTimeSync.PtpSyncListener() {
  2.     @Override
  3.     public void onPtpSyncComplete(long offsetNanos) {
  4.         Log.d(TAG, "PTP offset: " + offsetNanos + " ns");
  5.         if (Math.abs(offsetNanos) > 100_000) { // 如果偏移大于100μs
  6.             PtpTimeSync.adjustSystemClock(offsetNanos);
  7.         }
  8.     }
  10.     @Override
  11.     public void onPtpSyncError(String error) {
  12.         Log.e(TAG, "PTP error: " + error);
  13.     }
  14. });
复制代码
五、混合时间同步策略实现

综合时间同步管理器
  1. public class TimeSyncManager {
  2.     private static final String TAG = "TimeSyncManager";
  3.     private static final long SYNC_INTERVAL = 60_000; // 1分钟
  4.   
  5.     private Context context;
  6.     private Handler handler;
  7.     private NtpTimeSync.TimeSyncCallback ntpCallback;
  8.     private GpsTimeSync gpsTimeSync;
  9.     private CanTimeSync canTimeSync;
  10.   
  11.     private long lastSyncTime;
  12.     private TimeSource currentSource = TimeSource.LOCAL;
  13.   
  14.     public enum TimeSource {
  15.         GPS, NTP, CAN, PTP, LOCAL
  16.     }
  17.   
  18.     public interface SyncStatusListener {
  19.         void onSyncStatusChanged(TimeSource source, long time, long offset);
  20.     }
  21.   
  22.     public TimeSyncManager(Context context) {
  23.         this.context = context.getApplicationContext();
  24.         this.handler = new Handler(Looper.getMainLooper());
  25.    
  26.         initCallbacks();
  27.         initGpsSync();
  28.         initCanSync();
  29.     }
  30.   
  31.     private void initCallbacks() {
  32.         ntpCallback = new NtpTimeSync.TimeSyncCallback() {
  33.             @Override
  34.             public void onSuccess(long newTime) {
  35.                 long offset = newTime - System.currentTimeMillis();
  36.                 updateTime(TimeSource.NTP, newTime, offset);
  37.             }
  39.             @Override
  40.             public void onFailure(String error) {
  41.                 Log.w(TAG, "NTP sync failed: " + error);
  42.             }
  43.         };
  44.     }
  45.   
  46.     private void initGpsSync() {
  47.         gpsTimeSync = new GpsTimeSync(context, new GpsTimeSync.GpsTimeListener() {
  48.             @Override
  49.             public void onGpsTimeReceived(long gpsTime) {
  50.                 long offset = gpsTime - System.currentTimeMillis();
  51.                 updateTime(TimeSource.GPS, gpsTime, offset);
  52.             }
  54.             @Override
  55.             public void onGpsStatusChanged(boolean available) {
  56.                 if (available) {
  57.                     Log.d(TAG, "GPS available, preferring GPS time");
  58.                 }
  59.             }
  60.         });
  61.         gpsTimeSync.startListening();
  62.     }
  63.   
  64.     private void initCanSync() {
  65.         canTimeSync = new CanTimeSync(new CanTimeSync.CanTimeListener() {
  66.             @Override
  67.             public void onCanTimeReceived(long vehicleTime) {
  68.                 long systemTime = convertCanTimeToSystemTime(vehicleTime);
  69.                 long offset = systemTime - System.currentTimeMillis();
  70.                 updateTime(TimeSource.CAN, systemTime, offset);
  71.             }
  73.             @Override
  74.             public void onCanError(String error) {
  75.                 Log.w(TAG, "CAN sync error: " + error);
  76.             }
  77.         });
  78.         canTimeSync.start();
  79.     }
  80.   
  81.     public void startPeriodicSync() {
  82.         handler.postDelayed(syncRunnable, SYNC_INTERVAL);
  83.     }
  84.   
  85.     public void stopPeriodicSync() {
  86.         handler.removeCallbacks(syncRunnable);
  87.         gpsTimeSync.stopListening();
  88.         canTimeSync.stop();
  89.     }
  90.   
  91.     private Runnable syncRunnable = new Runnable() {
  92.         @Override
  93.         public void run() {
  94.             syncTime();
  95.             handler.postDelayed(this, SYNC_INTERVAL);
  96.         }
  97.     };
  98.   
  99.     private void syncTime() {
  100.         // 根据优先级尝试各种同步方法
  101.         if (isGpsAvailable()) {
  102.             // GPS时间已经通过回调处理
  103.         } else if (isNetworkAvailable()) {
  104.             NtpTimeSync.syncSystemTime(context, ntpCallback);
  105.         } else if (isCanAvailable()) {
  106.             // CAN时间已经通过回调处理
  107.         } else {
  108.             Log.w(TAG, "No time source available");
  109.         }
  110.    
  111.         lastSyncTime = System.currentTimeMillis();
  112.     }
  113.   
  114.     private void updateTime(TimeSource source, long newTime, long offset) {
  115.         // 只接受合理的时间偏移
  116.         if (Math.abs(offset) > 10_000) { // 10秒以上偏移
  117.             Log.w(TAG, "Large time offset detected: " + offset + "ms");
  118.         
  119.             // 渐进式调整
  120.             long adjustedTime = System.currentTimeMillis() + (offset / 2);
  121.             if (hasSetTimePermission()) {
  122.                 SystemClock.setCurrentTimeMillis(adjustedTime);
  123.             }
  124.         }
  125.    
  126.         currentSource = source;
  127.    
  128.         // 通知监听器
  129.         for (SyncStatusListener listener : listeners) {
  130.             listener.onSyncStatusChanged(source, newTime, offset);
  131.         }
  132.     }
  133.   
  134.     // 工具方法
  135.     private boolean isGpsAvailable() {
  136.         LocationManager lm = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
  137.         return lm.isProviderEnabled(LocationManager.GPS_PROVIDER);
  138.     }
  139.   
  140.     private boolean isNetworkAvailable() {
  141.         ConnectivityManager cm = (ConnectivityManager)
  142.             context.getSystemService(Context.CONNECTIVITY_SERVICE);
  143.         NetworkInfo netInfo = cm.getActiveNetworkInfo();
  144.         return netInfo != null && netInfo.isConnected();
  145.     }
  146.   
  147.     private boolean isCanAvailable() {
  148.         // 实现检查CAN总线可用性的逻辑
  149.         return true;
  150.     }
  151.   
  152.     private boolean hasSetTimePermission() {
  153.         return context.checkSelfPermission(Manifest.permission.SET_TIME) ==
  154.                PackageManager.PERMISSION_GRANTED;
  155.     }
  156.   
  157.     private long convertCanTimeToSystemTime(long canTime) {
  158.         // 实现CAN时间到系统时间的转换逻辑
  159.         return canTime;
  160.     }
  161.   
  162.     // 监听器管理
  163.     private List<SyncStatusListener> listeners = new ArrayList<>();
  164.   
  165.     public void addSyncStatusListener(SyncStatusListener listener) {
  166.         if (!listeners.contains(listener)) {
  167.             listeners.add(listener);
  168.         }
  169.     }
  170.   
  171.     public void removeSyncStatusListener(SyncStatusListener listener) {
  172.         listeners.remove(listener);
  173.     }
  174. }
复制代码
使用示例
  1. TimeSyncManager timeSyncManager = new TimeSyncManager(context);
  2. timeSyncManager.addSyncStatusListener(new TimeSyncManager.SyncStatusListener() {
  3.     @Override
  4.     public void onSyncStatusChanged(TimeSyncManager.TimeSource source,
  5.                                   long time, long offset) {
  6.         Log.d(TAG, "Time source: " + source +
  7.               ", offset: " + offset + "ms");
  8.     }
  9. });
  11. // 开始周期性同步
  12. timeSyncManager.startPeriodicSync();
  14. // 停止同步（在适当的时候调用）
  15. // timeSyncManager.stopPeriodicSync();
复制代码
六、权限配置

所有时间同步方案都需要在AndroidManifest.xml中添加相应权限：
  1. [/code]对于Android 6.0+，还需要在运行时请求危险权限：
  2. [code]private static final int PERMISSION_REQUEST_CODE = 100;
  3. private String[] requiredPermissions = {
  4.     Manifest.permission.ACCESS_FINE_LOCATION,
  5.     Manifest.permission.SET_TIME
  6. };
  8. private void checkPermissions() {
  9.     List<String> missingPermissions = new ArrayList<>();
  10.     for (String perm : requiredPermissions) {
  11.         if (ContextCompat.checkSelfPermission(this, perm)
  12.             != PackageManager.PERMISSION_GRANTED) {
  13.             missingPermissions.add(perm);
  14.         }
  15.     }
  16.   
  17.     if (!missingPermissions.isEmpty()) {
  18.         ActivityCompat.requestPermissions(this,
  19.             missingPermissions.toArray(new String[0]),
  20.             PERMISSION_REQUEST_CODE);
  21.     }
  22. }
  24. @Override
  25. public void onRequestPermissionsResult(int requestCode,
  26.                                      String[] permissions,
  27.                                      int[] grantResults) {
  28.     if (requestCode == PERMISSION_REQUEST_CODE) {
  29.         for (int i = 0; i < grantResults.length; i++) {
  30.             if (grantResults[i] != PackageManager.PERMISSION_GRANTED) {
  31.                 Log.w(TAG, "Permission denied: " + permissions[i]);
  32.             }
  33.         }
  34.     }
  35. }
复制代码
以上代码提供了Android车载系统各种时间同步方案的完整实现，您可以根据实际需求进行修改和扩展。

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
归筠溪
2025-7-17 17:04:23

0

粉丝关注

20

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫