怎么样做个网站最近军事新闻大事

怎么样做个网站,最近军事新闻大事,公司营销网络怎么写,合肥设网站一、总体架构树形分析1.1 应用层架构逻辑树GpsTrackerService (主服务) ├── 通信管理层 │ ├── NettyControll (TCP长连接) │ ├── JMOrderControll (核心套件协议) │ └── SerialPortUtil (串口通信) ├── 位置处理层 │ ├── GpsControll (GPS数据采…一、总体架构树形分析1.1 应用层架构逻辑树GpsTrackerService (主服务) ├── 通信管理层 │ ├── NettyControll (TCP长连接) │ ├── JMOrderControll (核心套件协议) │ └── SerialPortUtil (串口通信) ├── 位置处理层 │ ├── GpsControll (GPS数据采集) │ ├── Resolution (位置过滤算法) │ └── DistanceCalcUtils (距离计算) ├── 事件管理层 │ ├── RemoteEventManager (远程事件) │ ├── AlarmControll (报警控制) │ └── MessageFactory (消息工厂) ├── 文件传输层 │ ├── UploadManager (文件上传) │ ├── GsensorTransManager (G传感器传输) │ └── CardReaderManager (读卡器管理) └── 系统管理层 ├── DBHelper (数据库) ├── SPUtils (配置存储) └── Utils (工具类集合)1.2 解耦设计分析1.2.1 接口隔离设计// 四大监听器接口实现了解耦 public class GpsTrackerService implements IServerListener, // 服务器通信解耦 ILocationListener, // 位置监听解耦 IUploadListener, // 上传监听解耦 ISerialDataReceiverListener // 串口数据解耦1.2.2 工厂模式应用// 消息创建解耦 MessageFactory.getInstance(mContext).gpsPackageSend(info); ​ // 设备解析解耦 ExternalDeviceFactory.getInstance(mContext).parseBuffer(buffer); ​ // XML配置解析解耦 XmlParseFactory.getInstance(mContext).parseXml();二、Framework层树形分析2.1 Android系统服务调用树应用层调用框架 ├── 位置服务框架 │ ├── LocationManager │ │ └── GpsControll封装 │ └── LocationListener │ └── onLocationChanged回调 ├── 网络服务框架 │ ├── ConnectivityManager │ │ └── isNetworkAvailable() │ ├── WifiManager │ │ └── setWifiApEnabled() │ └── TelephonyManager │ └── SignalStrength监听 ├── 定时服务框架 │ └── AlarmManager │ ├── setExact() 精确定时 │ └── ELAPSED_REALTIME_WAKEUP 唤醒机制 └── 存储服务框架 ├── ContentResolver │ └── 系统设置访问 └── DownloadManager └── 下载管理2.2 关键Framework函数调用链onCreate() ├── getSystemService(CONNECTIVITY_SERVICE) │ └── ConnectivityManager系统服务 ├── getSystemService(TELEPHONY_SERVICE) │ └── TelephonyManager系统服务 ├── registerReceiver() │ └── BroadcastReceiver注册 └── startService() └── Service启动机制 ​ onLocationChanged() ├── GpsControll.getInstance() │ └── LocationManager API调用 └── sendLocationInfoMsg() ├── MessageFactory创建消息 ├── Netty/JMOrder发送 └── Handler消息队列2.3 Binder Server架构应用2.3.1 系统服务Binder调用// AlarmManager的Binder调用路径 AlarmManager am (AlarmManager) mContext.getSystemService(Context.ALARM_SERVICE); am.setExact(AlarmManager.ELAPSED_REALTIME_WAKEUP, times, mHeatBeatPi); ​ // 调用路径分析 // 应用层 → AlarmManager Proxy → AlarmManagerService (system_server) → Alarm驱动2.3.2 自定义Binder服务设计虽然代码中没有显式定义Binder服务但通过以下方式实现进程间通信PendingIntent机制封装了Binder通信Broadcast广播基于Binder的跨进程通信ContentProvider通过Binder访问系统设置2.4 数据流向精度分析2.4.1 位置数据流向树GPS硬件层 ├── NMEA数据流 (原始数据) ├── Android Location框架 │ ├── LocationManagerService (system_server) │ │ ├── GpsLocationProvider (JNI层) │ │ └── 位置过滤算法 │ └── Location对象封装 │ ├── 经度/纬度 (double, 6位小数) │ ├── 精度 (float) │ └── 时间戳 (long) └── 应用层处理 ├── LocationInfo对象转换 ├── 过滤算法处理 (Resolution) └── 网络传输编码 (43字节/条)2.4.2 网络数据流向树应用层数据包 ├── 消息编码层 (MessageFactory) │ ├── GPS包: 43字节固定长度 │ ├── 心跳包: 固定协议头 │ └── 报警包: 变长结构 ├── 网络传输层 │ ├── NettyControll (NIO框架) │ │ ├── Channel缓冲区管理 │ │ └── 异步事件驱动 │ └── JMOrderControll (自定义协议) │ └── TCP长连接管理 └── 服务器端处理 ├── 协议解析 ├── 数据存储 └── 业务逻辑处理三、System/Vendor层树形分析3.1 HAL层调用架构应用层 → JNI层 → HAL层 → 内核驱动 ​ 具体调用路径 GpsTrackerService ├── GpsControll位置监听 │ └── LocationManager API │ └── LocationManagerService (system_server) │ ├── JNI接口 (com_android_server_location_GpsLocationProvider.cpp) │ ├── GPS HAL接口 (hardware/libhardware/include/hardware/gps.h) │ │ ├── gps_device_t结构体 │ │ ├── GpsCallbacks回调 │ │ └── AGPS接口 │ └── Vendor HAL实现 │ └── 芯片厂商具体实现 (如Qualcomm GPS HAL)3.2 厂商特定功能调用// 第三方GPS芯片库调用 gmMisc.GM_Cam_Mirror_ctrl(1); // 相机镜像控制 gmMisc.GM_Relay_Ctrl(relayStatus); // 继电器控制 gmMisc.GM_Gsensor_Guard_on(0); // G传感器控制 ​ // 调用路径分析 // Java层 → JNI接口 → Vendor库 (.so) → 内核驱动3.3 系统设置访问路径Settings.Global.getInt(cr, Settings.Global.AIRPLANE_MODE_ON, 0); ​ 访问路径 应用层 → Settings Provider → Settings数据库 → 系统设置服务 ​ 数据流向 1. ContentResolver查询 2. Binder调用SettingsProvider 3. SQLite数据库访问 4. 系统属性设置 (SystemProperties.set)3.4 串口通信架构SerialPortUtil.getInstance().start(); ​ 架构层次 Java应用层 ├── JNI接口层 (SerialPortUtil JNI) ├── Vendor串口驱动层 │ ├── tty设备节点 (/dev/tty*) │ ├── 波特率配置 │ └── 数据流控制 └── 内核串口驱动 ├── 串口核心层 (drivers/tty/serial) └── 具体芯片UART驱动四、Kernel层架构树形分析4.1 GPS内核架构内核GPS子系统 ├── 字符设备层 │ └── /dev/gps 设备节点 ├── 驱动层 │ ├── GPS芯片驱动 (如gps_drv.c) │ │ ├── 电源管理 │ │ ├── 时钟控制 │ │ └── 中断处理 │ └── UART串口驱动 │ ├── 数据收发 │ └── DMA传输 ├── 协议层 │ └── NMEA协议解析 │ ├── GGA语句解析 │ ├── RMC语句解析 │ └── GSV语句解析 └── 接口层 ├── 向上接口 (用户空间) │ ├── ioctl控制接口 │ ├── read数据读取 │ └── write配置写入 └── 向下接口 (硬件) ├── I2C/SPI总线 └── GPIO控制4.2 传感器内核架构G传感器内核架构 ├── 输入子系统层 │ └── input_event事件上报 ├── IIO子系统 (Industrial I/O) │ ├── iio_device设备注册 │ ├── iio_trigger触发器 │ └── iio_buffer数据缓冲 ├── 具体传感器驱动 │ ├── 加速度计驱动 │ ├── 陀螺仪驱动 │ └── 磁力计驱动 └── 用户空间接口 ├── /sys/class/iio设备节点 ├── sysfs属性文件 └── 字符设备接口4.3 网络通信内核架构TCP/IP内核栈 ├── 套接字层 │ └── socket系统调用 ├── TCP层 │ ├── 连接管理 │ ├流量控制 │ └── 拥塞控制 ├── IP层 │ ├── 路由选择 │ ├── 分片重组 │ └── NAT转换 └── 网卡驱动层 ├── 数据包收发 ├── DMA传输 └── 中断处理五、跨层数据流完整分析5.1 完整GPS数据流硬件层 (GPS芯片) ├── 射频信号接收 ├── 基带处理 └── NMEA数据生成 ​ 内核层 ├── 串口驱动接收NMEA数据 ├── GPS字符设备节点 (/dev/gps) └── 输入子系统上报 ​ HAL层 ├── gps.h接口实现 ├── 位置数据转换 └── 精度计算 ​ Framework层 ├── LocationManagerService ├── Location对象封装 └── Binder IPC传递 ​ 应用层 (GpsTrackerService) ├── onLocationChanged回调 ├── 位置过滤算法 ├── 数据压缩编码 └── 网络传输5.2 异常处理数据流异常检测 (如碰撞检测) ├── G传感器硬件中断 ├── 内核输入子系统上报 ├── HAL层数据转换 ├→ Framework层SensorManager │ └→ SensorEventListener ├→ GpsTrackerService.onDataReceive ├→ AlarmControll.sendAlarmMessage ├→ 文件生成 (视频/图片) └→ 网络上传服务器六、性能优化架构分析6.1 多级缓冲设计内存缓冲层 (LinkedListLocationInfo) ├── 实时数据缓冲 (mSaveLocationList) ├── 异步IO缓冲 (AsynIoExecutor) └── 数据库缓冲 (DBHelper) ​ 文件缓冲层 ├── 临时文件缓冲 ├── 日志文件缓冲 └── 上传文件队列 ​ 网络缓冲层 ├── Netty Channel缓冲区 ├── TCP发送缓冲区 └── 重传缓冲区6.2 电源管理架构电源优化策略树 ├── 唤醒锁管理 │ ├── PARTIAL_WAKE_LOCK (CPU唤醒) │ └── AlarmManager精准唤醒 ├── 传感器采样优化 │ ├── 动态采样率调整 │ └── ACC状态依赖 └── 网络连接优化 ├── 心跳间隔调整 ├── TCP保活机制 └── 网络状态监听6.3 线程模型架构多线程架构树 ├── 主线程 (UI线程) │ ├── Handler消息处理 │ └── 系统回调处理 ├── 网络线程池 │ ├── Netty事件循环 │ └── 异步IO执行器 ├── 定时任务线程 │ ├── Timer定时器 │ └── AlarmManager唤醒 └── 串口通信线程 ├── 数据接收线程 └── 数据处理线程七、安全架构分析7.1 数据安全架构数据安全层级 ├── 传输层安全 │ ├── CRC校验 (ByteArrayUtils.checkMsgCRC) │ └── TCP可靠传输 ├── 存储层安全 │ ├── SQLite数据库加密 │ ├── SharedPreferences存储 │ └── 文件系统权限 └── 访问层安全 ├── Android权限系统 ├── 服务访问控制 └── 广播权限控制7.2 通信安全架构通信安全机制 ├── 协议层安全 │ ├── 消息格式校验 │ └── 序列号验证 ├── 认证层安全 │ ├── 设备IMEI认证 │ ├── 登录认证机制 │ └── 心跳保持认证 └── 数据层安全 ├── 敏感数据加密 ├── 位置数据脱敏 └── 日志数据保护八、 原代码// 定义应用程序包名表示这是com.android.gps.tracker包下的类 package com.android.gps.tracker; ​ // Netty网络框架相关的导入用于网络通信 import io.netty.channel.ChannelFuture; // Netty通道未来结果 import io.netty.channel.ChannelFutureListener; // Netty通道未来监听器 ​ // Java标准库导入 import java.io.File; // 文件操作类 import java.nio.ByteBuffer; // NIO字节缓冲区用于高效IO操作 import java.text.ParseException; // 日期解析异常 import java.text.SimpleDateFormat; // 日期格式化类 import java.util.ArrayList; // 动态数组用于存储位置信息等数据 import java.util.Date; // 日期类 import java.util.LinkedList; // 链表适用于频繁插入删除操作 import java.util.Map; // 键值对映射接口 import java.util.Set; // 集合接口 import java.util.Timer; // 定时器类用于调度任务 import java.util.TimerTask; // 定时任务抽象类 import java.util.concurrent.atomic.AtomicInteger; // 原子整数线程安全的计数器 ​ // Android框架导入 import android.annotation.SuppressLint; // 抑制lint警告注解 import android.app.AlarmManager; // 闹钟管理器用于定时唤醒 import android.app.DownloadManager; // 下载管理器 import android.app.PendingIntent; // 延迟意图用于跨进程通信 import android.app.Service; // 服务基类后台长期运行组件 import android.content.BroadcastReceiver; // 广播接收器基类 import android.content.ContentResolver; // 内容解析器访问系统数据 import android.content.Context; // 上下文接口 import android.content.Intent; // 意图类用于组件间通信 import android.content.IntentFilter; // 意图过滤器筛选广播 import android.net.ConnectivityManager; // 连接管理器网络状态监控 import android.net.NetworkInfo; // 网络信息类 import android.net.wifi.WifiManager; // WiFi管理器 import android.os.Handler; // 消息处理器用于线程间通信 import android.os.IBinder; // 绑定服务接口 import android.os.Message; // 消息对象 import android.os.SystemClock; // 系统时钟获取精确时间 import android.provider.Settings; // 系统设置访问 import android.telephony.PhoneStateListener; // 电话状态监听器 import android.telephony.SignalStrength; // 信号强度类 import android.telephony.SmsManager; // 短信管理器 import android.telephony.TelephonyManager; // 电话管理器 import android.text.TextUtils; // 文本工具类 import android.util.Log; // 日志工具类 ​ // 项目自定义包导入 import com.android.gps.tracker.application.TrackerApplication; // 应用程序类 import com.android.gps.tracker.binder.SDKSwitchUdpTrigger; // SDK开关UDP触发器 import com.android.gps.tracker.controll.AlarmControll; // 闹钟控制器 import com.android.gps.tracker.controll.CardReaderManager; // 读卡器管理器 import com.android.gps.tracker.controll.GpsControll; // GPS控制器 import com.android.gps.tracker.controll.GsensorTransManager; // G传感器传输管理器 import com.android.gps.tracker.controll.JMOrderControll; // JM指令控制器 import com.android.gps.tracker.controll.NettyControll; // Netty网络控制器 import com.android.gps.tracker.controll.RemoteEventManager; // 远程事件管理器 import com.android.gps.tracker.controll.UploadManager; // 上传管理器 import com.android.gps.tracker.controll.filter.Resolution; // 分辨率过滤器 import com.android.gps.tracker.db.DBHelper; // 数据库助手 import com.android.gps.tracker.event.FileActionType; // 文件操作类型枚举 import com.android.gps.tracker.factory.ExternalDeviceFactory; // 外部设备工厂工厂模式 import com.android.gps.tracker.factory.MessageFactory; // 消息工厂工厂模式 import com.android.gps.tracker.factory.XmlParseFactory; // XML解析工厂工厂模式 import com.android.gps.tracker.info.LocationInfo; // 位置信息数据类 import com.android.gps.tracker.info.RemoteEvent; // 远程事件数据类 import com.android.gps.tracker.listener.ILocationListener; // 位置监听器接口观察者模式 import com.android.gps.tracker.listener.IServerListener; // 服务器监听器接口观察者模式 import com.android.gps.tracker.listener.ISerialDataReceiverListener; // 串口数据接收监听器接口 import com.android.gps.tracker.listener.IUploadListener; // 上传监听器接口观察者模式 import com.android.gps.tracker.listener.ReUploadChannelFuture; // 重新上传通道未来类 import com.android.gps.tracker.log.LogUtils; // 日志工具类 import com.android.gps.tracker.player.AudioFileKey; // 音频文件键 import com.android.gps.tracker.receiver.TrackerBroadCastReceiver; // 追踪广播接收器 import com.android.gps.tracker.serialport.SerialPortUtil; // 串口工具类 import com.android.gps.tracker.trimmerge.FindFileRunnable; // 查找文件任务线程 import com.android.gps.tracker.utils.AmsOnLineCommadTask; // AMS在线命令任务 import com.android.gps.tracker.utils.AsynIoExecutor; // 异步IO执行器线程池模式 import com.android.gps.tracker.utils.ByteArrayUtils; // 字节数组工具类 import com.android.gps.tracker.utils.Constant; // 常量类 import com.android.gps.tracker.utils.DistanceCalcUtils; // 距离计算工具类 import com.android.gps.tracker.utils.DownloadUtils; // 下载工具类 import com.android.gps.tracker.utils.QueryIPRunnable; // 查询IP任务线程 import com.android.gps.tracker.utils.SPUtils; // SharedPreferences工具类 import com.android.gps.tracker.utils.TFConfigRunnable; // TF卡配置任务线程 import com.android.gps.tracker.utils.Utils; // 通用工具类 import java.lang.InterruptedException; // 中断异常 import com.concox.gmMisc.gmMisc; // 第三方GPS模块库 ​ /** * GPS追踪服务类 - 主服务组件 * 设计模式分析 * 1. 观察者模式实现多个监听器接口(ILocationListener, IServerListener等) * 2. 工厂模式通过导入的工厂类创建对象 * 3. 单例模式服务本身作为系统后台单例运行 * 4. 策略模式不同的控制器处理不同类型的业务逻辑 * 5. 命令模式通过指令控制器处理外部命令 * * 运行性能分析 * 1. 多线程处理使用线程池、定时器、Handler等多线程机制 * 2. 内存管理使用LinkedList、ArrayList等集合类管理数据 * 3. 网络优化使用Netty高性能网络框架 * 4. 电量优化合理使用AlarmManager唤醒机制 * 5. 数据流设计通过监听器模式解耦提高扩展性 * * 数据流结构大小设计注解 * 1. LocationInfo位置信息对象包含经度、纬度、速度、方向等字段约100-200字节 * 2. ByteBuffer用于网络传输的缓冲区通常设置为4KB-64KB * 3. ArrayList/LinkedList根据数据量动态调整位置历史数据可能达到上千条 * 4. 数据库存储SQLite数据库存储历史轨迹、配置信息等 */ // 定义GpsTrackerService类继承Service并实现多个监听器接口 // 这是Android后台服务用于持续追踪GPS位置并上传到服务器 public class GpsTrackerService extends Service implements IServerListener, ILocationListener, IUploadListener, ISerialDataReceiverListener { // 定义日志标签用于LogCat日志标识 private static final String TAG GpsTrackerService; ​ // 静态上下文引用用于全局访问 private static Context mContext null; ​ // 广播接收器实例用于接收系统广播和自定义广播 private TrackerBroadCastReceiver imReceiver null; ​ // 连接管理器用于监控网络状态 private ConnectivityManager mConnectivityManager null; ​ // 电话管理器用于获取SIM卡信息、信号强度等 private static TelephonyManager tmManager null; ​ // 上传管理器负责位置数据上传到服务器 private UploadManager mUploadManager null; ​ // 远程事件管理器处理远程控制事件 private RemoteEventManager mRemoteEventManager null; ​ // 应用程序实例引用 private static TrackerApplication mApp null; ​ // PendingIntent对象集合用于AlarmManager定时任务 private PendingIntent mHeatBeatPi null; // 心跳包定时器 private PendingIntent mTimeOutPi null; // 超时检测定时器 private PendingIntent mReconnectPi null; // 重连服务器定时器 private PendingIntent mDelayUploadPi null; // 延迟上传定时器 private PendingIntent mOpenVibrateAlarmPi null; // 开启震动报警定时器 private PendingIntent mSatelliteCountPi null; // 卫星数量检测定时器 private PendingIntent mUploadFilePi null; // 文件上传定时器 private PendingIntent mPingAddressPi null; // Ping地址检测定时器 private PendingIntent mTimerPicturePi null; // 定时拍照定时器 private int mGPSUploadTime Constant.LOCATION_UPLOAD_VALUE; // GPS上传时间间隔默认值 ​ // 定时拍照间隔时间长整型单位毫秒 private long mTimerPicInterval 0L; ​ // 位置计数用于统计位置数据点数量 private int mLocationCount 1; ​ // 文件上传状态标志true表示允许上传 private boolean UploadFileState true; ​ // Ping地址检测标志true表示启用Ping检测 private boolean mPingAddressFlag true; ​ // 最后方位角用于计算方向变化 private static float mLastBearing 0; ​ // 位置定时器用于定时获取位置 private Timer mLocationTimer null; ​ // 位置定时任务 private TimerTask mLocationTimerTask null; ​ // 位置信息链表存储待上传的位置数据 // 设计模式分析使用LinkedList存储位置历史适合频繁的插入删除操作 // 数据流结构大小每条LocationInfo约100-200字节默认可能存储100-1000条数据 private static LinkedListLocationInfo mSaveLocationList new LinkedListLocationInfo(); ​ // 极密云查询IP标志 private boolean mJimiyunQueryIP false; ​ // 核心套件标志标识是否使用核心功能模块 private boolean isCoreKit true; ​ // 视频相关标志位 private boolean mVideoflag false; // 视频标志 private boolean mVideoUploading false; // 视频上传中标志 private boolean mFileUploadFlag false; // 文件上传标志 ​ // 自检计数 private int mCheckSelfNum; ​ // 文件ID和蓝牙状态字符串变量 String GetFlieIdnull; // 获取的文件ID String BtStatus; // 蓝牙状态 ​ // 超时检测定时器和任务 private TimerTask mTimeoutTask; // 超时任务 private Timer mTimer; // 超时定时器 ​ /** * 文件重新上传允许的最大次数默认5次范围[1,10] * 性能分析限制重传次数防止无限重传消耗资源 */ private int fileReUploadNumberOfTimes; ​ /** * 文件重新上传时间间隔默认3秒范围[1,30] * 性能分析合理设置重传间隔避免网络拥塞 */ private int fileReUploadTimeInterval; ​ /** * 文件重新上传计数 * 设计模式分析使用AtomicInteger保证线程安全的计数器 * 性能分析原子操作避免多线程竞争问题 */ private AtomicInteger fileReUplaodCount new AtomicInteger(); ​ // TCP状态检查相关变量 private PendingIntent mTcpStatusCheck null; // TCP状态检查定时器 private boolean mTcpStatus false; // TCP连接状态 private int mTcpStatusCount 0; // TCP状态检查计数 private long mGetSaveTime 0; // 保存的时间戳 ​ // ljl add 20200519 - 注释说明2020年5月19日ljl添加 private boolean sensor_shocked_flag false; // 传感器震动标志 private int currentGpsfixStatus -1; // 当前GPS定位状态-1表示未知 ​ // 服务创建时调用的生命周期方法 Override public void onCreate() { // 调用父类的onCreate方法 super.onCreate(); // 设置上下文引用为当前服务上下文 mContext this; // 获取应用程序单例实例 mApp TrackerApplication.getInstance(); // 获取连接管理器系统服务 mConnectivityManager (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE); // 获取电话管理器系统服务 tmManager (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE); // 创建上传管理器实例传入上下文和监听器 mUploadManager new UploadManager(mContext, this); // 设置应用程序的上传管理器 mApp.setUploadManager(mUploadManager); ​ // 创建远程事件管理器 mRemoteEventManager new RemoteEventManager(mContext); // 获取系统属性中的公司值 String GetvalueUtils.getSystemProperties(Constant.SET_COMPANY_VALUE, ); // 记录日志onCreate方法调用和获取的值 LogUtils.saveLogFile(TAG, onCreate GetvalueGetvalue); // 设置系统属性保持配置一致性 Utils.setSystemProperties(mContext,Constant.SET_COMPANY_VALUE,Getvalue); ​ // 获取核心套件配置值 int CoreKitValue Utils.getGlobalInt(mContext, Constant.IS_CORE_KIT, Constant.IS_CORE_KIT_DEFAULT); // 记录核心套件值 LogUtils.saveLogFile(TAG, onCreate CoreKitValueCoreKitValue); // 根据配置值设置isCoreKit标志 if(CoreKitValue1) isCoreKit true; else{ isCoreKit false; } // 设置设备信息的核心套件状态 mApp.getDeviceInfo().setCoreKit(isCoreKit); // 记录isCoreKit状态 LogUtils.saveLogFile(TAG, onCreate isCoreKitisCoreKit); // 如果使用核心套件 if (isCoreKit) { // 启用极密云IP查询 mJimiyunQueryIP true; // 获取JM指令控制器单例并设置服务器监听器 JMOrderControll.getInstance(mContext).setServerListener(this); // 初始化JM指令控制器 JMOrderControll.getInstance(mContext).init(); // 获取保存的时间戳 mGetSaveTimeUtils.getGlobalLong(mContext, Constant.GET_CURRENT_TIME, System.currentTimeMillis()/1000); // 记录时间戳信息 LogUtils.saveLogFile(TAG, mGetSaveTimemGetSaveTime mGetCurrtentTimeSystem.currentTimeMillis()/1000); // 检查是否超过12小时未重启 if(SystemClock.elapsedRealtime()-mGetSaveTime12*60*60*1000){ // 设置重启标志为0不需要重启 Utils.putGlobalInt(mContext, Constant.IS_REBOOT_FLAG, 0); } // 记录重启标志状态 LogUtils.saveLogFile(TAG, IS_REBOOT_FLAG000Utils.getGlobalInt(mContext, Constant.IS_REBOOT_FLAG, 0)); // 设置TCP状态检查闹钟 setTcpStatusAlarm(SystemClock.elapsedRealtime()Constant.DEFAULT_CHECK_TCP_TIME); // 重置TCP状态计数 mTcpStatusCount0; // 获取内容解析器 final ContentResolver cr mContext.getContentResolver(); // 检查飞行模式状态 int isAirPlaneModegSettings.Global.getInt(cr, Settings.Global.AIRPLANE_MODE_ON,0); // 记录飞行模式状态 LogUtils.saveLogFile(TAG, isAirPlaneModegisAirPlaneModeg); // 如果飞行模式开启则关闭飞行模式 if(isAirPlaneModeg1) { Settings.Global.putInt(cr, Settings.Global.AIRPLANE_MODE_ON, 0); Intent intent new Intent(Intent.ACTION_AIRPLANE_MODE_CHANGED); intent.putExtra(state, false); mContext.sendBroadcast(intent); } } else { // 非核心套件模式设置Netty控制器和JM指令控制器的监听器 NettyControll.getInstance(mContext).setIServerListener(this); JMOrderControll.getInstance(mContext).setServerListener(this); JMOrderControll.getInstance(mContext).init(); } // 获取相机镜像状态配置 String cameraRetationStatus Utils.getGlobalString(mContext, Constant.CAMERA_MIRROR_FLAG, Constant.CAMERA_NO_MIRROR); // 记录相机镜像状态 LogUtils.saveLogFile(TAG, onCreate#cameraRetationStatus: cameraRetationStatus); // 如果配置为开启镜像则设置相机镜像 if(Constant.ON.equals(cameraRetationStatus)){ gmMisc.GM_Cam_Mirror_ctrl(1); // 调用第三方库设置相机镜像 } ​ // 获取蓝牙状态配置 BtStatus Utils.getGlobalString(mContext,Constant.BT_STATUS_SW, Constant.BT_STATUS); // 记录蓝牙状态 LogUtils.saveLogFile(TAG, onCreate#BtStatus: BtStatus); // 如果ACC开启且蓝牙配置为开启则打开蓝牙 if (Utils.isAccOn()(Constant.ON.equals(BtStatus))) { Utils.openBt(); } // 获取GPS控制器单例并设置位置变化监听器 GpsControll.getInstance(mContext).setLocationChangeListener(this); // 添加GPS或电话状态监听 addGpsOrTelStatusListen(); ​ // 获取XML解析工厂单例并解析XML配置 XmlParseFactory.getInstance(mContext).parseXml(); // 获取闹钟控制器单例 AlarmControll.getIntance(mContext); // 获取读卡器管理器单例 CardReaderManager.getIntance(mContext); ​ // 获取外部设备工厂单例并打开RS232电源 ExternalDeviceFactory.getInstance(mContext).rsr232PowerOn(); // 获取G传感器传输管理器单例并初始化 GsensorTransManager.getInstance(mContext).init(); // 注册广播接收器 registerBroadCast(); // 初始化追踪器状态 initTrackerStatus(); ​ // 注册自动测试 registerAutoTest(); // UART接收检测 AlarmControll.getIntance(mContext).UartRxDetect(); } ​ // 初始化追踪器状态方法 private void initTrackerStatus() { // 获取继电器状态配置 int relayStatus Utils .getGlobalInt(mContext, Constant.RELAY_STATUS, 0); // 设置继电器控制 gmMisc.GM_Relay_Ctrl(relayStatus); ​ // 获取震动灵敏度配置 int vibraSensitivity (Integer) SPUtils.get( Constant.VIBRATE_SENSITIVITY, Constant.VIBRATE_SENSITIVITY_DEFAULT); // 设置震动灵敏度 gmMisc.GM_Gsensor_Guard_Sensitivity(Utils .getVibrationSensitivity(vibraSensitivity)); ​ // 获取碰撞灵敏度配置 int crashSensitivity (Integer) SPUtils.get( Constant.CRASH_SENSITIVITY, Constant.CRASH_SENSITIVITY_DEFAULT); // 设置碰撞灵敏度 gmMisc.GM_Gsensor_Shock_Sensitivity(Utils .getCrashSensitivity(crashSensitivity)); // 获取G传感器范围配置 int gsensorRange (Integer) SPUtils.get(Constant.GSENSOR_RANGE, 2); // 设置G传感器范围 gmMisc.GM_gsensor_set_range(gsensorRange); // 开启G传感器震动检测 gsensorShockOpen(); ​ // 获取静态过滤器开关配置 String sfSwitch Utils.getGlobalString(mContext, Constant.SF_SWITCH, Constant.ON); // 根据配置设置静态过滤器状态 boolean status Constant.ON.equals(sfSwitch); mApp.getDeviceInfo().setmStaticFilter(status); ​ // 获取重启状态配置 int restartStatus Utils.getGlobalInt(mContext, Constant.RESTART_SHUTDOWN, Constant.TYPE_REBOOT_UNKNOW); // 记录重启状态 LogUtils.saveLogFile(TAG, initTrackerStatus#restartStatus: restartStatus); ​ // 处理重启状态逻辑 if (restartStatus Constant.TYPE_REBOOT_UNKNOW) { // 未知状态设置为正常重启 Utils.putGlobalInt(mContext, Constant.RESTART_SHUTDOWN, Constant.TYPE_REBOOT_NORMAL); } else if (restartStatus Constant.TYPE_REBOOT_OVER) { // 重启完成状态设置为异常重启 Utils.putGlobalInt(mContext, Constant.RESTART_SHUTDOWN, Constant.TYPE_REBOOT_ABNORMAL); } ​ // 延迟10秒发送获取设备状态消息 mHandler.sendEmptyMessageDelayed(Constant.MSG_GET_DEVICE_STATE, 10 * 1000); ​ // 延迟10秒发送WiFi AP状态消息 mHandler.sendEmptyMessageDelayed(Constant.MSG_WIFI_AP_STATE, 10 * 1000); ​ // 获取GPS定时上传开关配置 String uploadSw Utils.getGlobalString(mContext, Constant.GPS_TIMING_UPLOAD_SWITCH, Constant.GPS_TIMING_UPLOAD_SWITCH_DEFAULT); // 如果GPS定时上传开启 if (Constant.ON.equals(uploadSw)) { mApp.getDeviceInfo().setmGPSTimingUpload(true); // 发送位置上传消息 mHandler.obtainMessage(Constant.MSG_LOCATION_UPLOAD).sendToTarget(); } ​ // 获取定时拍照开关配置 String timePicSw (String) SPUtils.get(Constant.TIMER_PICTURE_SWITCH, Constant.OFF); // 如果定时拍照开启 if (Constant.ON.equals(timePicSw)) { mApp.getDeviceInfo().setmTimerPicture(true); // 获取定时拍照间隔时间 mTimerPicInterval (Long) SPUtils.get( Constant.TIMER_PICTURE_INTERVAL, Constant.DEFAULT_TIMER_PICTURE_INTERVAL); // 设置定时拍照闹钟 setTimerPictureAlarm(SystemClock.elapsedRealtime() mTimerPicInterval); } ​ // 设置串口数据接收监听器 SerialPortUtil.getInstance().setOnSerialDataReceiveListener(this); // 启动串口通信 boolean openResult SerialPortUtil.getInstance().start(); // 记录串口打开结果 LogUtils.saveLogFile(TAG, openResult# openResult); // 获取G传感器校准结果 String gCalibratResult (String) SPUtils.get( Constant.GSENSOR_CALIBRAT_RESULT, ); // 记录校准结果 LogUtils.saveLogFile(TAG, gCalibratResult# gCalibratResult); // 如果校准结果不为空则设置校准数据 if (!TextUtils.isEmpty(gCalibratResult)) { int[] array Utils.stringToIntArray(gCalibratResult); gmMisc.GM_gsensor_set_cali_data(array); } ​ // 获取油量传感器ID配置 int firstOilId Utils.getGlobalInt(mContext, Constant.FIRST_OILID, -1); int secondOilId Utils.getGlobalInt(mContext, Constant.SECOND_OILID, -1); // 设置油量传感器ID到设备信息 mApp.getDeviceInfo() .setmFirstOilId((firstOilId -1) ? 1 : firstOilId); mApp.getDeviceInfo().setmSecondOilId( (secondOilId -1) ? 2 : secondOilId); // 设置设备正常重启状态为false SPUtils.put(Constant.DEVICE_NORMAL_REBOOT_STATE, false); } ​ // 注册广播接收器方法 private void registerBroadCast() { // 创建意图过滤器 IntentFilter filter new IntentFilter(); // 添加短信接收广播动作 filter.addAction(Constant.ACTION_SMS_RECEIVED); // 添加心跳包广播动作 filter.addAction(Constant.ACTION_HEART_BEAT); // 添加重连服务器广播动作 filter.addAction(Constant.ACTION_RECONNECT_SERVER); // 添加网络连接状态变化广播动作 filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION); // 添加RTMP超时广播动作 filter.addAction(Constant.ACTION_RTMP_TIMEOUT); // 添加行车记录仪远程控制广播动作 filter.addAction(Constant.ACTION_CARRECORDER_REMOTE); // 添加下载完成广播动作 filter.addAction(DownloadManager.ACTION_DOWNLOAD_COMPLETE); // 添加移动事件广播动作 filter.addAction(Constant.ACTION_MOVE_EVENT); // 添加行车记录仪开始倒车广播动作 filter.addAction(Constant.CARRECORDER_START_BACK_ACTION); // 添加消息超时广播动作 filter.addAction(Constant.ACTION_MESSAGE_TIMEOUT); // 添加自定义按键事件广播动作 filter.addAction(Constant.CUSTOM_EINTKEY_EVENT); // 添加自定义ACC开启广播动作 filter.addAction(Constant.ACTION_CUSTOM_ACCON); // 添加自定义ACC关闭广播动作 filter.addAction(Constant.ACTION_CUSTOM_ACCOFF); // 添加关机广播动作 filter.addAction(Intent.ACTION_SHUTDOWN); // 添加上传事件文件广播动作 filter.addAction(Constant.ACTION_UPLOAD_EVENT_FILE); // 添加开始上传事件文件广播动作 filter.addAction(Constant.ACTION_START_UPLOAD_EVENT_FILE); // 添加延迟上传文件广播动作 filter.addAction(Constant.ACTION_DELAY_UPLOAD_FILE); // 添加开启G传感器防护广播动作 filter.addAction(Constant.ACTION_OPEN_GSENSOR_GUARD); // 添加卫星状态广播动作 filter.addAction(Constant.ACTION_SATELLITE_STATUS); // 添加系统更新广播动作 filter.addAction(Constant.ACTION_UPDATE_SYSTEM); // 添加上传文件状态广播动作 filter.addAction(Constant.ACTION_UPLOAD_FILE_STATE); // 添加Ping地址广播动作 filter.addAction(Constant.ACTION_PING_ADDRESS); // 添加状态错误广播动作 filter.addAction(Constant.ACTION_STATUS_ERROR); // 添加事件文件上传广播动作 filter.addAction(Constant.ACTION_EVENT_FILE_UPLOAD); // 添加历史文件上传广播动作 filter.addAction(Constant.ACTION_HISTTORY_FILE_UPLOAD); // 添加DMS上传事件文件广播动作 filter.addAction(Constant.DMS_UPLOAD_EVENT_FILE); // 添加DMS事件报警广播动作 filter.addAction(Constant.DMS_EVENT_ALARM); // 添加实时视频命令广播动作 filter.addAction(Constant.CMD_REALVIDEO); // 添加定时拍照广播动作 filter.addAction(Constant.ACTION_TIMER_PICTURE); // 添加GPS定时更新广播动作 filter.addAction(Constant.ACTION_GPS_TIMING_UPDATE); // 添加SOS值广播动作 filter.addAction(Constant.ACTION_SOS_VALUE); // 添加时区变化广播动作监控 filter.addAction(Intent.ACTION_TIMEZONE_CHANGED); // 添加电源电池切断广播动作 filter.addAction(Constant.ACTION_POWER_BATTERY_CUT); // 添加延迟启动WiFi AP广播动作 filter.addAction(Constant.ACTION_DELAY_START_WIFIAP); // 添加停止重启行车记录仪广播动作 filter.addAction(Constant.ACTION_STOP_RESTART_CARECORD); ​ // 添加检查TCP连接状态广播动作 filter.addAction(Constant.ACTION_CHECK_TCP_CONNECT_STATUS); // 添加WiFi状态变化广播动作 filter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION); // 添加AMS在线命令动作广播 filter.addAction(Constant.ACTION_AMS_ONLINE_COMMAND); // 创建广播接收器实例 imReceiver new TrackerBroadCastReceiver(mHandler); // 注册广播接收器 registerReceiver(imReceiver, filter); } ​ // IServerListener接口的消息接收回调方法 // 设计模式分析观察者模式 - 监听网络消息接收 // 运行性能分析消息处理在主线程应快速处理避免阻塞 Override public void OnMessageReceive(byte[] msg) { // 检查消息CRC校验 if (!ByteArrayUtils.checkMsgCRC(msg)) { return; // CRC校验失败直接返回不处理 } ​ // 根据消息类型进行不同处理 // msg[3]是协议类型字节 if (msg[3] Constant.PROTOCOL_TYPE_SIGN_IN[0]) { // 登录协议消息处理 // 重新上传0x69命令消息和文件 reUpload69CommandMessageAndFile(); signInSuccess(); // 登录成功处理 } else if (msg[3] Constant.PROTOCOL_TYPE_HEARTBEAT[0]) { // 心跳协议消息处理 LogUtils.saveLogFile(TAG, locationCache size: mSaveLocationList.size()); mSaveLocationList.clear(); // 清空位置缓存列表 cancleTimeOutAlarm(); // 取消超时闹钟 mHandler.obtainMessage(Constant.MSG_UPLOAD_LOGIN_STATE) .sendToTarget(); // 发送上传登录状态消息 } else if (msg[3] Constant.PROTOCOL_TYPE_80[0]) { // 0x80协议消息处理远程控制命令 RemoteEvent event MessageFactory.getInstance(mContext) .handleTcpMessage(msg); // 工厂模式创建远程事件对象 if (event ! null) { executeRemoteEvent(event); // 执行远程事件 } } } ​ /** * 重新上传0x69命令消息和文件 * 功能分析网络重连后恢复上传状态 * 性能分析重新上传可能涉及文件IO操作需考虑内存和存储使用 */ private void reUpload69CommandMessageAndFile() { // 重新上传文件 mUploadManager.fileReupload(); // 重新上传本地G传感器数据文件 // 通知GsensorTransManager重新上传G传感器数据文件 if (!isCoreKit) { // 非核心套件模式下 GsensorTransManager.getInstance(this).onNetWorkStateChangedOk(); } // 重新上传0x69命令消息 reUpload69CommandMessage(); } ​ // IServerListener接口的连接状态变化回调方法 Override public void OnConnectStatusChange(int statusCode) { LogUtils.saveLogFile(TAG, OnConnectStatusChange statusCode : statusCode); if (statusCode Constant.CONNECT_SUCCESS) { // 连接成功处理 if (!isCoreKit) { // 非核心套件模式 NettyControll.getInstance(mContext).setReconnectStatus(false); // 设置重连状态为false cancleReconnectAlarm(); // 取消重连闹钟 sendSignInMsg(); // 发送登录消息 } else { // 核心套件模式 signInSuccess(); // 直接调用登录成功处理 } ​ // 检查崩溃日志检查状态 if (!LogUtils.getIntance().isChecked) { LogUtils.getIntance().startCrashLogSizeCheck(); // 启动崩溃日志大小检查 } } else { // 连接失败处理 if (!isCoreKit) { // 非核心套件模式 cancleHeartBeatAlarm(); // 取消心跳闹钟 long reconnectInerval NettyControll.getInstance(mContext) .getReconnectIntervalTime(); // 获取重连间隔时间 NettyControll.getInstance(mContext).setReconnectStatus(true); // 设置重连状态为true setReconnectAlarm(SystemClock.elapsedRealtime() reconnectInerval); // 设置重连闹钟 } else { // 核心套件模式 LogUtils.saveLogFile(TAG, OnConnectStatusChange networkAvailable : isNetworkAvailable()); // 记录网络可用状态 if(isNetworkAvailable()) // 如果网络可用 JMOrderControll.getInstance(mContext).startConnect(); // 启动JM指令控制器连接 } } } ​ // Service绑定回调方法 // 设计模式分析Android服务生命周期模式 public IBinder onBind(Intent arg0) { return null; // 返回null表示不支持绑定服务 } ​ // ILocationListener接口的位置变化回调方法 // 设计模式分析观察者模式 - 监听位置变化 // 数据流结构LocationInfo对象约100-200字节每秒可能产生多条数据 Override public void onLocationChanged(LocationInfo info) { mLocationCount; // 位置计数增加 Constant.mGpsLocState true; // 设置GPS定位状态为true timeSync(info); // 时间同步 // 获取上一个位置信息 LocationInfo lastInfo GpsControll.getInstance(mContext) .getLastLocationInfo(); if (lastInfo ! null) { // 计算两个位置之间的距离 double dbDistance DistanceCalcUtils.getDistance( lastInfo.getLongitude(), lastInfo.getLatitude(), info.getLongitude(), info.getLatitude()); long lastLocationTime lastInfo.getTime(); double times (double) (info.getTime() - lastLocationTime) / 1000; // 计算时间差秒 // 注释掉的异常位置过滤逻辑保留供参考 // if (times 0 || dbDistance Constant.MAX_CAR_MOVE_DISTANCE_SENCONDS * times) { // LogUtils.saveLogFile(TAG, // dbDistance: dbDistance ,timeDiff: times // ,lastInfo time: lastInfo.getTime()); // return; // } ​ // 获取最后上传的位置信息 LocationInfo lastupload GpsControll.getInstance(mContext).getmLastUploadInfo(); if (lastupload ! null) { // ljl add 20200519 - 2020年5月19日添加的优化 // 使用分辨率过滤器抑制漂移数据 boolean isfilter Resolution.getResolution().inhibitDriftData(sensor_shocked_flag, GpsControll.getInstance(mContext).getSatelliteCount(),GpsControll.getInstance(mContext).getSnr_average(), info.getSpeed(),lastInfo.getSpeed(),info,lastInfo,lastupload); if (isfilter) { // 如果被过滤 // TrackerApplication.speech(静态漂移数据抑制); // LogUtils.saveLogFile(TAG, gps data isfilter); return; // 直接返回不上传此位置数据 } else { // 计算里程 DistanceCalcUtils.calculateMileage(times,info.getSpeed(),dbDistance); } } else { // 计算里程 DistanceCalcUtils.calculateMileage(times,info.getSpeed(),dbDistance); } } ​ // 低速状态处理速度小于等于1 if (info.getSpeed() 1) { boolean staticFilter mApp.getDeviceInfo().ismStaticFilter(); // 获取静态过滤器状态 if (!staticFilter (mLocationCount mGPSUploadTime)) { // 设置上传模式和补充信息 info.setMode(Constant.UPDATE_MODE[0]); info.setSupply(Constant.UPDATE_REALTIME[0]); mLocationCount 0; // 重置位置计数 LogUtils.saveLogFile(TAG, static upload); // 记录静态上传日志 sendLocationInfoMsg(info); // 发送位置信息消息 GpsControll.getInstance(mContext).setmLastUploadInfo(info); // 设置最后上传信息 ljl add 20200519 } } else { // 高速状态处理 if (mLocationCount mGPSUploadTime) { // 达到上传时间间隔 if (!mApp.getDeviceInfo().ismGPSTimingUpload()) { // 如果不是GPS定时上传模式 // 获取GPS时间间隔配置 mGPSUploadTime Utils.getGlobalInt(mContext, Constant.GPS_TIME, Constant.LOCATION_UPLOAD_VALUE); mLocationCount 0; // 重置位置计数 info.setMode(Constant.UPDATE_MODE[0]); // 设置上传模式 info.setSupply(Constant.UPDATE_REALTIME[0]); // 设置补充信息 LogUtils.saveLogFile(TAG, Normal upload); // 记录正常上传日志 sendLocationInfoMsg(info); // 发送位置信息消息 GpsControll.getInstance(mContext).setmLastUploadInfo(info); // 设置最后上传信息 ljl add 20200519 } } else if (checkGpsBearing(info)) { // 检查GPS方向变化 sendLocationInfoMsg(info); // 发送位置信息消息 GpsControll.getInstance(mContext).setmLastUploadInfo(info); // 设置最后上传信息 ljl add 20200519 } mLastBearing info.getBearing(); // 更新最后方位角 } // 更新最后位置信息 GpsControll.getInstance(mContext).setLastLocationInfo(info); // 处理位置信息相关的闹钟控制 AlarmControll.getIntance(mContext).handleLocationInfo(info); // 更新读卡器管理器的速度信息 CardReaderManager.getIntance(mContext).updateSpeedometer(info); // 驾驶行为分析 driveBehaviorAnalysis(info.getSpeed(),info.getBearing()); } ​ // ILocationListener接口的GPS状态变化回调方法 Override public void onGpsStateChanged(int state) { // GPS状态变化处理当前为空实现 } ​ // ISerialDataReceiverListener接口的数据接收回调方法 // 设计模式分析观察者模式 - 监听串口数据接收 // 数据流结构buffer数组大小根据串口协议定义通常64-1024字节 Override public void onDataReceive(byte[] buffer, int size) { // 记录接收到的原始数据十六进制格式 LogUtils.saveLogFile( TAG, onDataReceive#buffer: ByteArrayUtils.bytesToHexString(buffer)); // 使用外部设备工厂解析缓冲区数据 // 设计模式工厂模式 - 解析不同类型的设备数据 int result ExternalDeviceFactory.getInstance(mContext).parseBuffer( buffer); switch (result) { // 根据解析结果进行不同处理 case ExternalDeviceFactory.SWIPE_CARD_DATA_TRANS: // 刷卡数据传输 CardReaderManager.getIntance(mContext).swipeCardIdentityInfoReport(buffer); break; case ExternalDeviceFactory.OIL_DATA_TRANS: // 油量数据传输 // 获取第一和第二油量液压值 float oilHydraulicFirst mApp.getDeviceInfo() .getmFirstOilHydraulic(); float oilHydraulicSecond mApp.getDeviceInfo() .getmSecondOilHydraulic(); // 如果有有效的油量数据 if (oilHydraulicFirst ! -1 || oilHydraulicSecond ! -1) { // 使用消息工厂创建油量传输消息包 byte[] oilMsg MessageFactory.getInstance(mContext) .oilTransPackageSend(oilHydraulicFirst, oilHydraulicSecond); sendMessageToServer(oilMsg); // 发送消息到服务器 } // 获取闹钟控制器实例 AlarmControll controll AlarmControll.getIntance(mContext); controll.checkOilSteal(oilHydraulicFirst, oilHydraulicSecond); // 检查偷油 controll.cancleExternalDeviceTimeOutAlarm(); // 取消外部设备超时闹钟 break; case ExternalDeviceFactory.TEMP_DATA_TRANS: // 温度数据传输 if (mApp.getDeviceInfo().ismTempDataTrans()) { // 如果允许温度数据传输 // 使用消息工厂创建温度传输消息包 byte[] tempMsg MessageFactory.getInstance(mContext) .transPackageSend(buffer,Constant.MESSAGE_TYPE_TEMPERATURE_TRANS); sendMessageToServer(tempMsg); // 发送消息到服务器 mApp.getDeviceInfo().setmTempDataTrans(false); // 设置温度数据传输标志为false } AlarmControll.getIntance(mContext) .cancleExternalDeviceTimeOutAlarm(); // 取消外部设备超时闹钟 break; case ExternalDeviceFactory.RFID_DATA_TRANS: // RFID数据传输 long timeMills System.currentTimeMillis(); // 获取当前时间戳 String fileName Utils.createRfidFileName(mContext, timeMills, Constant.ALARM_RFID, mApp.getDeviceInfo().getmRfidNum()); // 创建RFID文件名 LocationInfo rfidInfo GpsControll.getInstance(mContext) .getCurrentLocInfo(); // 获取当前位置信息 // 使用消息工厂创建报警消息包 byte[] msg MessageFactory.getInstance(mContext) .alarmPackageSend(Constant.ALARM_RFID, timeMills, 0, fileName, rfidInfo); // 创建时间格式化对象 SimpleDateFormat sf new SimpleDateFormat( yyyy_MM_dd_HH_mm_ss); // 启动服务进行拍照 Utils.startToService(mContext, , FileActionType.ACTION_TYPE_IDENTIFICATION, Constant.REMOTE_PICTURE_IN, 0, 0, sf.format(new Date(timeMills)), fileName); // 播放刷卡成功语音提示 CardReaderManager.getIntance(mContext).playVoicePromot(AudioFileKey.AUDIO_SWIPE_SUCCESSFUL); break; case ExternalDeviceFactory.RFID_DATA_ERROR: // RFID数据错误 // 播放刷卡失败语音提示 CardReaderManager.getIntance(mContext).playVoicePromot(AudioFileKey.AUDIO_SWIPE_FAILED_PLEASE_TRY_AGAIN); break; default: // 默认情况 break; } } ​ // 检查GPS方位角变化方法 // 功能分析根据方向变化决定是否触发重新上传 private boolean checkGpsBearing(LocationInfo location) { // 获取方位角重新上传开关配置 boolean gpsBearingSw (Boolean) SPUtils.get( Constant.ANGLE_REUPLOAD_SWITCH, true); // 如果GPS定时上传开启或方位角重新上传关闭返回false if (mApp.getDeviceInfo().ismGPSTimingUpload() || !gpsBearingSw) { return false; } // 获取角度变化阈值配置 int angleDiff (Integer) SPUtils.get(Constant.ANGLE_CHANGE_THRESHOLD, Constant.DEFAULT_ANGLE_CHANGE_THRESHOLD); float currBearing location.getBearing(); // 当前方位角 float flAngle Utils.calculateBearingDiff(mLastBearing, currBearing); // 计算方位角差值 if (flAngle angleDiff) { // 如果角度变化超过阈值 location.setMode(Constant.UPDATE_MODE[2]); // 设置上传模式为角度变化 location.setSupply(Constant.UPDATE_REALTIME[0]); // 设置补充信息 LogUtils.saveLogFile(TAG, checkGpsBearing flAngle flAngle); // 记录日志 return true; // 返回true需要上传 } return false; // 返回false不需要上传 } ​ // IUploadListener接口的上传响应回调方法旧版本 // 设计模式分析观察者模式 - 监听上传结果 Override public void onUploadResponse(boolean result, String filePath) { LogUtils.saveLogFile(TAG, onUploadResponse#result: result ,filePath: filePath); mUploadManager.updateUploadState(false); // 更新上传状态为false if (result) { // 上传成功 if (isCoreKit) { // 核心套件模式 DBHelper.getInstance(mContext).deleteUploadFileInfo(filePath); // 从数据库删除上传文件信息 } else { // 非核心套件模式 mUploadManager.updateDb(null, filePath, -1, null, -1, null, -1, UploadManager.UPDATE_DELETE,-1,-1); // 更新数据库删除操作 } // 如果当前文件上传成功重置计数 fileReUplaodCount.set(0); // 10秒后调用UploadManager类的fileReupload方法 // 如果UploadManager类的mUploadState变量为false且网络可用开始上传下一个文件 setDelayUploadAlarm(SystemClock.elapsedRealtime() UploadManager.DELAY_UPLOAD_INTERVALS); } else { // 上传失败 if (UploadFileState) { // 如果上传文件状态为true UploadFileState false; // 设置上传文件状态为false Utils.putGlobalString(mContext, Constant.TRACKER_QINIU, Constant.QINIU_UPLOAD_FAIL); // 记录七牛上传失败状态 if (Constant.AMS_STATE_FLAG) { // 如果AMS状态标志为true mHandler.obtainMessage(Constant.MSG_GET_DEVICE_STATE) .sendToTarget(); // 发送获取设备状态消息 } // 5分钟后将UploadFileState设置为true setUploadFileState(SystemClock.elapsedRealtime() Constant.DEFAULT_UPLOAD_FILE_STATUS_TIME); } // 获取文件重新上传允许的最大次数和上传时间间隔 getFileReUploadTimesAndInterval(); LogUtils.saveLogFile(TAG, onUploadResponse#fileReUplaodCount-1 fileReUplaodCount.get() , fileReUploadNumberOfTimes fileReUploadNumberOfTimes , fileReUploadTimeInterval fileReUploadTimeInterval); if (fileReUplaodCount.getAndIncrement() fileReUploadNumberOfTimes) { // 如果重试次数未达到最大值 LogUtils.saveLogFile(TAG, onUploadResponse#fileReUplaodCount-2 fileReUplaodCount.get()); // fileReUploadTimeInterval分钟后重新上传当前文件 // 如果UploadManager类的mUploadState变量为false且网络可用开始上传下一个文件 setDelayUploadAlarm(SystemClock.elapsedRealtime() fileReUploadTimeInterval * 60 * 1000); } else { // 如果达到最大重试次数 LogUtils.saveLogFile(TAG, onUploadResponse# return fileReUplaodCount fileReUplaodCount.get()); // 如果达到最大次数重置计数 fileReUplaodCount.set(0); return; } } } ​ // IUploadListener接口的上传响应回调方法新版本带文件名参数 // 功能分析支持基于文件名的数据库操作更精确的文件管理 Override public void onUploadResponseResult(boolean result, String filePath,String filename) { LogUtils.saveLogFile(TAG, onUploadResponse#result2222: result ,filePath: filePath); mUploadManager.updateUploadState(false); // 更新上传状态为false if (result) { // 上传成功 if (isCoreKit) { // 核心套件模式 LogUtils.saveLogFile(TAG, onUploadResponse#result2222: result ,filename: filename); // DBHelper.getInstance(mContext).deleteUploadFileInfo(filePath); // 注释掉的旧方法 DBHelper.getInstance(mContext).deleteUploadFileNameInfo(filename); // 根据文件名删除上传文件信息 } else { // 非核心套件模式 mUploadManager.updateDb(null, filePath, -1, null, -1, null, -1, UploadManager.UPDATE_DELETE,-1,-1); // 更新数据库删除操作 } // 如果当前文件上传成功重置计数 fileReUplaodCount.set(0); // 10秒后调用UploadManager类的fileReupload方法 // 如果UploadManager类的mUploadState变量为false且网络可用开始上传下一个文件 setDelayUploadAlarm(SystemClock.elapsedRealtime() UploadManager.DELAY_UPLOAD_INTERVALS); } else { // 上传失败 if (UploadFileState) { // 如果上传文件状态为true UploadFileState false; // 设置上传文件状态为false Utils.putGlobalString(mContext, Constant.TRACKER_QINIU, Constant.QINIU_UPLOAD_FAIL); // 记录七牛上传失败状态 if (Constant.AMS_STATE_FLAG) { // 如果AMS状态标志为true mHandler.obtainMessage(Constant.MSG_GET_DEVICE_STATE) .sendToTarget(); // 发送获取设备状态消息 } // 5分钟后将UploadFileState设置为true setUploadFileState(SystemClock.elapsedRealtime() Constant.DEFAULT_UPLOAD_FILE_STATUS_TIME); } // 获取文件重新上传允许的最大次数和上传时间间隔 getFileReUploadTimesAndInterval(); LogUtils.saveLogFile(TAG, onUploadResponse#fileReUplaodCount-1 fileReUplaodCount.get() , fileReUploadNumberOfTimes fileReUploadNumberOfTimes , fileReUploadTimeInterval fileReUploadTimeInterval); if (fileReUplaodCount.getAndIncrement() fileReUploadNumberOfTimes) { // 如果重试次数未达到最大值 LogUtils.saveLogFile(TAG, onUploadResponse#fileReUplaodCount-2 fileReUplaodCount.get()); // fileReUploadTimeInterval分钟后重新上传当前文件 // 如果UploadManager类的mUploadState变量为false且网络可用开始上传下一个文件 setDelayUploadAlarm(SystemClock.elapsedRealtime() fileReUploadTimeInterval * 60 * 1000); } else { // 如果达到最大重试次数 LogUtils.saveLogFile(TAG, onUploadResponse# return fileReUplaodCount fileReUplaodCount.get()); // 如果达到最大次数重置计数 fileReUplaodCount.set(0); return; } } } // 碰撞事件文件上传方法 // 功能分析处理碰撞事件相关的文件上传逻辑 // 设计模式分析状态模式 - 根据isServerFlag参数执行不同路径 private void crashEventFileUpload(String msgContent, boolean isServerFlag) { if (TextUtils.isEmpty(msgContent)) { // 如果消息内容为空 return; // 直接返回 } ​ LogUtils.saveLogFile(TAG, msgContent: msgContent ,isServerFlag: isServerFlag); // 记录日志 String path null; // 文件路径 String serverFlag null; // 服务器标志 if (isServerFlag) { // 如果是服务器标志模式 serverFlag msgContent; // 服务器标志为消息内容 mApp.getDeviceInfo().setmCrashServerFlag(serverFlag); // 设置碰撞服务器标志 path mApp.getDeviceInfo().getmCrashFilePath(); // 获取碰撞文件路径 } else { // 如果是文件路径模式 path msgContent; // 路径为消息内容 mApp.getDeviceInfo().setmCrashFilePath(msgContent); // 设置碰撞文件路径 serverFlag mApp.getDeviceInfo().getmCrashServerFlag(); // 获取碰撞服务器标志 ​ // 获取远程开关配置 String remoteSw Utils.getGlobalString(mContext, Constant.REMOTE_SWITCH); ​ if (TextUtils.isEmpty(remoteSw)) { // 如果配置为空 remoteSw Constant.ON; // 默认设置为开启 } LogUtils.saveLogFile(TAG, crashEventFileUpload#remoteSw: remoteSw); // 记录远程开关状态 if (Constant.ON.equals(remoteSw)) { // 如果远程开关开启 LocationInfo info GpsControll.getInstance(mContext) .getLastLocationInfo(); // 获取最后位置信息 // 开始上传文件 startUploadFile(Constant.REMOTE_VIDEO_OUT, , msgContent, Constant.EVENT_TYPE_CRASH, getEventFileUploadName(path, null,Constant.REMOTE_VIDEO_OUT), -1); return; // 直接返回不执行后续逻辑 } } ​ // 如果路径和服务器标志都不为空 if (!TextUtils.isEmpty(path) !TextUtils.isEmpty(serverFlag)) { mApp.getDeviceInfo().setmCrashServerFlag(null); // 清空碰撞服务器标志 mApp.getDeviceInfo().setmCrashFilePath(null); // 清空碰撞文件路径 LocationInfo info GpsControll.getInstance(mContext) .getLastLocationInfo(); // 获取最后位置信息 // 开始上传文件 startUploadFile(Constant.REMOTE_VIDEO_OUT, , msgContent, Constant.EVENT_TYPE_CRASH, getEventFileUploadName(path, null,Constant.REMOTE_VIDEO_OUT), -1); } } ​ // 获取事件文件上传名称方法 // 功能分析生成规范的文件名格式 // 性能分析字符串拼接使用StringBuilder提高性能 private String getEventFileUploadName(String path, String serverFlag,int remoteType) { File file new File(path); // 创建文件对象 if (!file.exists()) { // 如果文件不存在 return null; // 返回null字符串 } StringBuilder sb new StringBuilder(); // 使用StringBuilder拼接字符串 sb.append(Constant.REMOTE_EVENT); // 添加远程事件前缀 sb.append(_); // 添加下划线分隔符 sb.append(Utils.getImeiForFile(mContext)); // 添加设备IMEI sb.append(_); // 添加下划线分隔符 sb.append(TextUtils.isEmpty(serverFlag) ? 00000000 : serverFlag); // 添加服务器标志或默认值 sb.append(_); // 添加下划线分隔符 int fileNameLength file.getName().length(); // 获取文件名长度 // 分割文件名前部分和后6位 String frontHalfName file.getName().substring(0,fileNameLength - 6); String afterHalfName file.getName().substring(fileNameLength - 6,fileNameLength); sb.append(frontHalfName); // 添加文件名前部分 sb.append(Utils.getFileCameraID(remoteType)); // 添加摄像头ID sb.append(_); // 添加下划线分隔符 sb.append(afterHalfName); // 添加文件名后部分 return sb.toString(); // 返回拼接后的文件名 } ​ // DMS事件文件上传方法 // 功能分析处理DMS驾驶员监控系统事件文件上传 // 数据流结构文件路径字符串、事件类型等参数 private void dmsEventFileUpload(String filePath, int actionType, String fileName,int eventType) { LogUtils.saveLogFile(TAG, dmsEventFileUpload); // 记录日志 if (TextUtils.isEmpty(filePath)||error.equals(filePath)) { // 如果文件路径为空或为error return; // 直接返回 } if(isCoreKit){ // 如果是核心套件模式 { LocationInfo info GpsControll.getInstance(mContext).getCurrentLocInfo(); // 获取当前位置信息 ​ StringBuilder sb new StringBuilder(); // 使用StringBuilder拼接参数 sb.append(Constant.REMOTE_VIDEO_IN); // 添加远程视频输入类型 sb.append(Constant.COMMA); // 添加逗号分隔符 sb.append(GetFlieId); // 添加文件ID sb.append(Constant.COMMA); // 添加逗号分隔符 sb.append(filePath); // 添加文件路径 sb.append(Constant.COMMA); // 添加逗号分隔符 sb.append(eventType); // 添加事件类型 sb.append(Constant.COMMA); // 添加逗号分隔符 sb.append(fileName); // 添加文件名 sb.append(Constant.COMMA); // 添加逗号分隔符 sb.append(actionType); // 添加动作类型 sb.append(Constant.COMMA); // 添加逗号分隔符 sb.append((info null) ? -1 : info.getLatitude()); // 添加纬度或默认值 sb.append(Constant.COMMA); // 添加逗号分隔符 sb.append((info null) ? -1 : info.getLongitude()); // 添加经度或默认值 // 调用上传管理器开始上传文件 mUploadManager.startUploadFile(sb.toString(), true,00000000); } }else{ // 非核心套件模式 startUploadFile(Constant.REMOTE_VIDEO_IN, 00000000, filePath, -1, fileName, actionType); // 调用通用上传方法 } } ​ // 开始上传文件方法通用 // 功能分析构建上传参数并启动文件上传 // 设计模式模板方法模式 - 定义文件上传的标准流程 private void startUploadFile(int dvrType, String fileId, String filePath, int eventType, String fileName, int actionType) { LocationInfo info GpsControll.getInstance(mContext).getCurrentLocInfo(); // 获取当前位置信息 StringBuilder sb new StringBuilder(); // 使用StringBuilder拼接参数 sb.append(dvrType); // 添加DVR类型 sb.append(Constant.COMMA); // 添加逗号分隔符 sb.append(fileId); // 添加文件ID sb.append(Constant.COMMA); // 添加逗号分隔符 sb.append(filePath); // 添加文件路径 sb.append(Constant.COMMA); // 添加逗号分隔符 sb.append(eventType); // 添加事件类型 sb.append(Constant.COMMA); // 添加逗号分隔符 sb.append(fileName); // 添加文件名 sb.append(Constant.COMMA); // 添加逗号分隔符 sb.append(actionType); // 添加动作类型 sb.append(Constant.COMMA); // 添加逗号分隔符 sb.append((info null) ? -1 : info.getLatitude()); // 添加纬度或默认值 sb.append(Constant.COMMA); // 添加逗号分隔符 sb.append((info null) ? -1 : info.getLongitude()); // 添加经度或默认值 mUploadManager.startUploadFile(sb.toString()); // 调用上传管理器开始上传 } ​ // ACC状态变化操作方法 // 功能分析处理车辆ACC点火开关状态变化时的各种操作 // 运行性能分析涉及多个子系统操作需要注意执行顺序和时间消耗 private void accStateChangeOperate() { mHandler.obtainMessage(Constant.MSG_WIFI_AP_STATE).sendToTarget(); // 发送WiFi AP状态消息 LogUtils.getIntance().startLogSizeCheck(); // 启动日志大小检查 AlarmControll.getIntance(mContext).UartRxDetect(); // UART接收检测 sendHeartBeatMsg(); // 发送心跳消息 // 获取蓝牙状态配置 BtStatus Utils.getGlobalString(mContext,Constant.BT_STATUS_SW, Constant.BT_STATUS); if (Utils.isAccOn()) { // 如果ACC开启 LogUtils.saveLogFile(TAG, accStateChangeOperate#BtStatus: BtStatus); // 记录蓝牙状态 if(Constant.ON.equals(BtStatus)){ // 如果蓝牙配置为开启 Utils.openBt(); // 打开蓝牙 } ExternalDeviceFactory.getInstance(mContext).rsr232PowerOn(); // 打开RS232电源 checkTFConfig(); // 检查TF卡配置 addGpsOrTelStatusListen(); // 添加GPS或电话状态监听 cancleOpenVibrateAlarm(); // 取消开启震动闹钟 gsensorShockOpen(); // 开启G传感器震动检测 CardReaderManager.getIntance(mContext).speedometerSelfInspectionDelay(); // 速度表自检延迟 mHandler.obtainMessage(Constant.MSG_TIMER_PICTURE).sendToTarget(); // 发送定时拍照消息 mHandler.obtainMessage(Constant.MSG_LOCATION_UPLOAD).sendToTarget(); // 发送位置上传消息 } else { // 如果ACC关闭 Utils.closeBt(); // 关闭蓝牙 ExternalDeviceFactory.getInstance(mContext).rsr232PowerOn(); // 打开RS232电源 cancleTimerPictureAlarm(); // 取消定时拍照闹钟 cancleSatelliteCountAlarm(); // 取消卫星计数闹钟 gmMisc.GM_Gsensor_Shock_On(0); // 关闭G传感器震动检测 sensor_shocked_flag false; // 重置传感器震动标志 removeGpsOrTelStatusListen(); // 移除GPS或电话状态监听 stopLocationSendTask(); // 停止位置发送任务 ​ // 获取守卫时间配置 int guardTime Utils.getGlobalInt(mContext, Constant.GUARD_TIME, Constant.DEFAULT_GUARD_TIME); // 设置G传感器开关延迟开启 setGSensorSwitch(SystemClock.elapsedRealtime() guardTime * 60 * 1000); LocationInfo info GpsControll.getInstance(mContext) .getLastLocationInfo(); // 获取最后位置信息 if (info ! null) { // 如果位置信息不为空 info.setSpeed(0); // 设置速度为0 CardReaderManager.getIntance(mContext).updateSpeedometer(info); // 更新速度表 } } ​ // 获取ACC变化报告开关配置 boolean accRepSwitch (Boolean) SPUtils.get( Constant.ACC_CHANGE_REPORT_SWITCH, Constant.DEFAULT_ACC_CHANGE_REPORT_SWITCH); LogUtils.saveLogFile(TAG, accRepSwitch: accRepSwitch); // 记录开关状态 if (accRepSwitch) { // 如果ACC变化报告开启 LocationInfo info GpsControll.getInstance(mContext) .getLastLocationInfo(); // 获取最后位置信息 if (info ! null) { // 如果位置信息不为空 info.setMode(Constant.UPDATE_MODE[3]); // 设置上传模式为ACC变化 sendLocationInfoMsg(info); // 发送位置信息消息 } } } ​ // 启动DVR行车记录仪方法 // 功能分析解析DVR启动参数并发送消息到服务器 // 数据流结构msgContent包含ID和版本号用逗号分隔 private void startDvr(String msgContent) { if (msgContent null) { // 如果消息内容为空 return; // 直接返回 } ​ String[] array msgContent.split(,); // 按逗号分割消息内容 String id array[0]; // 第一个参数为ID String version array[1]; // 第二个参数为版本号 LogUtils.saveLogFile(TAG, startDvr#id: id ,version: version); // 记录日志 ​ // 使用消息工厂创建消息包 byte[] msg MessageFactory.getInstance(mContext).messagePackageSend( ByteArrayUtils.str2Bcd(id), // 将ID转换为BCD码 ByteArrayUtils.stringToAscii(version)); // 将版本号转换为ASCII码 sendMessageToServer(msg); // 发送消息到服务器 } ​ // 极密云查询IP方法 // 功能分析启动线程查询服务器IP地址 // 设计模式异步任务模式 - 使用线程执行网络查询 private void JimiyunQueryIP(String url, String imei) { LogUtils.saveLogFile(TAG, JimiyunQueryIP url: url ,path: imei); // 记录日志 QueryIPRunnable JimiyunQuery new QueryIPRunnable(); // 创建查询IP任务 JimiyunQuery.setContext(mContext); // 设置上下文 JimiyunQuery.setUrl(url); // 设置URL JimiyunQuery.setImei(imei); // 设置IMEI JimiyunQuery.setCallBack(this); // 设置回调 Thread mThread new Thread(JimiyunQuery); // 创建线程 mThread.setDaemon(true); // 设置为守护线程 mThread.start(); // 启动线程 } ​ // 检查网络是否可用方法 // 功能分析判断当前网络连接状态 // 性能分析快速检查不涉及网络操作 private boolean isNetworkAvailable() { NetworkInfo info mConnectivityManager.getActiveNetworkInfo(); // 获取活动网络信息 return (info null) ? false : info.isConnected(); // 判断是否连接 } ​ // 设置心跳闹钟方法 // 功能分析使用AlarmManager设置精确的心跳定时任务 // 性能分析使用ELAPSED_REALTIME_WAKEUP唤醒设备节省电量 private void setHeartBeatAlarm(long times) { if (mHeatBeatPi null) { // 如果PendingIntent为空 Intent intent new Intent(Constant.ACTION_HEART_BEAT); // 创建心跳意图 mHeatBeatPi PendingIntent.getBroadcast(mContext, 0, intent, PendingIntent.FLAG_CANCEL_CURRENT); // 创建广播PendingIntent } AlarmManager am (AlarmManager) mContext .getSystemService(Context.ALARM_SERVICE); // 获取闹钟管理器 am.setExact(AlarmManager.ELAPSED_REALTIME_WAKEUP, times, mHeatBeatPi); // 设置精确闹钟 } ​ // 设置超时闹钟方法 private void setTimeOutAlarm(long times) { if (mTimeOutPi null) { // 如果PendingIntent为空 Intent intent new Intent(Constant.ACTION_MESSAGE_TIMEOUT); // 创建超时意图 mTimeOutPi PendingIntent.getBroadcast(mContext, 1, intent, PendingIntent.FLAG_CANCEL_CURRENT); // 创建广播PendingIntent } AlarmManager am (AlarmManager) mContext .getSystemService(Context.ALARM_SERVICE); // 获取闹钟管理器 am.setExact(AlarmManager.ELAPSED_REALTIME_WAKEUP, times, mTimeOutPi); // 设置精确闹钟 } ​ // 设置重连闹钟方法 private void setReconnectAlarm(long times) { if (mReconnectPi null) { // 如果PendingIntent为空 Intent intent new Intent(Constant.ACTION_RECONNECT_SERVER); // 创建重连意图 mReconnectPi PendingIntent.getBroadcast(mContext, 2, intent, PendingIntent.FLAG_CANCEL_CURRENT); // 创建广播PendingIntent } AlarmManager am (AlarmManager) mContext .getSystemService(Context.ALARM_SERVICE); // 获取闹钟管理器 am.setExact(AlarmManager.ELAPSED_REALTIME_WAKEUP, times, mReconnectPi); // 设置精确闹钟 } ​ // 设置延迟上传闹钟方法 private void setDelayUploadAlarm(long times) { if (mDelayUploadPi null) { // 如果PendingIntent为空 Intent intent new Intent(Constant.ACTION_DELAY_UPLOAD_FILE); // 创建延迟上传意图 mDelayUploadPi PendingIntent.getBroadcast(mContext, 3, intent, PendingIntent.FLAG_CANCEL_CURRENT); // 创建广播PendingIntent } AlarmManager am (AlarmManager) mContext .getSystemService(Context.ALARM_SERVICE); // 获取闹钟管理器 am.setExact(AlarmManager.ELAPSED_REALTIME_WAKEUP, times, mDelayUploadPi); // 设置精确闹钟 } ​ // 设置TCP状态检查闹钟方法 private void setTcpStatusAlarm(long times) { if (mTcpStatusCheck null) { // 如果PendingIntent为空 Intent intent new Intent(Constant.ACTION_CHECK_TCP_CONNECT_STATUS); // 创建TCP状态检查意图 mTcpStatusCheck PendingIntent.getBroadcast(mContext, 9, intent, PendingIntent.FLAG_CANCEL_CURRENT); // 创建广播PendingIntent } AlarmManager am (AlarmManager) mContext .getSystemService(Context.ALARM_SERVICE); // 获取闹钟管理器 am.setExact(AlarmManager.ELAPSED_REALTIME_WAKEUP, times, mTcpStatusCheck); // 设置精确闹钟 } ​ // 取消TCP状态检查闹钟方法 private void cancleTcpStatusAlarm() { if (mTcpStatusCheck null) { // 如果PendingIntent为空 return; // 直接返回 } AlarmManager am (AlarmManager) mContext .getSystemService(Context.ALARM_SERVICE); // 获取闹钟管理器 am.cancel(mTcpStatusCheck); // 取消闹钟 } ​ // 设置G传感器开关闹钟方法 private void setGSensorSwitch(long times) { if (mOpenVibrateAlarmPi null) { // 如果PendingIntent为空 Intent intent new Intent(Constant.ACTION_OPEN_GSENSOR_GUARD); // 创建开启G传感器防护意图 mOpenVibrateAlarmPi PendingIntent.getBroadcast(mContext, 4, intent, PendingIntent.FLAG_CANCEL_CURRENT); // 创建广播PendingIntent } AlarmManager am (AlarmManager) mContext .getSystemService(Context.ALARM_SERVICE); // 获取闹钟管理器 am.setExact(AlarmManager.ELAPSED_REALTIME_WAKEUP, times, mOpenVibrateAlarmPi); // 设置精确闹钟 } ​ // 设置卫星计数闹钟方法 private void setSatelliteCount(long times) { if (mSatelliteCountPi null) { // 如果PendingIntent为空 Intent intent new Intent(Constant.ACTION_SATELLITE_STATUS); // 创建卫星状态意图 mSatelliteCountPi PendingIntent.getBroadcast(mContext, 5, intent, PendingIntent.FLAG_CANCEL_CURRENT); // 创建广播PendingIntent } AlarmManager am (AlarmManager) mContext .getSystemService(Context.ALARM_SERVICE); // 获取闹钟管理器 am.setExact(AlarmManager.ELAPSED_REALTIME_WAKEUP, times, mSatelliteCountPi); // 设置精确闹钟 } ​ // 设置上传文件状态闹钟方法 private void setUploadFileState(long times) { if (mUploadFilePi null) { // 如果PendingIntent为空 Intent intent new Intent(Constant.ACTION_UPLOAD_FILE_STATE); // 创建上传文件状态意图 mUploadFilePi PendingIntent.getBroadcast(mContext, 6, intent, PendingIntent.FLAG_CANCEL_CURRENT); // 创建广播PendingIntent } AlarmManager am (AlarmManager) mContext .getSystemService(Context.ALARM_SERVICE); // 获取闹钟管理器 am.setExact(AlarmManager.ELAPSED_REALTIME_WAKEUP, times, mUploadFilePi); // 设置精确闹钟 } ​ // 设置Ping地址闹钟方法 private void setPingAddress(long times) { if (mPingAddressPi null) { // 如果PendingIntent为空 Intent intent new Intent(Constant.ACTION_PING_ADDRESS); // 创建Ping地址意图 mPingAddressPi PendingIntent.getBroadcast(mContext, 7, intent, PendingIntent.FLAG_CANCEL_CURRENT); // 创建广播PendingIntent } AlarmManager am (AlarmManager) mContext .getSystemService(Context.ALARM_SERVICE); // 获取闹钟管理器 am.setExact(AlarmManager.ELAPSED_REALTIME_WAKEUP, times, mPingAddressPi); // 设置精确闹钟 } ​ // 设置定时拍照闹钟方法 private void setTimerPictureAlarm(long times) { if (mTimerPicturePi null) { // 如果PendingIntent为空 Intent intent new Intent(Constant.ACTION_TIMER_PICTURE); // 创建定时拍照意图 mTimerPicturePi PendingIntent.getBroadcast(mContext, 8, intent, PendingIntent.FLAG_CANCEL_CURRENT); // 创建广播PendingIntent } AlarmManager am (AlarmManager) mContext .getSystemService(Context.ALARM_SERVICE); // 获取闹钟管理器 am.setExact(AlarmManager.ELAPSED_REALTIME_WAKEUP, times, mTimerPicturePi); // 设置精确闹钟 } ​ // 取消心跳闹钟方法 private void cancleHeartBeatAlarm() { if (mHeatBeatPi null) { // 如果PendingIntent为空 return; // 直接返回 } AlarmManager am (AlarmManager) mContext .getSystemService(Context.ALARM_SERVICE); // 获取闹钟管理器 am.cancel(mHeatBeatPi); // 取消闹钟 } ​ // 取消超时闹钟方法 private void cancleTimeOutAlarm() { if (mTimeOutPi null) { // 如果PendingIntent为空 return; // 直接返回 } AlarmManager am (AlarmManager) mContext .getSystemService(Context.ALARM_SERVICE); // 获取闹钟管理器 am.cancel(mTimeOutPi); // 取消闹钟 } ​ // 取消重连闹钟方法 private void cancleReconnectAlarm() { if (mReconnectPi null) { // 如果PendingIntent为空 return; // 直接返回 } AlarmManager am (AlarmManager) mContext .getSystemService(Context.ALARM_SERVICE); // 获取闹钟管理器 am.cancel(mReconnectPi); // 取消闹钟 } ​ // 取消Ping地址闹钟方法 private void canclePingAddress() { if (mPingAddressPi null) { // 如果PendingIntent为空 return; // 直接返回 } AlarmManager am (AlarmManager) mContext .getSystemService(Context.ALARM_SERVICE); // 获取闹钟管理器 am.cancel(mPingAddressPi); // 取消闹钟 } ​ // 取消上传文件状态闹钟方法 private void cancleUploadFileState() { if (mUploadFilePi null) { // 如果PendingIntent为空 return; // 直接返回 } AlarmManager am (AlarmManager) mContext .getSystemService(Context.ALARM_SERVICE); // 获取闹钟管理器 am.cancel(mUploadFilePi); // 取消闹钟 } ​ // 取消卫星闹钟方法与cancleSatelliteCountAlarm重复可能是冗余代码 // 功能分析取消卫星状态检查的定时闹钟 private void cancleSatelliteAlarm() { if (mSatelliteCountPi null) { // 如果卫星计数PendingIntent为空 return; // 直接返回 } AlarmManager am (AlarmManager) mContext .getSystemService(Context.ALARM_SERVICE); // 获取闹钟管理器系统服务 am.cancel(mSatelliteCountPi); // 取消卫星计数闹钟 } ​ // 取消延迟上传闹钟方法 // 功能分析取消文件延迟上传的定时任务 private void cancleDelayUploadAlarm() { if (mDelayUploadPi null) { // 如果延迟上传PendingIntent为空 return; // 直接返回 } AlarmManager am (AlarmManager) mContext .getSystemService(Context.ALARM_SERVICE); // 获取闹钟管理器系统服务 am.cancel(mDelayUploadPi); // 取消延迟上传闹钟 } ​ // 取消卫星计数闹钟方法 // 功能分析取消卫星数量检测的定时任务 private void cancleSatelliteCountAlarm() { if (mSatelliteCountPi null) { // 如果卫星计数PendingIntent为空 return; // 直接返回 } AlarmManager am (AlarmManager) mContext .getSystemService(Context.ALARM_SERVICE); // 获取闹钟管理器系统服务 am.cancel(mSatelliteCountPi); // 取消卫星计数闹钟 } ​ // 取消开启震动闹钟方法 // 功能分析取消G传感器震动检测开启的定时任务 private void cancleOpenVibrateAlarm() { if (mOpenVibrateAlarmPi null) { // 如果开启震动PendingIntent为空 return; // 直接返回 } AlarmManager am (AlarmManager) mContext .getSystemService(Context.ALARM_SERVICE); // 获取闹钟管理器系统服务 am.cancel(mOpenVibrateAlarmPi); // 取消开启震动闹钟 } ​ // 取消定时拍照闹钟方法 // 功能分析取消定时拍照的定时任务 private void cancleTimerPictureAlarm() { if (mTimerPicturePi null) { // 如果定时拍照PendingIntent为空 return; // 直接返回 } AlarmManager am (AlarmManager) mContext .getSystemService(Context.ALARM_SERVICE); // 获取闹钟管理器系统服务 am.cancel(mTimerPicturePi); // 取消定时拍照闹钟 } ​ // 重新上传位置信息方法 // 设计模式分析批量处理模式 - 从数据库获取多条位置数据批量上传 // 数据流结构每个位置信息43字节可能批量上传几十到几百条数据 private void reuploadLoactionInfo() { ArrayListLocationInfo infoList Utils.getLocationDataList(mContext); // 从工具类获取位置数据列表 if (infoList null || infoList.size() 0) { // 如果列表为空或大小为0 mHandler.removeMessages(Constant.MSG_REUPLOAD_LOCATION); // 移除重新上传位置消息 return; // 直接返回 } ​ LogUtils.saveLogFile(TAG, reuploadLoactionInfo#infoListSize: infoList.size()); // 记录位置列表大小 // 创建字节缓冲区每个位置信息分配43字节 ByteBuffer bb ByteBuffer.allocate(infoList.size() * 43); for (int i 0; i infoList.size(); i) { // 遍历位置信息列表 LocationInfo info infoList.get(i); // 获取位置信息 if (!isCoreKit) { // 如果不是核心套件模式 mSaveLocationList.add(info); // 添加到保存位置列表 } DBHelper.getInstance(mContext).deleteLocationInfo( String.valueOf(info.getTime())); // 从数据库删除位置信息 byte[] msg MessageFactory.getInstance(mContext).gpsPackageSend( info); // 使用工厂模式创建GPS数据包 bb.put(msg); // 将消息放入字节缓冲区 } ​ sendMessageToServer(bb.array()); // 发送消息到服务器 ​ mHandler.sendEmptyMessageDelayed(Constant.MSG_REUPLOAD_LOCATION, Constant.REUPLOAD_LOCATION_INTERVAL); // 延迟发送重新上传位置消息 } ​ // 重新上传报警信息方法 // 设计模式分析回调模式 - 使用监听器处理发送结果 // 运行性能分析涉及数据库操作和网络通信 private void reuploadAlarmInfo() { RemoteEvent event Utils.getAlarmInfo(mContext); // 从工具类获取报警信息 if (event null) { // 如果事件为空 return; // 直接返回 } ​ final long timeMills event.getmEventStartTime(); // 获取事件开始时间 int alarmType event.getmAlarmType(); // 获取报警类型 int alarmValue event.getmAlmValue(); // 获取报警值 String eventFileName event.getmEventFileName(); // 获取事件文件名 LogUtils.saveLogFile(TAG, alarmValue:alarmValue ,eventFileName:eventFileName); // 记录报警信息 LocationInfo info new LocationInfo(); // 创建位置信息对象 info.setLatitude(event.getmAlmLatitude()); // 设置纬度 info.setBearing(event.getmAlmBearing()); // 设置方位角 info.setLongitude(event.getmAlmLongitude()); // 设置经度 ​ int remoteType Utils.getGlobalInt(mContext, Constant.REMOTE_TYPE, Constant.REMOTE_VIDEO_IN_OUT); // 获取远程类型 ​ // 使用消息工厂创建报警包 byte[] msg MessageFactory.getInstance(mContext).alarmPackageSend( alarmType, timeMills, alarmValue, eventFileName, info); if (isCoreKit) { // 如果是核心套件模式 JMOrderControll.getInstance(mContext).sendMessage( msg, new JMOrderControll.IJMOrderCoreKitSendListener() { // 创建发送监听器 ​ Override public void OnSendResult(boolean result) { // 发送结果回调 if (result) { // 如果发送成功 DBHelper.getInstance(mContext) .deleteRemoteEventInfoByStartTime( String.valueOf(timeMills)); // 从数据库删除远程事件信息 LogUtils.saveLogFile(TAG, reuploadAlarmInfoToCoreKitServer#success); // 记录成功日志 } else { // 如果发送失败 LogUtils.saveLogFile(TAG, reuploadAlarmInfoToCoreKitServer#fail); // 记录失败日志 } } }); } else { // 非核心套件模式 NettyControll.getInstance(mContext).sendMessage(msg, new ChannelFutureListener() { // 创建Netty通道未来监听器 ​ Override public void operationComplete(ChannelFuture future) throws Exception { // 操作完成回调 if (future.isSuccess()) { // 如果操作成功 LogUtils.saveLogFile(TAG, reuploadAlarmInfo#success); // 记录成功日志 DBHelper.getInstance(mContext) .deleteRemoteEventInfoByStartTime( String.valueOf(timeMills)); // 从数据库删除远程事件信息 } else { // 如果操作失败 LogUtils.saveLogFile(TAG, reuploadAlarmInfo#fail); // 记录失败日志 } } }); } mHandler.sendEmptyMessageDelayed(Constant.MSG_REUPLOAD_ALARM, Constant.REUPLOAD_ALARM_INTERVAL); // 延迟发送重新上传报警消息 } ​ // 发送登录消息方法 // 功能分析设备登录服务器的关键方法 // 设计模式工厂模式 - 使用消息工厂创建登录包 private void sendSignInMsg() { byte[] signInMsg MessageFactory.getInstance(mContext) .signInPackageSend(); // 使用工厂模式创建登录包 sendMessageToServer(signInMsg); // 发送消息到服务器 ​ if (!isCoreKit) { // 如果不是核心套件模式 setTimeOutAlarm(SystemClock.elapsedRealtime() Constant.TIME_OUT_INTERVAL); // 设置超时闹钟 } ​ mHandler.sendEmptyMessageDelayed(Constant.MSG_SEND_ICCID_PACKAGE, 10 * 1000); // 延迟10秒发送ICCID包消息 // 检查Ping标志 if (Utils.getGlobalInt(mContext, Constant.PING_FLAG, 0) 1) { // 如果Ping标志为1 if (!mPingAddressFlag) { // 如果Ping地址标志为false mPingAddressFlag true; // 设置Ping地址标志为true if (mPingAddressPi null) { // 如果Ping地址PendingIntent为空 mHandler.sendEmptyMessageDelayed(Constant.MSG_PING_ADDRESS, 10 * 1000); // 延迟10秒发送Ping地址消息 } } } } ​ // 发送心跳消息方法 // 功能分析维持与服务器连接的重要方法 // 性能分析定时发送心跳包保持连接活跃 private void sendHeartBeatMsg() { byte[] msg MessageFactory.getInstance(mContext) .heartbeatPackageSend(); // 使用工厂模式创建心跳包 sendMessageToServer(msg); // 发送消息到服务器 if (!isCoreKit) { // 如果不是核心套件模式 setTimeOutAlarm(SystemClock.elapsedRealtime() Constant.TIME_OUT_INTERVAL); // 设置超时闹钟 } } ​ // 发送位置信息消息方法 // 设计模式分析策略模式 - 根据isCoreKit标志选择不同的发送策略 // 数据流结构LocationInfo对象约100-200字节网络消息包约43字节 private void sendLocationInfoMsg(final LocationInfo info) { info.setAccState(Utils.getAccState()); // 设置ACC状态 // 更新位置信息里程值 if (mApp.getDeviceInfo().ismMileageSwtich()) { // 如果里程开关开启 info.setMileageValue(mApp.getDeviceInfo().getmMileageValue()); // 设置里程值 } // 检查是否允许发送消息 if (!Utils.isAllowToSendMsg(isCoreKit, mContext)) { // 如果不允许发送消息 if (!info.isReupload()) { // 如果不是重新上传 info.setSupply(Constant.UPDATE_REALTIME[1]); // 设置补充信息为实时[1] Utils.setLocationData(mContext, info); // 保存位置数据到本地 } return; // 直接返回 } ​ if (isCoreKit) { // 核心套件模式 JMOrderControll.getInstance(mContext).sendMessage( MessageFactory.getInstance(mContext).gpsPackageSend(info), // 创建GPS包 new JMOrderControll.IJMOrderCoreKitSendListener() { // 创建发送监听器 ​ Override public void OnSendResult(boolean result) { // 发送结果回调 if (result) { // 如果发送成功 if (info.isReupload()) { // 如果是重新上传 Utils.delLocationData(mContext, info); // 删除本地位置数据 } LogUtils.saveLogFile(TAG, sendLocationInfoMessageToCoreKitServer#success); // 记录成功日志 } else { // 如果发送失败 if (!info.isReupload()) { // 如果不是重新上传 info.setSupply(Constant.UPDATE_REALTIME[1]); // 设置补充信息 Utils.setLocationData(mContext, info); // 保存位置数据到本地 } LogUtils.saveLogFile(TAG, sendLocationInfoMessageToCoreKitServer#fail); // 记录失败日志 } } }); } else { // 非核心套件模式 mSaveLocationList.add(info); // 添加到保存位置列表 NettyControll.getInstance(mContext).sendMessage( MessageFactory.getInstance(mContext).gpsPackageSend(info), // 创建GPS包 new ChannelFutureListener() { // 创建Netty通道未来监听器 ​ Override public void operationComplete(ChannelFuture future) throws Exception { // 操作完成回调 if (!future.isSuccess()) { // 如果操作失败 if (!info.isReupload()) { // 如果不是重新上传 info.setSupply(Constant.UPDATE_REALTIME[1]); // 设置补充信息 Utils.setLocationData(mContext, info); // 保存位置数据到本地 } LogUtils.saveLogFile(TAG, sendLocationInfoMsg fail); // 记录失败日志 } else { // 如果操作成功 if (info.isReupload()) { // 如果是重新上传 Utils.delLocationData(mContext, info); // 删除本地位置数据 } LogUtils.saveLogFile(TAG, sendLocationInfoMsg success); // 记录成功日志 } } }); } } ​ // Ping地址方法 // 功能分析测试网络连通性 // 设计模式异步任务模式 - 在新线程中执行网络测试 private void pingAddress() { if (mPingAddressFlag) { // 如果Ping地址标志为true mPingAddressFlag false; // 设置标志为false防止重复执行 new Thread(new Runnable() { // 创建新线程执行Ping操作 Override public void run() { String address Constant.DEFAULT_SOCKET_ADDRESS; // 默认socket地址 LogUtils.saveLogFile(TAG, pingAddress#run#addressaddress); // 记录地址 // 检查是否有自定义IP地址 if (!TextUtils.isEmpty(Utils.getGlobalString(mContext, Constant.IP_ADDRESS))) { // 如果IP地址不为空 address Utils.getGlobalString(mContext, Constant.IP_ADDRESS); // 使用自定义IP地址 } String pingValue Utils.ping(address); // 执行Ping操作 ​ byte[] msg MessageFactory.getInstance(mContext) .deviceMessagePackageSend(Constant.PING_BYTE, pingValue); // 创建设备消息包 sendMessageToServer(msg); // 发送消息到服务器 mPingAddressFlag true; // 重置Ping地址标志为true } }).start(); // 启动线程 } } ​ // 发送ICCID消息方法 // 功能分析发送设备SIM卡信息到服务器 private void sendICCIDMsg() { LogUtils.saveLogFile(TAG, sendICCIDMsg); // 记录日志 byte[] msg MessageFactory.getInstance(mContext) .deviceMessagePackageSend(Constant.TYPE_ICCID, // ICCID消息类型 Utils.getImeiAndiccid(mContext)); // 获取IMEI和ICCID sendMessageToServer(msg); // 发送消息到服务器 mPingAddressFlag true; // 设置Ping地址标志为true } ​ // 发送消息到服务器方法通用 // 设计模式分析策略模式 - 根据isCoreKit选择不同的发送控制器 // 回调模式 - 使用监听器处理发送结果 private void sendMessageToServer(byte[] msg) { if (isCoreKit) { // 核心套件模式 JMOrderControll.getInstance(mContext).sendMessage(msg, new JMOrderControll.IJMOrderCoreKitSendListener() { // 创建发送监听器 ​ Override public void OnSendResult(boolean result) { // 发送结果回调 if (result) { // 如果发送成功 LogUtils.saveLogFile(TAG, sendMessageToCoreKitServer#success); // 记录成功日志 } else { // 如果发送失败 LogUtils.saveLogFile(TAG, sendMessageToCoreKitServer#fail); // 记录失败日志 } } }); } else { // 非核心套件模式 NettyControll.getInstance(mContext).sendMessage(msg, new ChannelFutureListener() { // 创建Netty通道未来监听器 ​ Override public void operationComplete(ChannelFuture future) throws Exception { // 操作完成回调 if (future.isSuccess()) { // 如果操作成功 LogUtils.saveLogFile(TAG, sendMessageToServer#success); // 记录成功日志 } else { // 如果操作失败 LogUtils.saveLogFile(TAG, sendMessageToServer#fail); // 记录失败日志 } } }); } } ​ // 静态方法移除GPS或电话状态监听 // 功能分析清理监听器资源 public static void removeGpsOrTelStatusListen() { GpsControll.getInstance(mContext).removeListener(); // 移除GPS监听器 if (tmManager ! null) { // 如果电话管理器不为空 tmManager.listen(stateListener, PhoneStateListener.LISTEN_NONE); // 停止监听电话状态 } } ​ // 添加GPS或电话状态监听方法 // 功能分析启动位置和信号强度监控 private void addGpsOrTelStatusListen() { GpsControll.getInstance(mContext).addListener(); // 添加GPS监听器 tmManager.listen(stateListener, PhoneStateListener.LISTEN_SIGNAL_STRENGTHS); // 监听信号强度 setSatelliteCount(SystemClock.elapsedRealtime() Constant.DEFAULT_GPS_SATELLITE_STATUS_TIME); // 设置卫星计数闹钟 } ​ // 执行SOS事件方法 // 功能分析创建并执行SOS紧急事件 private void executeSOSEvent() { RemoteEvent event new RemoteEvent(); // 创建远程事件对象 event.setmCommandType(Constant.REMOTE_SOS); // 设置命令类型为SOS event.setmEventStartTime(System.currentTimeMillis()); // 设置事件开始时间为当前时间 executeRemoteEvent(event); // 执行远程事件 } ​ // 执行远程事件方法 // 功能分析委托给远程事件管理器处理事件执行 private void executeRemoteEvent(RemoteEvent event) { boolean isStart mRemoteEventManager .isStartToExecuteRemoteEvent(event); // 检查是否开始执行远程事件 LogUtils.saveLogFile(TAG, executeRemoteEvent#start: isStart); // 记录开始状态 if (isStart) { // 如果开始执行 mHandler.obtainMessage(Constant.MSG_HANDLE_REMOTE_EVENT) .sendToTarget(); // 发送处理远程事件消息 } } ​ // 执行下一个远程事件方法 // 功能分析根据远程事件管理器结果执行相应操作 // 设计模式状态模式 - 根据result值执行不同逻辑 private void executeNextRemoteEvent() { int result mRemoteEventManager.executeNextRemoteEvent(); // 执行下一个远程事件 switch (result) { // 根据结果执行不同操作 case RemoteEventManager.TYPE_CHECK_SOS_CALL: // 检查SOS呼叫 mHandler.sendEmptyMessageDelayed(Constant.MSG_CHECK_SOS_CALL_END, Constant.CHECK_SOS_CALL_INTERVAL); // 延迟发送检查SOS呼叫结束消息 break; case RemoteEventManager.TYPE_DO_NEXT_EVENT: // 执行下一个事件 mHandler.sendEmptyMessageDelayed(Constant.MSG_HANDLE_REMOTE_EVENT, Constant.EXECUTE_EVENT_INTERVAL); // 延迟发送处理远程事件消息 break; } } ​ // 启动连接服务器方法 // 功能分析根据当前模式启动相应的服务器连接 private void startConnectServer() { if (isCoreKit) { // 核心套件模式 boolean connectStatus JMOrderControll.getInstance(mContext) .getConnectStatus(); // 获取连接状态 LogUtils.saveLogFile(TAG, startConnectServer networkAvailable : isNetworkAvailable() ,connectStatus: connectStatus); // 记录连接信息 if (!connectStatus) { // 如果未连接 JMOrderControll.getInstance(mContext).startConnect(); // 启动JM指令控制器连接 } } else { // 非核心套件模式 NettyControll netty NettyControll.getInstance(mContext); // 获取Netty控制器 boolean reconnetStatus netty.getReconnectStatus(); // 获取重连状态 boolean channelConnect netty.isChannelConnected(); // 获取通道连接状态 boolean networkAvailable isNetworkAvailable(); // 检查网络是否可用 LogUtils.saveLogFile(TAG, startConnectServer networkAvailable : networkAvailable ,reconnetStatus : reconnetStatus ,channelConnect : channelConnect); // 记录连接信息 if (networkAvailable (!reconnetStatus) (!channelConnect)) { // 如果网络可用、未重连、通道未连接 NettyControll.getInstance(mContext).connect(); // 启动Netty连接 } } } ​ // 登录成功处理方法 // 功能分析设备成功登录服务器后的初始化操作 // 运行性能分析涉及多个子系统的初始化和状态恢复 private void signInSuccess() { LogUtils.saveLogFile(TAG, signInSuccess isCoreKit: isCoreKit mJimiyunQueryIP mJimiyunQueryIP); // 记录登录成功信息 ​ if (!isCoreKit) { // 非核心套件模式 cancleTimeOutAlarm(); // 取消超时闹钟 setHeartBeatAlarm(SystemClock.elapsedRealtime()); // 设置心跳闹钟立即执行 } else { // 核心套件模式 mHandler.obtainMessage(Constant.MSG_UPLOAD_LOGIN_STATE) .sendToTarget(); // 发送上传登录状态消息 // 重新上传0x69命令消息和文件 if (Utils.isAllowToSendMsg(isCoreKit, mContext)) { // 如果允许发送消息 reUpload69CommandMessageAndFile(); // 重新上传69命令消息和文件 } } ​ // 如果没有正在重新上传位置消息且允许发送消息 if (!mHandler.hasMessages(Constant.MSG_REUPLOAD_LOCATION) Utils.isAllowToSendMsg(isCoreKit, mContext)) { mHandler.sendEmptyMessageDelayed(Constant.MSG_REUPLOAD_LOCATION, Constant.REUPLOAD_LOCATION_INTERVAL); // 延迟发送重新上传位置消息 } ​ // 如果没有正在重新上传报警消息且允许发送消息 if (!mHandler.hasMessages(Constant.MSG_REUPLOAD_ALARM) Utils.isAllowToSendMsg(isCoreKit, mContext)) { mHandler.sendEmptyMessageDelayed(Constant.MSG_REUPLOAD_ALARM, Constant.REUPLOAD_ALARM_INTERVAL); // 延迟发送重新上传报警消息 } ​ // 检查是否开始执行远程事件 boolean executeStart mRemoteEventManager .isStartToExecuteRemoteEvent(null); // 检查远程事件执行状态 if (executeStart) { // 如果开始执行 mHandler.sendEmptyMessageDelayed(Constant.MSG_HANDLE_REMOTE_EVENT, Constant.EXECUTE_EVENT_INTERVAL); // 延迟发送处理远程事件消息 } ​ // 核心套件模式且需要查询极密云IP if (isCoreKit mJimiyunQueryIP) { String imei Utils.getImeiForFile(mContext); // 获取文件IMEI JimiyunQueryIP(8.210.205.58:8081, imei); // 查询极密云IP mJimiyunQueryIP false; // 重置查询标志 } } ​ // 检查SOS呼叫服务销毁方法 // 功能分析监控SOS呼叫服务的运行状态 private void checkSosCallServiceDestory() { // 检查SOS服务是否正在运行 boolean isServiceRun Utils.isServiceRun(mContext, Constant.SOS_SERVICE_NAME); // 检查SOS服务运行状态 LogUtils.saveLogFile(TAG, checkSosCallServiceDestory sosCall service isRun : isServiceRun); // 记录服务运行状态 if (!isServiceRun) { // 如果服务未运行 mHandler.sendEmptyMessageDelayed(Constant.MSG_HANDLE_REMOTE_EVENT, 5 * 1000); // 延迟5秒发送处理远程事件消息 } else { // 如果服务正在运行 mHandler.sendEmptyMessageDelayed(Constant.MSG_CHECK_SOS_CALL_END, Constant.CHECK_SOS_CALL_INTERVAL); // 延迟发送检查SOS呼叫结束消息 } } ​ // DMS事件操作方法 // 功能分析处理驾驶员监控系统DMS事件 // 设计模式工厂模式 - 将alarmType字符串映射为对应的常量值 // 数据流结构msgContent包含文件路径、报警类型、动作类型用逗号分隔 private void dmsEventOperate(String msgContent) { int alarmTypeInt -1; // 报警类型整数初始化为-1表示未知类型 ​ // 按逗号分割消息内容 String[] dmsEventParams msgContent.split(Constant.COMMA); ​ String filePath dmsEventParams[0]; // 文件路径 String alarmType dmsEventParams[1]; // 报警类型字符串 int actionType Integer.parseInt(dmsEventParams[2]); // 动作类型转换为整数 LogUtils.saveLogFile(TAG, dmsEventOperate#filePath: filePath ,alarmType: alarmType ,actionType: actionType); // 记录日志 ​ long timeMills System.currentTimeMillis(); // 获取当前时间戳 LocationInfo info GpsControll.getInstance(mContext) .getLastLocationInfo(); // 获取最后位置信息 // 将报警类型字符串映射为对应的常量值 if (DFW.equals(alarmType)) { // 闭眼 alarmTypeInt Constant.ALARM_CLOSE_EYES; } else if (DYA.equals(alarmType)) { // 打哈欠 alarmTypeInt Constant.ALARM_YAWN; } else if (DDW.equals(alarmType)) { // 分心 alarmTypeInt Constant.ALARM_DISTRACTION; } else if (DSA.equals(alarmType)) { // 吸烟 alarmTypeInt Constant.ALARM_SMOKING; } else if (DCA.equals(alarmType)) { // 打电话 alarmTypeInt Constant.ALARM_PHONE_CALLING; } else if (DAA.equals(alarmType)) { // 人脸缺失 alarmTypeInt Constant.ALARM_MISSING_FACE; } else if (CLIBABN.equals(alarmType)) { // 人脸校准异常 alarmTypeInt Constant.ALARM_ABNORMAL_FACE_CALIBRA; } ​ LogUtils.saveLogFile(TAG, dmsEventAlarmOperate#alarmType: alarmType ,alarmTypeInt: alarmTypeInt ,actionType: actionType); // 记录映射结果 ​ if (alarmTypeInt -1) { // 如果未识别到报警类型 return; // 直接返回 } ​ int alarmValue 0; // 报警值默认为0 ​ // 根据动作类型设置报警值 if (actionType FileActionType.ACTION_TYPE_DMS_SEC_CLOSE_EYES actionType FileActionType.ACTION_TYPE_DMS_SEC_MISSING_FACE) { alarmValue 2; // 二级报警值为2 } ​ File file new File(filePath); // 创建文件对象 int fileLengthfile.getName().length(); // 获取文件名长度 // 重构文件名前部分 I_ 后6位 String filenName file.getName().substring(0,fileLength - 6) I_file.getName().substring(fileLength - 6,fileLength); LogUtils.saveLogFile(TAG, dmsEventOperate filenName filenName); // 记录新文件名 // 从文件名中解析事件时间前19个字符是时间戳 long mEventTime Utils.stringToLong(filenName.substring(0,19),yyyy_MM_dd_HH_mm_ss); LogUtils.saveLogFile(TAG, dmsEventOperate mEventTime mEventTime); // 记录事件时间 // 创建事件文件名 String eventFileName Utils.createEventFileName(filenName, Utils.getImeiForFile(mContext), 00000000); LogUtils.saveLogFile(TAG, dmsEventOperate eventFileName eventFileName); // 记录事件文件名 LogUtils.saveLogFile(TAG, System.currentTimeMillis() System.currentTimeMillis()); // 记录当前时间 // 发送报警消息 AlarmControll.getIntance(mContext).sendAlarmMessage(alarmTypeInt, mEventTime, eventFileName, alarmValue, info); // 上传DMS事件文件 dmsEventFileUpload(filePath, actionType, eventFileName,alarmTypeInt); } ​ // 定时位置发送任务方法 // 设计模式定时器模式 - 使用Timer和TimerTask实现定时任务 // 性能分析定时任务可能影响电池续航需要合理设置间隔 private void timingLocationSendTask() { if (mLocationTimerTask ! null) { // 如果定时任务已存在 mLocationTimerTask.cancel(); // 取消旧任务 mLocationTimerTask null; // 置空引用 } ​ if (mLocationTimerTask null) { // 如果定时任务为空 mLocationTimerTask new TimerTask() { // 创建新的定时任务 ​ Override public void run() { // 任务执行方法 boolean isGpsLocated GpsControll.getInstance(mContext) .isGPSLocated(); // 检查GPS是否定位 LocationInfo info GpsControll.getInstance(mContext) .getLastLocationInfo(); // 获取最后位置信息 if (info ! null) { // 如果位置信息不为空 // 获取速度字符串并转换为整数 int speed Integer.parseInt(Utils.getStringSpeed(mContext, info.getSpeed())); if (speed 0 || !isGpsLocated) { // 如果速度为0或GPS未定位 info.setTime(System.currentTimeMillis()); // 更新时间戳 info.setMode(Constant.UPDATE_MODE[10]); // 设置上传模式为定时上传 } sendLocationInfoMsg(info); // 发送位置信息消息 } } }; } ​ if (mLocationTimer null) { // 如果定时器为空 mLocationTimer new Timer(TAG); // 创建新的定时器使用TAG作为线程名 } ​ // 获取GPS上传间隔时间转换为毫秒 long gpsUploadInterval Utils.getGlobalInt(mContext, Constant.GPS_TIME, Constant.LOCATION_UPLOAD_VALUE) * 1000; // 安排定时任务首次延迟gpsUploadInterval之后每隔gpsUploadInterval执行 mLocationTimer.schedule(mLocationTimerTask, gpsUploadInterval, gpsUploadInterval); } ​ // 停止位置发送任务方法 // 功能分析清理定时任务资源 private void stopLocationSendTask() { if (mLocationTimerTask ! null) { // 如果定时任务不为空 mLocationTimerTask.cancel(); // 取消定时任务 mLocationTimerTask null; // 置空引用 } } ​ // 电话状态监听器静态实例 // 设计模式观察者模式 - 监听电话信号强度变化 // 数据流结构SignalStrength对象包含多个网络制式的信号参数 private static PhoneStateListener stateListener new PhoneStateListener() { ​ Override public void onSignalStrengthsChanged(SignalStrength signalStrength) { // 信号强度变化回调 super.onSignalStrengthsChanged(signalStrength); int level -1; // 信号等级初始化为-1 int networkType tmManager.getNetworkType(); // 获取当前网络类型 ​ // 根据网络类型获取相应的信号等级 if (networkType TelephonyManager.NETWORK_TYPE_LTE) { // LTE网络 level signalStrength.getLteLevel(); } else if (networkType TelephonyManager.NETWORK_TYPE_CDMA) { // CDMA网络 level signalStrength.getCdmaLevel(); } else if (networkType TelephonyManager.NETWORK_TYPE_EVDO_0 || networkType TelephonyManager.NETWORK_TYPE_EVDO_A || networkType TelephonyManager.NETWORK_TYPE_EVDO_B) { // EVDO网络 level signalStrength.getEvdoLevel(); } else { // 其他网络类型 level signalStrength.getLevel(); // 使用通用信号等级 } byte b Utils.getSignalStren(level); // 将信号等级转换为字节值 mApp.getDeviceInfo().setmSignalStren(b); // 设置信号强度字节值 mApp.getDeviceInfo().setmSingnalLevel(level); // 设置信号等级 mApp.getDeviceInfo().setmSignalDbm(signalStrength.getDbm()); // 设置信号dBm值 mApp.getDeviceInfo().setmSignalAsu(signalStrength.getAsuLevel()); // 设置信号ASU值 } }; ​ // 主消息处理器 // 设计模式消息队列模式 - 使用Handler处理异步消息 // 运行性能分析Handler在主线程运行需要快速处理消息避免ANR // SuppressLint(HandlerLeak) 抑制Handler可能导致内存泄漏的警告 SuppressLint(HandlerLeak) private Handler mHandler new Handler() { ​ Override public void handleMessage(Message msg) { // 消息处理回调 super.handleMessage(msg); int what msg.what; // 消息类型 String msgContent (String) msg.obj; // 消息内容 switch (what) { // 根据消息类型处理 case Constant.MSG_HEAR_BEAT: // 心跳消息 sendHeartBeatMsg(); // 发送心跳消息 long heartBeatInterval Utils.getGlobalLong(mContext, Constant.HEARTBEAT_INTERVAL, Constant.DEFAULT_HEART_BEAT_INTERVAL); // 获取心跳间隔 setHeartBeatAlarm(SystemClock.elapsedRealtime() heartBeatInterval); // 设置下一个心跳闹钟 break; case Constant.MSG_SMS_RECEIVED: // 短信接收消息 // 使用消息工厂处理短信消息 RemoteEvent event MessageFactory.getInstance(mContext).handleSmsMessage( msgContent); if (event ! null) { // 如果事件不为空 executeRemoteEvent(event); // 执行远程事件 } break; case Constant.MSG_LOCATION_UPLOAD: // 位置上传消息 if (mApp.getDeviceInfo().ismGPSTimingUpload()) { // 如果GPS定时上传开启 timingLocationSendTask(); // 启动定时位置发送任务 } break; case Constant.MSG_GPS_TIMING_UPDATE: // GPS定时更新消息 String timingSwitch Utils.getGlobalString(mContext, Constant.GPS_TIMING_UPLOAD_SWITCH, Constant.GPS_TIMING_UPLOAD_SWITCH_DEFAULT); // 获取定时上传开关 if (Constant.ON.equals(timingSwitch)) { // 如果开关开启 mApp.getDeviceInfo().setmGPSTimingUpload(true); // 设置GPS定时上传标志 if (Utils.isAccOn()) { // 如果ACC开启 mHandler.obtainMessage(Constant.MSG_LOCATION_UPLOAD) .sendToTarget(); // 发送位置上传消息 } } else { // 如果开关关闭 mApp.getDeviceInfo().setmGPSTimingUpload(false); // 设置GPS定时上传标志 stopLocationSendTask(); // 停止位置发送任务 } break; case Constant.MSG_RECONNECT_SERVER: // 重连服务器消息 NettyControll.getInstance(mContext).startReconnect(); // 启动Netty重连 break; case Constant.MSG_RTMP_TIMEOUT: // RTMP超时消息 LogUtils.saveNetLogFile(mContext, RTMP, TIMEOUT); // 记录网络日志 break; case Constant.MSG_CONNECT_SERVER: // 连接服务器消息 startConnectServer(); // 启动连接服务器 break; case Constant.MSG_CONNECTIVITY: // 网络连接消息 if (!mHandler.hasMessages(Constant.MSG_CONNECT_SERVER)) { // 如果没有正在连接的消息 mHandler.sendEmptyMessageDelayed( Constant.MSG_CONNECT_SERVER, 10 * 1000); // 延迟10秒发送连接服务器消息 } break; case Constant.MSG_CARRECODER_REMOTE: // 行车记录仪远程控制消息 String[] array msgContent.split(Constant.COMMA); // 按逗号分割消息内容 String fileName array[4]; // 文件名 String filePath array[2]; // 文件路径 LogUtils.saveLogFile(TAG, Constant.MSG_CARRECODER_REMOTE fileNamefileName); // 记录文件名 LogUtils.saveLogFile(TAG, Constant.MSG_CARRECODER_REMOTE filePathfilePath); // 记录文件路径 if(getUploadFileName(fileName)) // 检查文件名是否在待上传列表 { if(!error.equals(filePath)) { // 如果文件路径不是error mUploadManager.startUploadFile(msgContent, true,GetFlieId); // 开始上传文件带文件ID } }else{ // 如果文件名不在待上传列表 if(!error.equals(filePath)) { // 如果文件路径不是error mUploadManager.startUploadFile(msgContent); // 开始上传文件不带文件ID } } mHandler.obtainMessage(Constant.MSG_HANDLE_REMOTE_EVENT) .sendToTarget(); // 发送处理远程事件消息 break; case Constant.MSG_EVENT_FILE_UPLOAD: // 事件文件上传消息 crashEventFileUpload(msgContent, false); // 上传碰撞事件文件文件路径模式 break; case Constant.MSG_START_EVENT_FILE_UPLOAD: // 开始事件文件上传消息 crashEventFileUpload(msgContent, true); // 上传碰撞事件文件服务器标志模式 mHandler.sendEmptyMessageDelayed( Constant.MSG_CRASH_UPLOAD_CONTENT, 15 * 1000); // 延迟15秒发送碰撞上传内容消息 break; case Constant.MSG_DELAY_UPLOAD_FILE: // 延迟上传文件消息 mUploadManager.fileReupload(); // 重新上传文件 break; case Constant.MSG_SOS_VALUE: // SOS值消息 executeSOSEvent(); // 执行SOS事件 break; case Constant.MSG_HANDLE_REMOTE_EVENT: // 处理远程事件消息 executeNextRemoteEvent(); // 执行下一个远程事件 break; case Constant.MSG_DOWNLOAD_COMPLETE: // 下载完成消息 DownloadUtils.getInstance(mContext).checkDownloadStatus(); // 检查下载状态 break; case Constant.MSG_STARTDVR_BACK: // 启动DVR返回消息 startDvr(msgContent); // 启动DVR break; case Constant.MSG_CUSTOM_ACCON: // 自定义ACC开启消息 accStateChangeOperate(); // 执行ACC状态变化操作 break; case Constant.MSG_CUSTOM_ACCOFF: // 自定义ACC关闭消息 accStateChangeOperate(); // 执行ACC状态变化操作 break; case Constant.MSG_CHECK_SOS_CALL_END: // 检查SOS呼叫结束消息 checkSosCallServiceDestory(); // 检查SOS呼叫服务销毁 break; case Constant.MSG_SHUTDOWN: // 关机消息 Utils.putGlobalInt(mContext, Constant.RESTART_SHUTDOWN, Constant.TYPE_REBOOT_NORMAL); // 设置重启关闭类型为正常重启 SPUtils.put(Constant.DEVICE_NORMAL_REBOOT_STATE, true); // 设置设备正常重启状态 break; case Constant.MSG_OPEN_GSENSOR_SHOCK: // 开启G传感器震动消息 gsensorShockOpen(); // 开启G传感器震动检测 break; case Constant.MSG_OPEN_GSENSOR_GUARD: // 开启G传感器防护消息 gsensorGuardOpen(); // 开启G传感器防护 break; case Constant.MSG_WIFI_AP_STATE: // WiFi AP状态消息 setWifiApEnabled(); // 设置WiFi AP启用状态 break; case Constant.MSG_GPS_SATELLITE_STATUS: // GPS卫星状态消息 int satellitesCount GpsControll.getInstance(mContext) .getmSatellitesCountUsedInFix(); // 获取用于定位的卫星数量 if (satellitesCount 0) { // 如果卫星数量小于等于0 Constant.mGpsLocState false; // 设置GPS定位状态为false if (Constant.AMS_STATE_FLAG) { // 如果AMS状态标志为true Utils.sendReceiver(mContext, Utils.deviceState(mContext)); // 发送设备状态广播 } else { mHandler.sendEmptyMessageDelayed( Constant.MSG_GET_DEVICE_STATE, 10 * 1000); // 延迟10秒获取设备状态 } } break; case Constant.MSG_UPDATE_SYSTEM: // 更新系统消息 doUpateSystem(msgContent); // 执行系统更新 break; case Constant.MSG_UPLOAD_LOGIN_STATE: // 上传登录状态消息 if (Utils.getGlobalInt(mContext, Constant.LOGIN_TIME_STATE, 0) 1) { // 如果登录时间状态为1 Utils.putGlobalInt(mContext, Constant.LOGIN_TIME_STATE, 0); // 重置登录时间状态 Utils.putGlobalString(mContext, Constant.Heartbeat_time, Utils.getLoginTime()); // 保存心跳时间 // 计算内容间隔 Utils.getContentInterval(mContext, (Utils.getGlobalString( mContext, Constant.signIn_time)), (Utils.getGlobalString(mContext, Constant.Heartbeat_time))); } break; case Constant.MSG_UPLOAD_FILE_STATE: // 上传文件状态消息 UploadFileState true; // 设置上传文件状态为true break; case Constant.MSG_PING_ADDRESS: // Ping地址消息 if ((Utils.getGlobalInt(mContext, Constant.PING_FLAG, 0) 1)) { // 如果Ping标志为1 pingAddress(); // 执行Ping操作 int pingTime Utils.getGlobalInt(mContext, Constant.PING_TIME, 10); // 获取Ping时间间隔 setPingAddress(SystemClock.elapsedRealtime() (pingTime * 1000)); // 设置下一个Ping闹钟 } break; case Constant.MSG_CRASH_UPLOAD_CONTENT: // 碰撞上传内容消息 mApp.getDeviceInfo().setmCrashServerFlag(null); // 清空碰撞服务器标志 mApp.getDeviceInfo().setmCrashFilePath(null); // 清空碰撞文件路径 break; case Constant.MSG_GET_DEVICE_STATE: // 获取设备状态消息 Utils.sendReceiver(mContext, Utils.deviceState(mContext)); // 发送设备状态广播 break; case Constant.MSG_MESSAGE_TIMEOUT: // 消息超时消息 saveLocationList(); // 保存位置列表 NettyControll.getInstance(mContext).release(); // 释放Netty资源 break; case Constant.MSG_SEND_ICCID_PACKAGE: // 发送ICCID包消息 sendICCIDMsg(); // 发送ICCID消息 break; case Constant.MSG_REUPLOAD_LOCATION: // 重新上传位置消息 reuploadLoactionInfo(); // 重新上传位置信息 break; case Constant.MSG_HISTORY_TRIM_VIDEO_UPLOAD: // 历史剪辑视频上传消息 String[] historyParams msgContent.split(Constant.COMMA); // 按逗号分割 String historyPath historyParams[0]; // 历史文件路径 String historyFlag historyParams[1]; // 历史文件标志 LogUtils.saveLogFile(TAG, historyPath: historyPath ,historyFlag: historyFlag); // 记录日志 int historyFileSource Constant.REMOTE_VIDEO_IN; // 默认视频源为输入 if (historyPath.contains(FindFileRunnable.HISTORY_FILE_FORWARD_SERCH)) { // 如果包含前向搜索标志 historyFileSource Constant.REMOTE_VIDEO_OUT; // 视频源改为输出 } ​ // 开始上传历史剪辑视频 startUploadFile(historyFileSource, historyFlag, historyPath, 0, getEventFileUploadName(historyPath, historyFlag,historyFileSource), FileActionType.ACTION_TYPE_TRIMMERGE_VIDEO); break; case Constant.MSG_EVENT_TRIM_VIDEO_UPLOAD: // 事件剪辑视频上传消息 String[] eventParams msgContent.split(Constant.COMMA); // 按逗号分割 String eventPath eventParams[0]; // 事件文件路径 String eventFlag eventParams[1]; // 事件文件标志 LogUtils.saveLogFile(TAG, eventPath: eventPath ,eventFlag: eventFlag); // 记录日志 int eventFileSource Constant.REMOTE_VIDEO_IN; // 默认视频源为输入 if (eventPath.contains(FindFileRunnable.EVENT_VIDEO_FORWARD_FLAG)) { // 如果包含前向标志 eventFileSource Constant.REMOTE_VIDEO_OUT; // 视频源改为输出 } ​ // 开始上传事件剪辑视频 startUploadFile(eventFileSource, eventFlag, eventPath, 0, getEventFileUploadName(eventPath, eventFlag,eventFileSource), FileActionType.ACTION_TYPE_TRIMMERGE_VIDEO); break; case Constant.MSG_DMS_EVENT_ALARM: // DMS事件报警消息 if (!TextUtils.isEmpty(msgContent)) { // 如果消息内容不为空 dmsEventOperate(msgContent); // 执行DMS事件操作 } break; case Constant.MSG_DMS_UPLOAD_EVENT_FILE: // DMS上传事件文件消息 // 已注释的代码dmsEventFileUpload(msgContent); break; case Constant.MSG_TIMER_PICTURE: // 定时拍照消息 if (mApp.getDeviceInfo().ismTimerPicture()) { // 如果定时拍照开启 final int picNum (Integer) SPUtils.get(Constant.PICTURE_NUMBER, 1); // 获取拍照数量 // 启动服务拍摄内摄像头照片 Utils.startToService(mContext, , FileActionType.ACTION_TYPE_TIMED_MEDIA, Constant.REMOTE_PICTURE_IN, 0, picNum, 5); // 延迟500毫秒后拍摄外摄像头照片 new Handler().postDelayed(new Runnable() { Override public void run() { Utils.startToService(mContext, , FileActionType.ACTION_TYPE_TIMED_MEDIA, Constant.REMOTE_PICTURE_OUT, 0, picNum,5); } }, 500); // 获取定时拍照间隔时间 mTimerPicInterval (Long) SPUtils.get( Constant.TIMER_PICTURE_INTERVAL, Constant.DEFAULT_TIMER_PICTURE_INTERVAL); LogUtils.saveLogFile(TAG, mTimerPicInterval: mTimerPicInterval); // 记录间隔时间 // 设置下一个定时拍照闹钟 setTimerPictureAlarm(SystemClock.elapsedRealtime() mTimerPicInterval); } break; case Constant.MSG_TRACKER_REALVIDEO: // 追踪器实时视频消息 String relayCmdDataStr msg.getData().getString( relayCmdDataStr); // 获取中继命令数据字符串 int serverFlagId msg.getData().getInt(serverFlagId); // 获取服务器标志ID LogUtils.saveLogFile(TAG, relayCmdDataStr: relayCmdDataStr serverFlagId: serverFlagId); // 记录日志 // 将服务器标志ID转换为字节数组 byte[] serverFlag ByteArrayUtils.intToBytes(serverFlagId); // 使用消息工厂创建回复消息 byte[] replyMsg MessageFactory.getInstance(mContext) .messagePackageSend( ByteArrayUtils.str2Bcd(ByteArrayUtils .bytesToHexString(serverFlag)), ByteArrayUtils.stringToAscii(relayCmdDataStr)); sendMessageToServer(replyMsg); // 发送消息到服务器 break; case Constant.MSG_REUPLOAD_ALARM: // 重新上传报警消息 reuploadAlarmInfo(); // 重新上传报警信息 break; case Constant.MSG_ACTION_TIMEZONE_CHANGED: // 时区改变动作消息 boolean nettyIsConnected NettyControll.getInstance(GpsTrackerService.this).isChannelConnected(); // 检查Netty连接状态 LogUtils.saveLogFile(TAG, handleMessage#action time changed , netty is connected nettyIsConnected); // 记录连接状态 if (nettyIsConnected) { // 如果已连接 // 关闭当前连接然后重新连接 // 如果连接成功将再次发送登录消息但会在更新时区后发送登录消息 NettyControll.getInstance(GpsTrackerService.this).release(); // 释放Netty资源 } break; case Constant.MSG_BATTERY_CUT_SHUTDOWN: // 电池切断关机消息 LogUtils.saveLogFile(TAG, Constant.MSG_BATTERY_CUT_SHUTDOWN); // 记录日志 startTimeTask(); // 启动时间任务开始关机检查流程 break; case Constant.MSG_POWER_BATTERY_CUT: // 电源电池切断消息 mCheckSelfNum; // 自检计数增加 LogUtils.saveLogFile(TAG, MSG_POWER_BATTERY_CUT mCheckSelfNummCheckSelfNum); // 记录自检计数 if(mUploadManager.updateUploadComplete()){ // 如果上传完成 mHandler.removeMessages(Constant.MSG_POWER_BATTERY_CUT); // 移除电源电池切断消息 mHandler.obtainMessage(Constant.MSG_BATTERY_CUT_WAIT_SHUTDOWN).sendToTarget(); // 发送电池切断等待关机消息 } else{ // 如果上传未完成 LogUtils.saveLogFile(TAG, MSG_POWER_BATTERY_CUT mCheckSelfNum00); // 记录日志 if(mUploadManager.updateUploadStateing()) { // 如果正在上传状态 LogUtils.saveLogFile(TAG, MSG_POWER_BATTERY_CUT mCheckSelfNum11); // 记录日志 if(mCheckSelfNum3) { // 如果自检计数达到3次 LogUtils.saveLogFile(TAG, MSG_POWER_BATTERY_CUT mCheckSelfNum22); // 记录日志 mHandler.obtainMessage(Constant.MSG_BATTERY_CUT_WAIT_SHUTDOWN).sendToTarget(); // 发送电池切断等待关机消息 }else{ // 如果自检计数未达到3次 startTimeTask(); // 再次启动时间任务 } }else{ // 如果不是正在上传状态 mHandler.obtainMessage(Constant.MSG_BATTERY_CUT_WAIT_SHUTDOWN).sendToTarget(); // 发送电池切断等待关机消息 } } break; case Constant.MSG_BATTERY_CUT_WAIT_SHUTDOWN: // 电池切断等待关机消息 LogUtils.saveLogFile(TAG, Constant.MSG_BATTERY_CUT_WAIT_SHUTDOWN); // 记录日志 mCheckSelfNum0; // 重置自检计数 Utils.shutdown(mContext); // 执行关机操作 break; case Constant.MSG_STOP_AND_RESTART: // 停止并重启消息 LogUtils.saveLogFile(TAG, Constant.MSG_STOP_AND_RESTART); // 记录日志 Utils.stopCarrecorder(mContext); // 停止行车记录仪 AlarmControll.getIntance(mContext).setRestartVideoRecordTimer(); // 设置重启视频录制定时器 break; case Constant.MSG_TCP_STATUS_CHECK: // TCP状态检查消息 mTcpStatus JMOrderControll.getInstance(mContext).mGetConnectStatus(); // 获取TCP连接状态 LogUtils.saveLogFile(TAG, mTcpStatusmTcpStatus isNetworkAvailableisNetworkAvailable()); // 记录TCP状态和网络可用性 if(isNetworkAvailable()){ // 如果网络可用 if (mTcpStatus) { // 如果TCP连接正常 cancleTcpStatusAlarm(); // 取消TCP状态检查闹钟 } else { // 如果TCP连接异常 mTcpStatusCount; // TCP状态计数增加 setTcpStatusAlarm(SystemClock.elapsedRealtime() Constant.DEFAULT_CHECK_TCP_TIME); // 设置下一个TCP状态检查闹钟 LogUtils.saveLogFile(TAG, Constant.MSG_TCP_STATUS_CHECK mTcpStatusCount mTcpStatusCount); // 记录TCP状态计数 int mRebootValue Utils.getGlobalInt(mContext, Constant.IS_REBOOT_FLAG, 0); // 获取重启标志值 LogUtils.saveLogFile(TAG, mRebootValue mRebootValue); // 记录重启标志值 if ((mTcpStatusCount 2) (mRebootValue 0)) { // 如果TCP状态计数2且未设置重启标志 Utils.putGlobalInt(mContext, Constant.IS_REBOOT_FLAG, 1); // 设置重启标志 Utils.putGlobalLong(mContext, Constant.GET_CURRENT_TIME, System.currentTimeMillis()/1000); // 保存当前时间 delayReboot(); // 延迟重启 } else { // 否则 // 设置飞行模式 final ContentResolver cr mContext.getContentResolver(); Settings.Global.putInt(cr, Settings.Global.AIRPLANE_MODE_ON, 1); // 开启飞行模式 Intent intent new Intent(Intent.ACTION_AIRPLANE_MODE_CHANGED); intent.putExtra(state, true); mContext.sendBroadcast(intent); // 延迟关闭飞行模式 mHandler.sendEmptyMessageDelayed(Constant.MSG_AIRPLANE_MODE_CLOSE, Constant.GUARD_LED_INTERVAL); } } }else{ // 如果网络不可用 cancleTcpStatusAlarm(); // 取消TCP状态检查闹钟 LogUtils.saveLogFile(TAG, no NetworkAvailable); // 记录网络不可用日志 } break; case Constant.MSG_AIRPLANE_MODE_CLOSE: // 关闭飞行模式消息 final ContentResolver cr getContentResolver(); Settings.Global.putInt(cr, Settings.Global.AIRPLANE_MODE_ON, 0); // 关闭飞行模式 Intent intent new Intent(Intent.ACTION_AIRPLANE_MODE_CHANGED); intent.putExtra(state, false); mContext.sendBroadcast(intent); LogUtils.saveLogFile(TAG, Constant.MSG_AIRPLANE_MODE_CLOSE); // 记录日志 break; case Constant.MSG_GPS_FIX_CHANGE: // GPS定位状态改变消息ljl add 20200519 recordGpsFixStatus(msg.arg1); // 记录GPS定位状态 break; case Constant.MSG_AMS_ONLINE_COMMAND: // AMS在线命令消息 executeAmsOnlineCommand(msgContent); // 执行AMS在线命令 break; default: // 默认情况 break; } } }; ​ /** * 执行AMS在线命令 * 设计模式命令模式 - 将命令封装为任务对象执行 * 运行性能分析使用异步IO执行器执行避免阻塞主线程 * * param command 命令字符串 */ private void executeAmsOnlineCommand(String command) { LogUtils.saveLogFile(TAG, executeAmsOnlineCommand#command:command); // 记录命令内容 AmsOnLineCommadTask task new AmsOnLineCommadTask(mContext, command); // 创建AMS在线命令任务 AsynIoExecutor.getIoExecutor().execute(task); // 使用异步IO执行器执行任务 } ​ /** * 记录GPS定位状态方法 * 功能分析监控GPS定位状态变化进行相关缓存清理 * ljl add 20200519 - 2020年5月19日添加的功能 */ private void recordGpsFixStatus(int fixStatus) { LogUtils.saveLogFile(TAG, recordGpsFixStatus fixStatus fixStatus); // 记录GPS定位状态 if (fixStatus 1) { // 如果当前状态为定位状态 if (currentGpsfixStatus 2) { // 如果之前状态为不定位定位转为不定位 LogUtils.saveLogFile(TAG, recordGpsFixStatus clearSpeedCheckCache); // 记录清理缓存日志 Resolution.getResolution().clearSpeedCheckCache(); // 清理速度检查缓存 Resolution.getResolution().clearSwerveCheckCache(); // 清理转向检查缓存 } } currentGpsfixStatus fixStatus; // 更新当前GPS定位状态 } ​ /** * 延迟重启方法 * 功能分析在10秒延迟后执行设备重启 * 设计模式异步任务模式 - 在新线程中执行延迟操作 */ private static void delayReboot() { new Thread(new Runnable() { // 创建新线程执行延迟重启 ​ Override public void run() { // 线程执行方法 try { Thread.sleep(10000); // 延迟10秒 LogUtils.saveLogFile(TAG, mGetSaveTime55 Utils.getGlobalInt(mContext, Constant.IS_REBOOT_FLAG, 0)); // 记录重启标志状态 Utils.reboot(mContext); // 执行重启操作 } catch (InterruptedException e) { // 捕获中断异常 e.printStackTrace(); // 打印异常堆栈 } } }).start(); // 启动线程 } ​ /** * 启动时间任务方法 * 功能分析启动定时任务检查电源电池状态 * 设计模式定时器模式 - 使用Timer和TimerTask实现延迟任务 */ public void startTimeTask(){ if (mTimeoutTask ! null) { // 如果超时任务已存在 mTimeoutTask.cancel(); // 取消旧任务 mTimeoutTask null; // 置空引用 } if (mTimer ! null) { // 如果定时器已存在 mTimer.cancel(); // 取消定时器 mTimer null; // 置空引用 } if (mTimer null){ // 如果定时器为空 mTimeoutTask new TimerTask() { // 创建超时定时任务 Override public void run() { // 任务执行方法 mHandler.obtainMessage(Constant.MSG_POWER_BATTERY_CUT).sendToTarget(); // 发送电源电池切断消息 LogUtils.saveLogFile(TAG, startTimeTask 60s); // 记录日志启动时间任务60秒 } }; mTimer new Timer(); // 创建定时器 mTimer.schedule(mTimeoutTask,Constant.POWER_BATTERY_CUT_TIME); // 安排任务延迟POWER_BATTERY_CUT_TIME后执行 } } ​ /** * 驾驶行为分析急加速/急减速/急转弯分析 * 功能分析基于速度和方位角分析驾驶行为检测异常驾驶 * 设计模式策略模式 - 使用不同的检查策略分析驾驶行为 * * param speed 当前速度 * param bearing 当前方位角 */ private void driveBehaviorAnalysis(float speed, float bearing) { Resolution resolution Resolution.getResolution(); // 获取分辨率单例 int speedCheckResult resolution.speedCheck(speed); // 速度检查急加速/急减速检测 int swerveCheckResult resolution.swerveCheck(bearing, speed); // 转向检查急转弯检测 if (speedCheckResult Resolution.ALARM_TYPE_NONE swerveCheckResult Resolution.ALARM_TYPE_NONE) { // 如果没有检测到异常 return ; // 直接返回 } LogUtils.saveLogFile(TAG, driveBehaviorAnalysis#speedCheckResult:speedCheckResult,swerveCheckResult:swerveCheckResult); // 记录检查结果 Intent intent new Intent(); // 创建意图对象 if (speedCheckResult Resolution.ALARM_TYPE_ACC) { // 如果是急加速 intent.setAction(Constant.ACTION_RAPID_ACC); // 设置动作为急加速 } if (speedCheckResult Resolution.ALARM_TYPE_DEC) { // 如果是急减速 intent.setAction(Constant.ACTION_RAPID_DEC); // 设置动作为急减速 } if (swerveCheckResult Resolution.ALARM_TYPE_SWERVE_LEFT || swerveCheckResult Resolution.ALARM_TYPE_SWERVE_RIGHT) { // 如果是急转弯左或右 intent.setAction(Constant.ACTION_RAPID_TURN); // 设置动作为急转弯 } mContext.sendBroadcast(intent); // 发送广播 } ​ /** * 重新上传0x69命令消息支持非UI线程异步IO操作 * 功能分析从数据库查询需要重新上传的0x69命令并上传 * 设计模式异步任务模式 - 使用线程池执行数据库查询和网络操作 */ private void reUpload69CommandMessage() { AsynIoExecutor.getIoExecutor().execute(new Runnable() { // 使用异步IO执行器执行任务 Override public void run() { // 任务执行方法 MapInteger, byte[] map DBHelper.getInstance(mContext).queryReUpload69Command(); // 从数据库查询需要重新上传的0x69命令 if (map ! null map.size() 0) { // 如果查询结果不为空且有数据 new ReUploadChannelFuture(mContext, map); // 创建重新上传通道未来对象并执行上传 } } }); } ​ /** * 获取文件重新上传允许的最大次数和上传时间间隔 * 功能分析从SharedPreferences获取文件重传配置参数 */ private void getFileReUploadTimesAndInterval() { // 默认5次 int fileReUploadNumberOfTimes (int) SPUtils.get(Constant.FILE_REUPLOAD_MAX_NUMBER_OF_TIMES, 5); // 从SP获取最大重传次数默认5 if (fileReUploadNumberOfTimes 0) { // 如果小于0 fileReUploadNumberOfTimes 5; // 重置为5 } if (fileReUploadNumberOfTimes 10) { // 如果大于10 fileReUploadNumberOfTimes 10; // 限制为10 } // 默认3分钟 int fileReUploadTimeInterval (int) SPUtils.get(Constant.FILE_REUPLOAD_TIME_INTERVAL, Constant.FILE_REUPLOAD_TIME_INTERVAL_DEFAULT); // 从SP获取重传时间间隔默认3 if (fileReUploadTimeInterval 0) { // 如果小于0 fileReUploadTimeInterval 3; // 重置为3 } if (fileReUploadTimeInterval 30) { // 如果大于30 fileReUploadTimeInterval 3; // 限制为3 } LogUtils.saveLogFile(TAG, getFileReUploadTimesAndInterval#fileReUploadNumberOfTimes fileReUploadNumberOfTimes , fileReUploadTimeInterval fileReUploadTimeInterval); // 记录获取的配置参数 this.fileReUploadNumberOfTimes fileReUploadNumberOfTimes; // 设置成员变量文件重新上传最大次数 this.fileReUploadTimeInterval fileReUploadTimeInterval; // 设置成员变量文件重新上传时间间隔 } ​ /** * 当ACC状态改变时设置WiFi AP启用或禁用 * 功能分析根据ACC状态和配置开关控制WiFi热点 */ private void setWifiApEnabled(){ if (Utils.isAccOn()) { // 如果ACC开启 String wifiApSwitch null; // WiFi AP开关字符串 if (isCoreKit) { // 如果是核心套件模式 wifiApSwitch (String) SPUtils.get(Constant.COREKIT_WIFI_AP_SWITCH, Constant.WIFI_AP_SWITCH_DEFAULT); // 获取核心套件WiFi AP开关配置 } else { // 非核心套件模式 wifiApSwitch (String) SPUtils.get(Constant.WIFI_AP_SWITCH, Constant.WIFI_AP_SWITCH_DEFAULT); // 获取普通WiFi AP开关配置 } boolean enable Constant.ON.equals(wifiApSwitch); // 判断开关是否开启 boolean curWifiApState Utils.isWifiApEnabled(mContext); // 获取当前WiFi AP状态 if (enable ^ curWifiApState) { // 如果期望状态与当前状态不同异或运算 Utils.setWifiApEnabled(enable, mContext); // 设置WiFi AP状态 } } else { // 如果ACC关闭 if (Utils.isWifiApEnabled(mContext)) { // 如果WiFi AP当前启用 Utils.setWifiApEnabled(false, mContext); // 关闭WiFi AP } } } ​ /** * 检查TF卡配置方法 * 功能分析检查TF卡上的配置文件并启动配置任务 * 数据流结构配置文件位于TF卡根目录大小通常几KB到几十KB */ private void checkTFConfig() { File file new File(TFConfigRunnable.ROOT_PATH, // TF卡根路径 TFConfigRunnable.CONFIG_FILE_NAME); // 配置文件名 if (file.exists()) { // 如果配置文件存在 mApp.getDeviceInfo().getmTFConfigResults().clear(); // 清空TF配置结果列表 new Handler().postDelayed(new Runnable() { // 延迟10秒执行 ​ Override public void run() { // 延迟执行方法 int debugMode Utils.getGlobalInt(mContext, Constant.DMS_MODE, 0); // 获取DMS调试模式 LogUtils.saveLogFile(TAG, checkTFConfig#debugMode: debugMode); // 记录调试模式 if (debugMode 0) { // 如果调试模式为0非调试模式 new Thread(new TFConfigRunnable(mContext)).start(); // 启动TF配置任务线程 } } }, 10 * 1000); // 延迟10秒 } } ​ /** * 时间同步方法 * 功能分析根据GPS时间同步设备系统时间 * 设计模式策略模式 - 根据配置选择不同的时间同步策略 */ private void timeSync(LocationInfo info) { String timeSyncMode Settings.Global.getString( // 从系统设置获取时间同步模式 mContext.getContentResolver(), Constant.TIME_SYNC_MODE); ​ if (Constant.TIME_SYNC_GPS.equals(timeSyncMode)) { // 如果时间同步模式为GPS同步 try { // 关闭自动时间设置 if (Settings.Global.getInt(mContext.getContentResolver(), Settings.Global.AUTO_TIME) ! 0) { // 如果自动时间开启 Settings.Global.putInt(mContext.getContentResolver(), Settings.Global.AUTO_TIME, 0); // 关闭自动时间 } ​ // 关闭自动时区设置 if (Settings.Global.getInt(mContext.getContentResolver(), Settings.Global.AUTO_TIME_ZONE) ! 0) { // 如果自动时区开启 Settings.Global.putInt(mContext.getContentResolver(), Settings.Global.AUTO_TIME_ZONE, 0); // 关闭自动时区 } ​ // 如果GPS时间与系统时间相差超过5秒设置系统时间 if (Math.abs(info.getTime() - System.currentTimeMillis()) 5000) { // 时间差大于5秒 Utils.setTime(info.getTime(), mContext); // 设置系统时间 } ​ // 设置时区 String timeZone Settings.Global.getString( mContext.getContentResolver(), Constant.SYNC_TIME_ZONE); // 获取同步时区 if (TextUtils.isEmpty(timeZone)) { // 如果时区为空 timeZone Constant.DEFAULT_TIME_ZONE; // 使用默认时区 } ​ Utils.setTimeZone(timeZone, mContext); // 设置系统时区 } catch (Exception e) { // 捕获异常 e.printStackTrace(); // 打印异常堆栈 } } } ​ /** * 开启G传感器震动检测方法 * 功能分析配置G传感器进行震动检测 */ private void gsensorShockOpen() { LogUtils.saveLogFile(TAG, gensorShockOpen); // 记录日志 gmMisc.GM_Gsensor_Guard_on(0); // 关闭G传感器防护 gmMisc.GM_Gsensor_Shock_On(1); // 开启G传感器震动检测 sensor_shocked_flag true; // 设置传感器震动标志为true SPUtils.put(Constant.GUARD_STATE, false); // 保存防护状态为false } ​ /** * 开启G传感器防护方法 * 功能分析根据配置开启G传感器防护功能 */ private void gsensorGuardOpen() { int guadFlag Utils.getGlobalInt(mContext, Constant.GUARD_FLAG, 1); // 获取防护标志默认1 LogUtils.saveLogFile(TAG, gensorGuardOpen#guadFlag: guadFlag); // 记录防护标志 if (guadFlag 1) { // 如果防护标志为1开启 SPUtils.put(Constant.GUARD_STATE, true); // 保存防护状态为true gmMisc.GM_Gsensor_Shock_On(0); // 关闭G传感器震动检测 gmMisc.GM_Gsensor_Guard_on(1); // 开启G传感器防护 sensor_shocked_flag false; // 设置传感器震动标志为false } } ​ /** * 执行系统更新方法 * 功能分析下载并安装系统更新包 * 设计模式异步任务模式 - 在新线程中执行下载操作 */ private void doUpateSystem(final String path) { LogUtils.saveLogFile(TAG, doUpateSystem#path: path); // 记录更新路径 if (TextUtils.isEmpty(path)) { // 如果路径为空 return; // 直接返回 } ​ new Thread(new Runnable() { // 创建新线程执行下载 Override public void run() { // 线程执行方法 DownloadUtils.getInstance(mContext).download(path); // 调用下载工具下载更新包 } }).start(); // 启动线程 } ​ /** * 保存位置列表方法 * 功能分析将内存中的位置列表保存到本地存储 * 运行性能分析循环保存可能影响性能需要控制数据量 */ private void saveLocationList() { try { while (mSaveLocationList.size() 0) { // 当位置列表不为空时循环 LocationInfo reInfo mSaveLocationList.poll(); // 从链表头部取出位置信息 reInfo.setSupply(Constant.UPDATE_REALTIME[1]); // 设置补充信息为实时[1] Utils.setLocationData(mContext, reInfo); // 保存位置数据到本地 } } catch (Exception e) { // 捕获异常 // 空catch块静默处理异常 } } ​ /** * 服务销毁回调方法 * 设计模式生命周期模式 - Android服务的标准销毁流程 * 运行性能分析需要清理所有资源避免内存泄漏 */ Override public void onDestroy() { super.onDestroy(); // 调用父类销毁方法 LogUtils.saveLogFile(TAG, onDestroy); // 记录服务销毁日志 JMOrderControll.getInstance(mContext).deInit(); // 反初始化JM指令控制器 GpsControll.getInstance(mContext).removeListener(); // 移除GPS监听器 NettyControll.getInstance(mContext).release(); // 释放Netty资源 DBHelper.getInstance(mContext).close(); // 关闭数据库连接 GsensorTransManager.getInstance(mContext).release(); // 释放G传感器传输管理器资源 unregisterReceiver(imReceiver); // 注销广播接收器 cancleHeartBeatAlarm(); // 取消心跳闹钟 cancleReconnectAlarm(); // 取消重连闹钟 canclePingAddress(); // 取消Ping地址闹钟 cancleUploadFileState(); // 取消上传文件状态闹钟 cancleSatelliteAlarm(); // 取消卫星闹钟 cancleDelayUploadAlarm(); // 取消延迟上传闹钟 SerialPortUtil.getInstance().closeSerialPort(); // 关闭串口 cancleTcpStatusAlarm(); // 取消TCP状态检查闹钟 unRegisterAutoTest(); // 注销自动测试 } ​ // qsf:auto test - 注释qsf添加的自动测试功能 /** * 注册自动测试方法 * 功能分析注册自动测试广播接收器 */ public void registerAutoTest() { IntentFilter intentFilter new IntentFilter(); // 创建意图过滤器 intentFilter.addAction(action.auto.test.order); // 添加自动测试命令动作 registerReceiver(mAutoTestBroadcastReceiver, intentFilter); // 注册广播接收器 } ​ /** * 注销自动测试方法 * 功能分析注销自动测试广播接收器 */ public void unRegisterAutoTest() { unregisterReceiver(mAutoTestBroadcastReceiver); // 注销广播接收器 } ​ /** * 自动测试广播接收器实例 * 功能分析接收并处理自动测试命令 */ private BroadcastReceiver mAutoTestBroadcastReceiver new BroadcastReceiver() { // 创建广播接收器 Override public void onReceive(Context context, Intent intent) { // 接收广播回调 byte[] msgintent.getByteArrayExtra(auto_test_order); // 获取自动测试命令字节数组 Log.d(qsf,msgmsg hex(msg) ByteArrayUtils.bytesToHexString(msg)); // 调试日志打印命令内容和十六进制表示 ​ RemoteEvent event MessageFactory.getInstance(mContext) // 使用消息工厂处理TCP消息 .handleTcpMessage(msg); if (event ! null) { // 如果事件不为空 executeRemoteEvent(event); // 执行远程事件 } } }; ​ /** * 获取上传文件名方法 * 功能分析根据事件周期映射表匹配上传文件名 * 运行性能分析涉及文件列表遍历和字符串匹配复杂度O(n*m) */ private boolean getUploadFileName(String fileName) { // 获取事件周期映射表 MapString, String eventCycleMap AlarmControll.getIntance(mContext).getEventCycleFileNameMap(); // 获取事件周期文件名映射表 if (eventCycleMap.size() 1) { // 如果映射表为空 LogUtils.saveLogFile(TAG, getUploadFileName#eventCycleMap is empty, return!); // 记录日志 return false; // 返回false } // 排除远程命令和RFID文件 if (fileName.startsWith(Constant.REMOTE_CMD) || fileName.startsWith(Constant.REMOTE_RFID)) { // 如果是远程命令或RFID文件 return false; // 返回false } SetString keySet eventCycleMap.keySet(); // 获取映射表的键集合 ​ String eventFileName null; // 事件文件名 ArrayListString FileNameList Utils.getFilelistList(); // 获取文件列表 for (int i 0; i FileNameList.size(); i) { // 遍历文件列表 String GetListName FileNameList.get(i); // 获取列表中的文件名 String tempName GetListName.substring(30, GetListName.length()); // 截取文件名后部分去掉前30个字符 for (String key : keySet) { // 遍历映射表键集合 String[] nameArray key.split(Constant.COMMA); // 按逗号分割键 String tempKey1 nameArray[0].substring(30, nameArray[0].length()); // 截取第一个键的后部分 String tempKey2 null; // 第二个键后部分 if (nameArray.length 1) { // 如果有第二个键 tempKey2 nameArray[1].substring(30, nameArray[1].length()); // 截取第二个键的后部分 } // 如果临时名称包含任一键的后部分 if (tempName.contains(tempKey1) || tempName.contains(tempKey2)) { eventFileName eventCycleMap.get(key); // 获取对应的值事件文件名 } } String tempFileName fileName.substring(30, fileName.length()); // 截取参数文件名的后部分 LogUtils.saveLogFile(TAG, getUploadFileName FileName888 GetListName,eventFileName:eventFileName ,tempFileName:tempFileName); // 记录匹配过程 if(eventFileName ! null eventFileName.contains(tempFileName) ){ // 如果事件文件名包含临时文件名 LogUtils.saveLogFile(TAG, getUploadFileName tempName tempName,tempFileName:tempFileName ); // 记录匹配成功 // 内摄像头文件匹配文件名包含I if (tempName.contains(I) tempFileName.contains(I)) { GetFlieId GetListName.substring(GetListName.length() - 37, GetListName.length() - 29); // 提取文件ID从倒数37位到倒数29位 return true; // 返回true } // 前摄像头文件匹配文件名包含F if (tempName.contains(F) tempFileName.contains(F)) { GetFlieId GetListName.substring(GetListName.length() - 37, GetListName.length() - 29); // 提取文件ID return true; // 返回true } } } return false; // 未找到匹配返回false } } ​