diff --git a/app/src/main/java/com/navinfo/omqs/ui/MainActivity.kt b/app/src/main/java/com/navinfo/omqs/ui/MainActivity.kt index 6bad71e2..2db13ba2 100644 --- a/app/src/main/java/com/navinfo/omqs/ui/MainActivity.kt +++ b/app/src/main/java/com/navinfo/omqs/ui/MainActivity.kt @@ -23,8 +23,8 @@ class MainActivity : PermissionsActivity(), FSAFActivityCallbacks { setContentView(binding.root) // val navController = findNavController(R.id.nav_host_fragment_content_main) -// appBarConfiguration = AppBarConfiguration(navController.graph) -// setupActionBarWithNavController(navController, appBarConfiguration) +//// appBarConfiguration = AppBarConfiguration(navController.graph) +//// setupActionBarWithNavController(navController, appBarConfiguration) fileChooser.setCallbacks(this@MainActivity) // binding.fab.setOnClickListener { view -> diff --git a/collect-library/libs/Volley.jar b/collect-library/libs/Volley.jar new file mode 100644 index 00000000..836877ff Binary files /dev/null and b/collect-library/libs/Volley.jar differ diff --git a/collect-library/libs/commons-lang3-3.3.2.jar b/collect-library/libs/commons-lang3-3.3.2.jar new file mode 100644 index 00000000..bb069797 Binary files /dev/null and b/collect-library/libs/commons-lang3-3.3.2.jar differ diff --git a/collect-library/libs/commons-net-3.3.jar b/collect-library/libs/commons-net-3.3.jar new file mode 100644 index 00000000..f4f19a90 Binary files /dev/null and b/collect-library/libs/commons-net-3.3.jar differ diff --git a/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/CameraEventListener.java b/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/CameraEventListener.java new file mode 100644 index 00000000..585c4075 --- /dev/null +++ b/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/CameraEventListener.java @@ -0,0 +1,100 @@ +package com.navinfo.collect.library.garminvirbxe; + +import android.graphics.Bitmap; +import com.android.volley.VolleyError; +import java.util.ArrayList; +import com.navinfo.collect.library.sensor.SensorEventListener; +import com.navinfo.collect.library.sensor.ISensor.enmConnectionStatus; + +/** + * @author dongpuxiao + * @version V1.0 + * @ClassName: CameraEventListener.java + * @Date 2017年8月22日 下午2:24:43 + * @Description: 相机操作接口定义 + */ +public interface CameraEventListener extends SensorEventListener{ + /** + *拍照成功 + * + * @return + */ + public void OnSnapPictureResponse(HostBean hostBean, Bitmap bitmap, String picName, int tag); + + /** 错误 */ + public void requestError(HostBean hostBean, VolleyError e, CameraGarminVirbXE.enmCommandType commandType, int tag); + + /** + * 开始自动拍照回调 + */ + public void OnStartRecordResponse(HostBean hostBean, int tag); + + /** + * 停止自动拍照回调 + */ + public void OnStopRecordResponse(HostBean hostBean, int tag); + + /** + * 停止自动拍照回调 + */ + public void OnStatusResponse(HostBean hostBean, int tag); + + /** + * 局域网搜索相机完成回调 + * @param tag + * @param scanIpList + */ + public void OnSearchResponse(int tag,ArrayList scanIpList); + + /** + * 状态发生改变时候回调 + * @param connectStatus + */ + public void OnConnectStatusChanged(HostBean hostBean, enmConnectionStatus connectStatus, int tag); + + /** + * 返回设备id + * @param devicesId + */ + public void OnGetDeviceInfo(HostBean hostBean, String devicesId, int tag); + + /** + * 返回是否有gps信息 + * @param status + */ + public void OnGetGpsStatusResponse(HostBean hostBean, boolean status, int tag); + + /** + * 状态发生改变时候回调 + * @param hostBean 相机 + * @param cs + */ + public void OnConnectionStatusChanged(HostBean hostBean, enmConnectionStatus cs, int tag); + + + /** + * 设置自动拍照为1s + */ + public void OnContinuousPhototTimeLapseRateResponse(HostBean hostBean, int tag); + + /** + * 启动自动拍照 + */ + public void OnContinuousPhototTimeLapseRateStartResponse(HostBean hostBean, int tag); + + /** + * 启动自动拍照 + */ + public void OnContinuousPhototTimeLapseRateStopResponse(HostBean hostBean, int tag); + + /** + * 单拍照 + */ + public void OnContinuousPhototSingle(HostBean hostBean, String url, String name, int tag); + + /** + * 获取多媒体信息 + * + */ + public void OnGetMediaList(HostBean hostBean, String json, int tag); +} diff --git a/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/CameraGarminVirbXE.java b/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/CameraGarminVirbXE.java new file mode 100644 index 00000000..b1b5eda5 --- /dev/null +++ b/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/CameraGarminVirbXE.java @@ -0,0 +1,442 @@ +package com.navinfo.collect.library.garminvirbxe; + +import android.content.Context; +import android.location.Location; +import android.os.Handler; +import android.os.Message; +import android.util.Log; +import org.json.JSONException; +import java.text.SimpleDateFormat; +import java.util.Calendar; +import java.util.Date; +import com.navinfo.collect.library.sensor.Camera; +import com.navinfo.collect.library.sensor.SensorEventListener; +import com.navinfo.collect.library.utils.SensorUtils; + +public class CameraGarminVirbXE extends Camera /*implements LocationCallBack*/ { + + private Command conmand; + private boolean bSnapPicProgress = false; // 每秒自动拍照标示 + private boolean bMonitoring = false; // + private final Context mContext; + SensorWorkingMode mSensorWorkingMode; + private CameraEventListener cameraEventListener; + private WifiDiscovery mDiscoveryTask; + private static String mSavePath; // 保存照片路径 + private enmConnectionStatus emuConnectionStatus; + private SimpleDateFormat formatter; + private long gpstime = 0; + private long ntptime = 0; + //private MyLocationManager myLocation; + public static String mPicUuid; + private Calendar calendar = Calendar.getInstance(); + private Calendar gpscalendar = Calendar.getInstance(); + private HostBean mHostBean; + private int mTag; + private boolean mContinuousPhototTimeLapseRate; + private boolean mNTPTimeFlag; + private boolean mGoogleTimeFlag; + + public enum enmCommandType { + COMMAND_CAMERA_SNAPPICTURE, COMMAND_CAMERA_RECORD, COMMAND_CAMERA_STOP_RECORD,COMMAND_CAMERA_MONITORING,COMMAND_CAMERA_GETSTATUS, COMMAND_CAMERA_GETDEVICESINFO, COMMAND_CAMERA_GETGPSSTATUS,COMMAND_CAMERA_LIVEPREVIEW, + COMMAND_UNKNOW,COMMAND_PHOTO_MODE,COMMAND_PHOTO_TIME_LASPE_RATE,COMMAND_PHOTO_TIME_LASPE_RATE_STOP,COMMAND_CAMERA_SNAPPICTURE_SINGLE/*单独拍照*/,COMMAND_CAMERA_MEDIA_LIST/*多媒体信息集合*/ + } + + public CameraGarminVirbXE(Context mcontext) { + super(mcontext); + this.mContext = mcontext; + conmand = new Command(mContext); + formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS"); +/* // 初始化google gps 定位 + MyLocationManager.init(mContext, CameraGarminVirbXE.this); + myLocation = MyLocationManager.getInstance();*/ + mNTPTimeFlag = true; + new Thread(mGetNtpTimeProgress).start(); + } + + @Override + public enmSensorType GetSensorType() { + return enmSensorType.SENSOR_CAMEAR; + } + + @Override + public enmConnectionStatus GetConnectionStatus() { + return emuConnectionStatus; + } + + public enmConnectionStatus Connect(HostBean hostBean, SensorParams params) { + try { + setmHostBean(hostBean); + conmand.SetHandle(mCameraHandler); + RequestApi.setApiIp(getmTag(),params.getParams().get("ip").toString()); + emuConnectionStatus = enmConnectionStatus.CONNECTTING; + cameraEventListener.OnConnectionStatusChanged(hostBean,emuConnectionStatus,mTag); + conmand.getStatus(hostBean,getmTag()); + } catch (JSONException e) { + e.printStackTrace(); + } + return null; + } + + @Override + public enmConnectionStatus DisConnect() { + emuConnectionStatus = enmConnectionStatus.DISCONNECTTED; + return null; + } + + @Override + public enmSignalQuality GetSignalQuality() { + // TODO Auto-generated method stub + return null; + } + + @Override + public void GetGpsStatus() { + conmand.getGpsStatus(getmHostBean(),getmTag()); + } + + @Override + public void snapPicture(String picuuid) { + CameraGarminVirbXE.mPicUuid = picuuid; + if (mSensorWorkingMode == SensorWorkingMode.CAMEAR_VEDIO_720P + || mSensorWorkingMode == SensorWorkingMode.CAMERA_VEDIO_1080P + || mSensorWorkingMode == SensorWorkingMode.CAMERA_VEDIO_TIMELAPSE) { + if(getGoogleGpsTime() != 0) { + cameraEventListener.OnSnapPictureResponse(getmHostBean(),null, formatter.format(new Date(getGoogleGpsTime())),getmTag()); + } + else + cameraEventListener.OnSnapPictureResponse(getmHostBean(),null, + formatter.format(new Date(System.currentTimeMillis())),getmTag()); + }else if(mSensorWorkingMode==SensorWorkingMode.CAMERA_PHOTO_SINGLE){//单拍流程，时间校验使用 + conmand.snapSinglePicture(getmHostBean(),getmTag()); + } else { + if (bSnapPicProgress) { // 代表一秒拍照线程开启 + Log.e("CamerGarminVirb", "直接取路径"); + conmand.getBitmapByUrl(getmHostBean(),getmTag()); + } else { + Log.e("CamerGarminVirb", "拍照进行取路径"); + conmand.snapPicture(getmHostBean(),true,getmTag()); + } + } + } + + @Override + public void StartRecording() { + if (mSensorWorkingMode == SensorWorkingMode.CAMEAR_PHOTO_12MP + || mSensorWorkingMode == SensorWorkingMode.CAMEAR_PHOTO_7MP) { + if (!bSnapPicProgress) { + mSnapPicProgress.run(); + bSnapPicProgress = true; + if(cameraEventListener != null) + cameraEventListener.OnStartRecordResponse(getmHostBean(),getmTag()); + } + } else if (mSensorWorkingMode == SensorWorkingMode.CAMEAR_VEDIO_720P + || mSensorWorkingMode == SensorWorkingMode.CAMERA_VEDIO_1080P + || mSensorWorkingMode == SensorWorkingMode.CAMERA_VEDIO_TIMELAPSE) { + conmand.StartRecording(getmHostBean(),getmTag()); + bMonitoring = true; + mCameraHandler.postDelayed(mGetStatusProgress, 5000/*调大值域，对应录像命令处理结束后再执行*/); + } else if(mSensorWorkingMode == SensorWorkingMode.CAMEAR_PHOTO_CONTINUOUS_PHOTO){ + // 其他模式下干其他事情 + //conmand.snapPicture(getmHostBean(),false,getmTag()); + //优先设置缩时时间为1s + if(!mContinuousPhototTimeLapseRate){ + conmand.setContinuousPhototTimeLapseRate(getmHostBean(),getmTag()); + mContinuousPhototTimeLapseRate = true; + } + else { + conmand.snapPicture(getmHostBean(),false,getmTag()); + bMonitoring = true; + mCameraHandler.postDelayed(mGetStatusProgress, 5000/*调大值域，对应录像命令处理结束后再执行*/); + } + } + } + + @Override + public void StopRecording() { + if (mSensorWorkingMode == SensorWorkingMode.CAMEAR_PHOTO_12MP + || mSensorWorkingMode == SensorWorkingMode.CAMEAR_PHOTO_7MP) { + mCameraHandler.removeCallbacks(mSnapPicProgress); + if(cameraEventListener != null) + cameraEventListener.OnStopRecordResponse(getmHostBean(),getmTag()); + bSnapPicProgress = false; + } else if (mSensorWorkingMode == SensorWorkingMode.CAMEAR_VEDIO_720P + || mSensorWorkingMode == SensorWorkingMode.CAMERA_VEDIO_1080P + || mSensorWorkingMode == SensorWorkingMode.CAMERA_VEDIO_TIMELAPSE) { + conmand.StopRecording(getmHostBean(),getmTag()); + mCameraHandler.removeCallbacks(mGetStatusProgress); + bMonitoring = false; + } else if(mSensorWorkingMode == SensorWorkingMode.CAMEAR_PHOTO_CONTINUOUS_PHOTO){ + mContinuousPhototTimeLapseRate = false; + conmand.stopContinuousPhototTimeLapseRate(getmHostBean(),getmTag()); + mCameraHandler.removeCallbacks(mGetStatusProgress); + bMonitoring = false; + } + } + + + @Override + public void Search(boolean isReadCache) { + + //先停止当前搜索 + StopSearch(); + + mDiscoveryTask = new WifiDiscovery(mContext, cameraEventListener,isReadCache); + mDiscoveryTask.setTag(getmTag()); + mDiscoveryTask.execute(); + + } + + @Override + public void StopSearch() { + if(mDiscoveryTask!=null){ + + if(!mDiscoveryTask.isCancelled()){ + + boolean result = mDiscoveryTask.cancel(true); + + Log.e("StopSearch",result+"==="); + } + + mDiscoveryTask = null; + } + } + + @Override + public int RegisterSensorEvent(SensorEventListener sensorEventLister) { + cameraEventListener = (CameraEventListener) sensorEventLister; + return conmand.RegisterSensorEvent(cameraEventListener); + } + + @Override + public void SetMode(SensorWorkingMode sensorWorkingMode) { + mSensorWorkingMode = sensorWorkingMode; + if (sensorWorkingMode == SensorWorkingMode.CAMERA_VEDIO_TIMELAPSE){ + + /*外业需求变更，不在强制设置缩时模式，有作业员自己设置相机*///conmand.setTimeLapse(getmHostBean(),getmTag()); + } + else if(sensorWorkingMode==SensorWorkingMode.CAMEAR_PHOTO_CONTINUOUS_PHOTO){ + conmand.setContinuousPhoto(getmHostBean(),getmTag()); + }else if(sensorWorkingMode==SensorWorkingMode.CAMERA_PHOTO_SINGLE){ + conmand.setContinuousPhotoSingle(getmHostBean(),getmTag()); + } + } + + //获取指定目录多媒体信息 + public void mediaList(String path){ + conmand.mediaList(getmHostBean(),getmTag(),path); + } + + + //获取相机模式 + public SensorWorkingMode GetMode() { + return mSensorWorkingMode; + } + + // 每隔30s进行一次获取连接 + private Runnable mGetStatusProgress = new Runnable() { + + @Override + public void run() { + /*if(1==1) + return;*/ + conmand.getMonitoringStatus(getmHostBean(),getmTag()); + if(bMonitoring) + mCameraHandler.postDelayed(mGetStatusProgress, 1000*30l/*降低频率，解决机器性能下降导致命令无效*/); + } + }; + + // 每隔1000s进行一次拍照 + private Runnable mSnapPicProgress = new Runnable() { + + @Override + public void run() { + conmand.snapPicture(getmHostBean(),false,getmTag()); + } + }; + + //停止时间线程 + public void stopTimeThread(){ + mGoogleTimeFlag = false; + mNTPTimeFlag = false; + ntptime = 0; + gpstime = 0; + } + + private Runnable mGetNtpTimeProgress = new Runnable() { + + @Override + public void run() { + while (mNTPTimeFlag) { + if (SensorUtils.isNetworkAvailable(mContext)) { + Date dateNTP = SensorUtils.syncNow(); + if (dateNTP != null) { + ntptime = dateNTP.getTime(); + calendar.setTime(dateNTP); + //Log.e("AAA", "ntp time :" + DateUtils.formatTime(dateNTP)); + mNTPTimeFlag = false; + mGoogleTimeFlag = true; + //获取NTP时间后开始启动计时线程 + new Thread(mNtpClockTimeProgress).start(); + new Thread(mGpsClockTimeProgress).start(); + } + } + //30秒执行一次，降低频率，节省电量 + try{ + Thread.sleep(30000); + }catch (Exception e){ + + } + + } + } + }; + + /** + * 计时器 + */ + private Runnable mNtpClockTimeProgress = new Runnable() { + + @Override + public void run() { + while (mGoogleTimeFlag) { + if(ntptime != 0) { + int second = calendar.get(Calendar.SECOND); + second += 1; + calendar.set(Calendar.SECOND, second); + try { + Thread.sleep(1000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + }else{ + try{ + Thread.sleep(1); + }catch (Exception e){ + + } + } + } + } + }; + + /** + * 计时器 + */ + private Runnable mGpsClockTimeProgress = new Runnable() { + + @Override + public void run() { + while (mGoogleTimeFlag) { + if(gpstime != 0) { + int second = gpscalendar.get(Calendar.SECOND); + second += 1; + gpscalendar.set(Calendar.SECOND, second); + try { + Thread.sleep(1000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + }else{ + try{ + Thread.sleep(1); + }catch (Exception e){ + + } + } + } + } + }; + + private Handler mCameraHandler = new Handler() { + @Override + public void handleMessage(Message msg) { + switch (msg.what) { + case SensorUtils.HADNLE_CONNECT_OK: + emuConnectionStatus = enmConnectionStatus.CONNECTTED; + cameraEventListener + .OnConnectionStatusChanged(getmHostBean(),emuConnectionStatus,getmTag()); + break; + case SensorUtils.HADNLE_CONNECT_FAIL: + Log.e("AAA", "断开连接~~~~~~~~~~"); + emuConnectionStatus = enmConnectionStatus.DISCONNECTTED; + cameraEventListener + .OnConnectionStatusChanged(getmHostBean(),emuConnectionStatus,getmTag()); + break; + case SensorUtils.HADNLE_SNAPPICTURE:// 定时拍照返回 + if (bSnapPicProgress) + mCameraHandler.post(mSnapPicProgress); + case SensorUtils.HADNLE_MONITORING: + Log.e("AAA", "状态监测中...."); + + break; + default: + break; + } + } + }; + + /** + * 设置照片保存路径 + * + * @param savePath + */ + public void SetCameraPictureSavaPath(String savePath) { + mSavePath = savePath; + } + + //获取google定位时间 + public Long getGoogleGpsTime() { + long time = 0; + if (ntptime != 0) { + time = calendar.getTime().getTime(); + return time; + } else { + if(gpstime != 0 ) + time = gpscalendar.getTime().getTime(); + return time; + } + } + + /** + * 获取照片保存路径 + * + * @return + */ + public static String getCameraPcitureSavePath() { + if ("".equals(mSavePath) || null == mSavePath) + return SensorUtils.STR_CAMERA_PICTURE_SAVEPATH; + else + return mSavePath; + } + +/* @Override + public void onCurrentLocation(Location location) { + if(location != null) { + Log.e("AAA", "onCurrentLocation"); + gpstime = location.getTime(); + gpscalendar.setTime(new Date(gpstime)); + } + else + gpstime = 0; + + if (myLocation != null) + myLocation.destoryLocationManager(); + }*/ + + public HostBean getmHostBean() { + return mHostBean; + } + + public void setmHostBean(HostBean mHostBean) { + this.mHostBean = mHostBean; + } + + public int getmTag() { + return mTag; + } + + public void setmTag(int mTag) { + this.mTag = mTag; + } +} diff --git a/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/Command.java b/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/Command.java new file mode 100644 index 00000000..9af8f772 --- /dev/null +++ b/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/Command.java @@ -0,0 +1,224 @@ +package com.navinfo.collect.library.garminvirbxe; + +import android.content.Context; +import android.graphics.Bitmap; +import android.os.Handler; + +import com.navinfo.collect.library.utils.PreferencesUtils; + +public class Command { + + private Context mContext; + private static CameraEventListener cameraEventListener; + String mPicUrl; // 返回照片的uri + Bitmap mBitmap; + private RequestManager requestManager; + private Handler mHandle; + public static Boolean createBitmap = false; // 是否生成bitmap + + public Command(Context mContext) { + this.mContext = mContext; + requestManager = new RequestManager(mContext); + } + + public void SetHandle(Handler mHandle){ + this.mHandle = mHandle; + requestManager.SetRequestHandle(mHandle); + } + + /** + * 拍照命令 返回照片 + */ + public void snapPicture(HostBean hostBean,Boolean createBitmap,int tag) { + SensorParams params = new SensorParams(); + params.put("command", "snapPicture"); + sendConmand(params, false, com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType.COMMAND_CAMERA_SNAPPICTURE,hostBean,tag); + Command.createBitmap = createBitmap; + } + + /** + * 单拍照拍照命令 返回照片 + */ + public void snapSinglePicture(HostBean hostBean,int tag) { + SensorParams params = new SensorParams(); + params.put("command", "snapPicture"); + sendConmand(params, false, com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType.COMMAND_CAMERA_SNAPPICTURE_SINGLE,hostBean,tag); + } + + /** + * 获取指定目录多媒体信息 + */ + public void mediaList(HostBean hostBean,int tag,String path) { + SensorParams params = new SensorParams(); + params.put("command", "mediaList"); + params.put("path",path+""); + sendConmand(params, false, com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType.COMMAND_CAMERA_MEDIA_LIST,hostBean,tag); + } + + + /** + * 获取相机状态 + */ + public void getStatus(HostBean hostBean,int tag) { + SensorParams params = new SensorParams(); + params.put("command", "status"); + sendConmand(params, false, com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType.COMMAND_CAMERA_GETSTATUS,hostBean,tag); + } + + /** + * (主要用于测试请求) + */ + public void getWifiTestStatus(HostBean hostBean,int tag) { + SensorParams params = new SensorParams(); + //params.put("command", "status");解决相机性能下降后获取status慢问题 + params.put("command", "deviceInfo"); + sendConmandWifi(params, true, com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType.COMMAND_CAMERA_GETSTATUS,hostBean,tag); + } + + /** + * (主要用于监控状态请求) + */ + public void getMonitoringStatus(HostBean hostBean,int tag) { + SensorParams params = new SensorParams(); + params.put("command", "deviceInfo");//解决相机性能下降后获取status慢问题 + //测试代码 + //params.put("command", "mediaList"); + //D:/DCIM/797_VIRB/VIRB0110.jpg + //..\/DCIM\/797_VIRB\/VIRB0110.jpg + //D:/DCIM/797_VIRB/VIRB0110 + //params.put("path",RequestApi.getApiMediaUri(tag)+"/media/photo/DCIM/797_VIRB/VIRB0110.jpg"); + //params.put("path","D:/DCIM/797_VIRB/"); + sendConmand(params, false, com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType.COMMAND_CAMERA_MONITORING,hostBean,tag); + } + + /** + * 获取设备信息 + */ + public void getDeviceInfo(HostBean hostBean,int tag) { + SensorParams params = new SensorParams(); + params.put("command", "deviceInfo"); + sendConmand(params, false, com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType.COMMAND_CAMERA_GETDEVICESINFO,hostBean,tag); + } + + /** + * 获取gps是否连接 + */ + public void getGpsStatus(HostBean hostBean,int tag) { + SensorParams params = new SensorParams(); + params.put("command", "status"); + sendConmand(params, false, com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType.COMMAND_CAMERA_GETGPSSTATUS,hostBean,tag); + } + + /** + * 设置缩时模式 + */ + public void setTimeLapse(HostBean hostBean,int tag){ + SensorParams params = new SensorParams(); + params.put("command", "updateFeature"); + params.put("feature", "videoMode"); + params.put("value", "缩时"); + sendConmand(params, false, com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType.COMMAND_UNKNOW,hostBean,tag); + } + + /** + * 停止录像 + */ + public void StopRecording(HostBean hostBean,int tag) { + SensorParams params = new SensorParams(); + params.put("command", "stopRecording"); + sendConmand(params, false, com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType.COMMAND_CAMERA_STOP_RECORD,hostBean,tag); + } + + /** + * 开始录像 + */ + public void StartRecording(HostBean hostBean,int tag) { + SensorParams params = new SensorParams(); + params.put("command", "startRecording"); + sendConmand(params, false, com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType.COMMAND_CAMERA_RECORD,hostBean,tag); + } + + /** + * 设置连续拍照模式 + */ + public void setContinuousPhoto(HostBean hostBean,int tag){ + SensorParams params = new SensorParams(); + params.put("command", "updateFeature"); + params.put("feature", "photoMode"); + params.put("value", "Timelapse"); + sendConmand(params, false, com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType.COMMAND_PHOTO_MODE,hostBean,tag); + } + + /** + * 设置单拍照模式 + */ + public void setContinuousPhotoSingle(HostBean hostBean,int tag){ + SensorParams params = new SensorParams(); + params.put("command", "updateFeature"); + params.put("feature", "photoMode"); + params.put("value", "Single"); + sendConmand(params, false, com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType.COMMAND_PHOTO_MODE,hostBean,tag); + } + + + public void setContinuousPhototTimeLapseRate(HostBean hostBean,int tag){ + SensorParams params = new SensorParams(); + params.put("command", "updateFeature"); + params.put("feature", "photoTimeLapseRate"); + params.put("value", "1s"); + sendConmand(params, false, com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType.COMMAND_PHOTO_TIME_LASPE_RATE,hostBean,tag); + } + + /** + * 停止连拍 + */ + public void stopContinuousPhototTimeLapseRate(HostBean hostBean,int tag){ + SensorParams params = new SensorParams(); + params.put("command", "stopStillRecording"); + sendConmand(params, false, com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType.COMMAND_PHOTO_TIME_LASPE_RATE_STOP,hostBean,tag); + } + + public int RegisterSensorEvent(CameraEventListener cameraEventListener) { + Command.cameraEventListener = cameraEventListener; + return 0; + } + + /** + * 发送命令 + * + * @param params + * isDebug 参数用来测试，当测试连接时候，需要将超时时间该短，普通拍照请求超时时间设长 + * * @param tag + * @return + */ + public void sendConmand(SensorParams params, Boolean isDebug, + com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType type,HostBean hostBean,int tag) { + IRequest.post(mContext, RequestApi.getApiUri(tag), params, isDebug, + cameraEventListener, type,hostBean,tag); + } + + /** + * 发送命令 + * + * @param params + * isDebug 参数用来测试，当测试连接时候，需要将超时时间该短，普通拍照请求超时时间设长 + * * @param tag + * @return + */ + public void sendConmandWifi(SensorParams params, Boolean isDebug, + com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType type,HostBean hostBean,int tag) { + IRequest.post(mContext, RequestApi.getApiWifiIp(), params, isDebug, + cameraEventListener, type,hostBean,tag); + } + + /** + * + * @param hostBean + * * @param tag + */ + public void getBitmapByUrl(HostBean hostBean,int tag) { + String path = PreferencesUtils.getSpText(mContext, "pictureUri"); + IRequest.getbitmap(mContext, hostBean,path, false, cameraEventListener,tag); + } + +} diff --git a/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/HostBean.java b/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/HostBean.java new file mode 100644 index 00000000..c77d04b8 --- /dev/null +++ b/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/HostBean.java @@ -0,0 +1,107 @@ +package com.navinfo.collect.library.garminvirbxe; + + +import android.os.Parcel; +import android.os.Parcelable; +import android.util.Log; + +import com.navinfo.collect.library.utils.NetScanInfo; + +import java.util.ArrayList; +import java.util.HashMap; + +public class HostBean implements Parcelable { + + public static final String PKG = "info.lamatricexiste.network"; + + public static final String EXTRA = PKG + ".extra"; + public static final String EXTRA_POSITION = PKG + ".extra_position"; + public static final String EXTRA_HOST = PKG + ".extra_host"; + public static final String EXTRA_TIMEOUT = PKG + ".network.extra_timeout"; + public static final String EXTRA_HOSTNAME = PKG + ".extra_hostname"; + public static final String EXTRA_BANNERS = PKG + ".extra_banners"; + public static final String EXTRA_PORTSO = PKG + ".extra_ports_o"; + public static final String EXTRA_PORTSC = PKG + ".extra_ports_c"; + public static final String EXTRA_SERVICES = PKG + ".extra_services"; + public static final int TYPE_GATEWAY = 0; + public static final int TYPE_COMPUTER = 1; + + public int deviceType = TYPE_COMPUTER; + public int isAlive = 1; + public int position = 0; + public int responseTime = 0; // ms + public String ipAddress = null; + public String hostname = null; + public String hardwareAddress = com.navinfo.collect.library.utils.NetScanInfo.NOMAC; + public String nicVendor = "Unknown"; + public String os = "Unknown"; + public HashMap services = null; + public HashMap banners = null; + public ArrayList portsOpen = null; + public ArrayList portsClosed = null; + + public HostBean() { + // New object + } + + public HostBean(Parcel in) { + // Object from parcel + readFromParcel(in); + } + + @Override + public int describeContents() { + return 0; + } + + @Override + public void writeToParcel(Parcel dest, int flags) { + dest.writeInt(deviceType); + dest.writeInt(isAlive); + dest.writeString(ipAddress); + dest.writeString(hostname); + dest.writeString(hardwareAddress); + Log.e("AAA", "writeToParcelipAddress"+ipAddress); + Log.e("AAA", "writeToParcelhardwareAddress"+hardwareAddress); + dest.writeString(nicVendor); + dest.writeString(os); + dest.writeInt(responseTime); + dest.writeInt(position); + dest.writeMap(services); + dest.writeMap(banners); + dest.writeList(portsOpen); + dest.writeList(portsClosed); + } + + @SuppressWarnings("unchecked") + private void readFromParcel(Parcel in) { + deviceType = in.readInt(); + isAlive = in.readInt(); + ipAddress = in.readString(); + hostname = in.readString(); + hardwareAddress = in.readString(); + Log.e("AAA", "readFromParcelParcelipAddress"+ipAddress); + Log.e("AAA", "readFromParcelhardwareAddress"+hardwareAddress); + nicVendor = in.readString(); + os = in.readString(); + responseTime = in.readInt(); + position = in.readInt(); + services = in.readHashMap(null); + banners = in.readHashMap(null); + portsOpen = in.readArrayList(Integer.class.getClassLoader()); + portsClosed = in.readArrayList(Integer.class.getClassLoader()); + } + + @SuppressWarnings("unchecked") + public static final Creator CREATOR = new Creator() { + @Override + public HostBean createFromParcel(Parcel in) { + return new HostBean(in); + } + + @Override + public HostBean[] newArray(int size) { + return new HostBean[size]; + } + }; +} diff --git a/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/IRequest.java b/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/IRequest.java new file mode 100644 index 00000000..950a2966 --- /dev/null +++ b/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/IRequest.java @@ -0,0 +1,34 @@ +package com.navinfo.collect.library.garminvirbxe; + +import android.content.Context; + +public class IRequest { + + /** + * + * @param context + * @param url + * @param params + * @param isDebug + * @param cmaeralistener + */ + public static void post(Context context, String url, SensorParams params, + Boolean isDebug, CameraEventListener cmaeralistener, + com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType type,HostBean hostBean,int tag) { + RequestManager + .post(url, context, params, isDebug, cmaeralistener, type,hostBean,tag); + } + + /** + * + * @param context + * @param hostBean + * @param url + * @param isthumb + */ + public static void getbitmap(Context context, HostBean hostBean,String url, Boolean isthumb, + CameraEventListener cameralistener,int tag) { + RequestManager.getbitmap(context, hostBean,url, isthumb, cameralistener,tag); + } + +} \ No newline at end of file diff --git a/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/RateControl.java b/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/RateControl.java new file mode 100644 index 00000000..c4ab41ee --- /dev/null +++ b/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/RateControl.java @@ -0,0 +1,83 @@ +/* + * Copyright (C) 2009-2010 Aubort Jean-Baptiste (Rorist) + * Licensed under GNU's GPL 2, see README + */ + +package com.navinfo.collect.library.garminvirbxe; + +import android.util.Log; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +import java.net.InetAddress; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +public class RateControl { + + private final String TAG = "RateControl"; + private static final int BUF = 512; + private final int REACH_TIMEOUT = 5000; + private final String CMD = "/system/bin/ping -A -q -n -w 3 -W 2 -c 3 "; + private final String PTN = "^rtt min\\/avg\\/max\\/mdev = [0-9\\.]+\\/[0-9\\.]+\\/([0-9\\.]+)\\/[0-9\\.]+ ms.*"; + private Pattern mPattern; + private String line; + public String indicator = null; + public int rate = 800; // Slow start + + public RateControl() { + mPattern = Pattern.compile(PTN); + } + + public void adaptRate() { + int response_time = 0; + if ((response_time = getAvgResponseTime(indicator)) > 0) { + if (response_time > 100) { // Most distanced hosts + rate = response_time * 5; // Minimum 500ms + } else { + rate = response_time * 10; // Maximum 1000ms + } + if (rate > REACH_TIMEOUT) { + rate = REACH_TIMEOUT; + } + } + } + + private int getAvgResponseTime(String host) { + // TODO: Reduce allocation + BufferedReader reader = null; + Matcher matcher; + try { + final Process proc = Runtime.getRuntime().exec(CMD + host); + reader = new BufferedReader(new InputStreamReader(proc.getInputStream()), BUF); + while ((line = reader.readLine()) != null) { + matcher = mPattern.matcher(line); + if (matcher.matches()) { + reader.close(); + return (int) Float.parseFloat(matcher.group(1)); + } + } + reader.close(); + } catch (Exception e) { + Log.e(TAG, "Can't use native ping: " + e.getMessage()); + try { + final long start = System.nanoTime(); + if (InetAddress.getByName(host).isReachable(REACH_TIMEOUT)) { + Log.i(TAG, "Using Java ICMP request instead ..."); + return (int) ((System.nanoTime() - start) / 1000); + } + } catch (Exception e1) { + Log.e(TAG, e1.getMessage()); + } + } finally { + try { + if (reader != null) { + reader.close(); + } + } catch(IOException e){ + } + } + return rate; + } +} diff --git a/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/RequestApi.java b/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/RequestApi.java new file mode 100644 index 00000000..55c6fce7 --- /dev/null +++ b/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/RequestApi.java @@ -0,0 +1,55 @@ +package com.navinfo.collect.library.garminvirbxe; + +import java.util.HashMap; + +/** + * @author dongpuxiao + * @version V1.0 + * @ClassName: RequestApi + * @Date 2017/1/12 + * @Description: ${TODO}(请求地址类) + */ +public class RequestApi { + // 该类用于管理http请求地址以及接口函数 + private static String apiWifiIp; + //缓存多地址集合 + private static HashMap hashMap = new HashMap(); + + // 获取测试服务器接口 + public static String getApiUri(int key) { + String apiIp = hashMap.get(key); + if (apiIp == null || "".equals(apiIp)) + return "http://192.168.0.1/virb"; + else + return "http://"+apiIp+"/virb"; + + } + + // 获取测试服务器接口 + public static String getApiMediaUri(int key) { + String apiIp = hashMap.get(key); + if (apiIp == null || "".equals(apiIp)) + return "http://192.168.0.1"; + else + return "http://"+apiIp+""; + + } + + //设置地址ip + public static void setApiIp(int key,String ip) { + hashMap.put(key,ip); + } + + //获取wifi测试地址ip + public static String getApiWifiIp() { + if (apiWifiIp == null || "".equals(apiWifiIp)) + return "http://192.168.0.1/virb"; + else + return "http://"+apiWifiIp+"/virb"; + } + + //设置wifi测试ip + public static void setApiWifiIp(String apiWifiIp) { + RequestApi.apiWifiIp = apiWifiIp; + } +} diff --git a/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/RequestJsonListener.java b/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/RequestJsonListener.java new file mode 100644 index 00000000..2e684a09 --- /dev/null +++ b/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/RequestJsonListener.java @@ -0,0 +1,17 @@ +package com.navinfo.collect.library.garminvirbxe; + +import com.android.volley.VolleyError; + +public interface RequestJsonListener { + /** + * 成功 + * + * @param + */ + public void requestSuccess(T result); + + /** + * 错误 + */ + public void requestError(VolleyError e); +} diff --git a/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/RequestListener.java b/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/RequestListener.java new file mode 100644 index 00000000..49da3756 --- /dev/null +++ b/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/RequestListener.java @@ -0,0 +1,14 @@ +package com.navinfo.collect.library.garminvirbxe; + +import android.graphics.Bitmap; + +import com.android.volley.VolleyError; + +public interface RequestListener { + + /** 成功 */ + public void requestSuccess(Bitmap bitmap,String savePath); + + /** 错误 */ + public void requestError(VolleyError e); +} diff --git a/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/RequestManager.java b/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/RequestManager.java new file mode 100644 index 00000000..e97f2a26 --- /dev/null +++ b/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/RequestManager.java @@ -0,0 +1,326 @@ +package com.navinfo.collect.library.garminvirbxe; + +import android.annotation.SuppressLint; +import android.content.Context; +import android.graphics.Bitmap; +import android.graphics.Bitmap.Config; +import android.os.Handler; +import android.util.Log; + +import com.android.volley.DefaultRetryPolicy; +import com.android.volley.Request; +import com.android.volley.RequestQueue; +import com.android.volley.Response; +import com.android.volley.Response.Listener; +import com.android.volley.VolleyError; +import com.android.volley.toolbox.ImageRequest; +import com.android.volley.toolbox.JsonObjectRequest; +import com.android.volley.toolbox.Volley; +import com.navinfo.collect.library.utils.PreferencesUtils; +import com.navinfo.collect.library.utils.SensorUtils; + +import org.json.JSONArray; +import org.json.JSONException; +import org.json.JSONObject; +import java.io.File; +import java.io.IOException; + +@SuppressLint("NewApi") +public class RequestManager { + public static RequestQueue mRequestQueue; + private static Context mContext; + static String picThumbUrl; + private static String picUrl; + private static Handler mHandle; + private static int currentFailCount = 0; // 记录发送命令失败次数 + private static int failCount = 3; // 记录发送命令失败次数 + + public RequestManager(Context mContext) { + mRequestQueue = Volley.newRequestQueue(mContext); + RequestManager.mContext = mContext; + } + + public void SetRequestHandle(Handler mHandle) { + RequestManager.mHandle = mHandle; + } + + public static void getbitmap(Object object, HostBean hostBean, String url, Boolean isThumb, + CameraEventListener listener, int tag) { + ImageRequest imageRequest = new ImageRequest(url, + responseBitmapListener(listener, url, isThumb, hostBean, tag), 0, 0, + Config.RGB_565, responseError(listener, false, null,hostBean, tag)); + addRequest(imageRequest, tag); + } + + /** + * 返回String + * + * @param url 接口 + * @param tag 上下文 + * @param params post需要传的参数 + * @param listener 回调 + */ + public static void post(String url, Object object, SensorParams params, + Boolean isDebug, CameraEventListener listener, + com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType commandType, HostBean hostBean, int tag) { + JsonObjectRequest jsonRequest; + if (isDebug) { + jsonRequest = new JsonObjectRequest(Request.Method.POST, url, + params.getParams(), responseListener(listener, commandType, + isDebug, hostBean, tag), responseError(listener, isDebug, commandType,hostBean, tag)); + jsonRequest + .setRetryPolicy(new DefaultRetryPolicy(1 * 1000, 1, 1.0f)); + } else { + jsonRequest = new JsonObjectRequest(Request.Method.POST, url, + params.getParams(), responseListener(listener, commandType, + isDebug, hostBean, tag), responseError(listener, isDebug, commandType,hostBean, tag)); + //超时时间 + int timeOut = 10 * 1000; + //如果为获取GPS状态，修改超时时间，解决连续拍照导致相机性能下降，获取时间过长问题 + if (commandType == com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType.COMMAND_CAMERA_GETSTATUS) + timeOut = 100 * 1000; + //解决性能问题 + if (commandType == com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType.COMMAND_CAMERA_MEDIA_LIST) { + timeOut = 100 * 1000; + } + + jsonRequest.setRetryPolicy(new DefaultRetryPolicy(timeOut, 1, + 1.0f)); + } + addRequest(jsonRequest, tag); + } + + /** + * 成功消息监听 返回String + * + * @param listener String 接口 + * @return + */ + protected static Listener responseListener( + final CameraEventListener listener, final com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType type, + final Boolean isDebug, final HostBean hostBean, final int tag) { + return new Response.Listener() { + + @Override + public void onResponse(JSONObject json) { + try { + if (isDebug) { + mHandle.sendEmptyMessage(SensorUtils.HADNLE_STATUS_OK); + } else { + + try { + Log.e("AAA", type + (json == null ? "" : json.toString())); + } catch (Exception e) { + + } + + if (type == com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType.COMMAND_CAMERA_MONITORING) { + currentFailCount = 0; + mHandle.sendEmptyMessage(SensorUtils.HADNLE_MONITORING); + } else if (type == com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType.COMMAND_CAMERA_GETSTATUS) { + currentFailCount = 0; + mHandle.sendEmptyMessage(SensorUtils.HADNLE_CONNECT_OK); + if (listener != null) + listener.OnStatusResponse(hostBean, tag); + } else if (type == com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType.COMMAND_CAMERA_RECORD) { + if (listener != null) + listener.OnStartRecordResponse(hostBean, tag); + } else if (type == com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType.COMMAND_CAMERA_STOP_RECORD) { + if (listener != null) + listener.OnStopRecordResponse(hostBean, tag); + } else if (type == com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType.COMMAND_PHOTO_TIME_LASPE_RATE) { + if (listener != null) + listener.OnContinuousPhototTimeLapseRateResponse(hostBean, tag); + } else if (type == com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType.COMMAND_CAMERA_SNAPPICTURE) { + if (listener != null) + listener.OnContinuousPhototTimeLapseRateStartResponse(hostBean, tag); + } else if (type == com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType.COMMAND_CAMERA_SNAPPICTURE_SINGLE) {/*增加单独拍照流程，增加时间校验流程*/ + if (listener != null) { + JSONObject mediajson; + try { + if(json!=null){ + mediajson = new JSONObject(json.getString("media").toString()); + String url = mediajson.get("url").toString(); + String name = mediajson.get("name").toString(); + listener.OnContinuousPhototSingle(hostBean, url, name, tag); + Log.e("AAA", "获取单张拍照" + url); + } + } catch (JSONException e) { + e.printStackTrace(); + listener.OnContinuousPhototSingle(hostBean, null, null, tag); + } + } + } else if (type == com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType.COMMAND_CAMERA_MEDIA_LIST) { + if (listener != null&&json!=null){ + listener.OnGetMediaList(hostBean, json.toString(), tag); + } + + } else if (type == com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType.COMMAND_PHOTO_TIME_LASPE_RATE_STOP) { + if (listener != null) + listener.OnContinuousPhototTimeLapseRateStopResponse(hostBean, tag); + } else if (type == com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType.COMMAND_CAMERA_GETGPSSTATUS) { + if (listener != null&&json!=null) { + String lat = ""; + String lon = ""; + try { + lat = json.get("gpsLatitude").toString(); + lon = json.get("gpsLongitude").toString(); + Log.e("AAA", "获取设备time" + json.get("recordingTime").toString()); + } catch (JSONException e) { + e.printStackTrace(); + } + if (!lat.equals("") && !lon.equals("")) + listener.OnGetGpsStatusResponse(hostBean, true, tag); + else + listener.OnGetGpsStatusResponse(hostBean, false, tag); + } + } else if (type == com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType.COMMAND_CAMERA_GETDEVICESINFO) { + JSONArray jsonobj; + try { + if(json!=null){ + jsonobj = new JSONArray(json.getString("deviceInfo").toString()); + JSONObject ob = (JSONObject) jsonobj.get(0); + if (listener != null) + Log.e("AAA", "获取设备id"); + listener.OnGetDeviceInfo(hostBean, ob.getString( + "deviceId").toString(), tag); + } + } catch (JSONException e) { + e.printStackTrace(); + } + } else if (type == com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType.COMMAND_PHOTO_MODE) {//相机模式设置，增加容错，防止错误解析影响到预览功能 + + } else {//预览命令解析 + JSONObject mediajson; + try { + if(json!=null){ + mediajson = new JSONObject(json.getString("media").toString()); + picUrl = mediajson.get("url").toString(); + picThumbUrl = mediajson.get("thumbUrl").toString(); + PreferencesUtils.saveSpText(mContext, "pictureUri", + picThumbUrl); + PreferencesUtils.saveSpText(mContext, + "pictureThumbUri", picUrl); + mHandle.sendEmptyMessage(SensorUtils.HADNLE_SNAPPICTURE); + if (Command.createBitmap) { + getbitmap(mContext, hostBean, picThumbUrl, false, listener, tag); + } + } + // Toast.makeText(mContext, "成功" + picThumbUrl,Toast.LENGTH_SHORT).show(); + } catch (JSONException e) { + e.printStackTrace(); + } + } + } + } catch (Exception e) { + e.printStackTrace(); + } + + } + }; + } + + protected static Listener responseBitmapListener( + final CameraEventListener listener, final String url, + final Boolean isThumb, final HostBean hostBean, final int tag) { + return new Response.Listener() { + + @Override + public void onResponse(Bitmap bitmap) { + File file = new File(url); + if (!isThumb) { + listener.OnSnapPictureResponse(hostBean, + bitmap, + CameraGarminVirbXE.mPicUuid + + "_thumbnail." + + SensorUtils.getExtensionName(file + .getName()), tag); + String url = PreferencesUtils.getSpText(mContext, + "pictureThumbUri").toString(); + getbitmap(mContext, hostBean, url, true, listener, tag); + } else { + SaveFileRunnable runable = new SaveFileRunnable(bitmap, + CameraGarminVirbXE.mPicUuid + + "." + + SensorUtils.getExtensionName(file + .getName())); + Thread th = new Thread(runable); + th.start(); + } + } + }; + } + + /** + * String 返回错误监听 + * + * @param listener String 接口 + * @return + */ + protected static Response.ErrorListener responseError( + final CameraEventListener listener, final Boolean isDebug, final com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE.enmCommandType commandType, final HostBean hostBean, final int tag) { + return new Response.ErrorListener() { + + @Override + public void onErrorResponse(VolleyError e) { + try { + if (isDebug) { + mHandle.sendEmptyMessage(SensorUtils.HADNLE_STATUS_FAIL); + } else { + if (listener != null) + listener.requestError(hostBean, e, commandType,tag); + currentFailCount++; + if (currentFailCount == failCount) + mHandle.sendEmptyMessage(SensorUtils.HADNLE_CONNECT_FAIL); + } + } catch (Exception e1) { + Log.e("AAA",e1.getStackTrace()+""); + } + } + }; + } + + public static void addRequest(Request request, Object tag) { + if (tag != null) { + request.setTag(tag); + } + mRequestQueue.add(request); + } + + /** + * 当主页面调用协议 在结束该页面调用此方法 + * + * @param tag + */ + public static void cancelAll(Object tag) { + mRequestQueue.cancelAll(tag); + } + + public static class SaveFileRunnable implements Runnable { + private Bitmap mBitmap; + private String fileName; + + public SaveFileRunnable(Bitmap mBitmap, String fileName) { + this.mBitmap = mBitmap; + this.fileName = fileName; + } + + @Override + public void run() { + try { + SensorUtils.saveFile(mBitmap, fileName + ".temp"); + String savePath = CameraGarminVirbXE.getCameraPcitureSavePath(); + File oldName = new File(savePath + fileName + ".temp"); + + if (oldName != null) { + oldName.renameTo(new File(savePath + fileName)); + } + Log.e("AAA", "保存图片成功"); + } catch (IOException e) { + e.printStackTrace(); + } + + } + + } +} diff --git a/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/SensorParams.java b/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/SensorParams.java new file mode 100644 index 00000000..9a57a28e --- /dev/null +++ b/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/SensorParams.java @@ -0,0 +1,41 @@ +package com.navinfo.collect.library.garminvirbxe; + +import org.json.JSONException; +import org.json.JSONObject; + +public class SensorParams extends JSONObject { + + private JSONObject params; + + public SensorParams() { + init(); + } + + public SensorParams(String key, String value) { + init(); + put(key, value); + } + + private void init() { + params = new JSONObject(); + } + + /** + * @param key + * @param value + */ + public void put(String key, String value) { + if (key != null && value != null) { + try { + params.put(key, value); + } catch (JSONException e) { + e.printStackTrace(); + } + } + } + + public JSONObject getParams() { + return params; + } + +} diff --git a/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/WifiDiscovery.java b/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/WifiDiscovery.java new file mode 100644 index 00000000..b630dea7 --- /dev/null +++ b/collect-library/src/main/java/com/navinfo/collect/library/garminvirbxe/WifiDiscovery.java @@ -0,0 +1,509 @@ +package com.navinfo.collect.library.garminvirbxe; + +import android.content.Context; +import android.content.SharedPreferences; +import android.content.SharedPreferences.Editor; +import android.os.AsyncTask; +import android.os.Build; +import android.os.Handler; +import android.os.Message; +import android.preference.PreferenceManager; +import android.util.Log; + +import com.navinfo.collect.library.utils.NetScanInfo; +import com.navinfo.collect.library.utils.NetScanPrefs; +import com.navinfo.collect.library.utils.PreferencesUtils; +import com.navinfo.collect.library.utils.SensorUtils; + +import static com.navinfo.collect.library.utils.NetScanInfo.NOMAC; + +import org.json.JSONArray; +import org.json.JSONObject; + +import java.io.BufferedReader; +import java.io.FileReader; +import java.io.IOException; +import java.net.InetAddress; +import java.net.UnknownHostException; +import java.util.ArrayList; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.TimeUnit; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + + +public class WifiDiscovery extends AsyncTask { + + private final String TAG = "DefaultDiscovery"; + private final static int[] DPORTS = {139, 445, 22, 80}; + private final static int TIMEOUT_SCAN = 3600; // seconds + private final static int TIMEOUT_SHUTDOWN = 10; // seconds + private final static int THREADS = 25; // FIXME: Test, plz set in options + // again ? + private final int mRateMult = 5; // Number of alive hosts between Rate + private int pt_move = 2; // 1=backward 2=forward + private ExecutorService mPool; + private boolean doRateControl; + private RateControl mRateControl; + private int mSearchStatus = 0; // 0为使用缓存ip进行连接测试， 1，从新扫描ip进行连接测试。 + private boolean mBstatus = false; + + protected long ip; + protected long start = 0; + protected long end = 0; + protected long size = 0; + + protected int hosts_done = 0; + private Context mContext; + private Command command; + private int addressIndex = 0; + private SharedPreferences prefs; + private NetScanInfo net; + private CameraEventListener cameraEventListener; + private ArrayList scanHostBeanList; + private ArrayList hosts; + private ArrayList hostsCache; + private int tag; + + public WifiDiscovery(Context mContext, + CameraEventListener cameraEventListener, boolean isReadCache) { + this.mContext = mContext; + this.cameraEventListener = cameraEventListener; + command = new Command(mContext); + command.SetHandle(mHandler); + scanHostBeanList = new ArrayList(); + hosts = new ArrayList(); + hostsCache = new ArrayList(); + prefs = PreferenceManager.getDefaultSharedPreferences(mContext); + net = new NetScanInfo(mContext); + mRateControl = new RateControl(); + setScanInfo(); + if (isReadCache) + getLocalIpSend(); + else{ + mBstatus = true; + Log.e("mBstatus","WifiDiscovery==="+mBstatus); + } + + } + + //优先本地缓存记录连接 + private void getLocalIpSend() { + String cacheHostBean = PreferencesUtils.getSpText(mContext, "cacheHostBean").toString(); + if (!"".equals(cacheHostBean)) { + mSearchStatus = 0; + try { + JSONArray jsonArray = new JSONArray(cacheHostBean); + if (jsonArray != null && jsonArray.length() > 0) { + for (int i = 0; i < jsonArray.length(); i++) { + JSONObject jobj = jsonArray.getJSONObject(i); + if (jobj != null) { + HostBean hostBean = new HostBean(); + if (jobj.has("ipAddress")) + hostBean.ipAddress = jobj.getString("ipAddress"); + if (jobj.has("hardwareAddress")) + hostBean.hardwareAddress = jobj.getString("hardwareAddress"); + hostsCache.add(hostBean); + } + } + } + } catch (Exception e) { + Log.e("AAA", "getLocalIpSend：异常" + e.toString()); + } + //如果缓存转换失败，重新执行扫描 + if (hostsCache == null || hostsCache.size() == 0) { + mBstatus = true; + } else { + //不启动扫描 + mBstatus = false; + Log.e("mBstatus","getLocalIpSend==="+mBstatus); + sendConnectCommand(); + } + } else { + mBstatus = true; + } + } + + private Handler mHandler = new Handler() { + @Override + public void handleMessage(Message msg) { + switch (msg.what) { + case SensorUtils.HADNLE_STATUS_OK: + scanHostBeanList.add(mCurrentHostBean); + sendCommand(); + break; + case SensorUtils.HADNLE_STATUS_FAIL: + //使用缓存获取状态失败了，代表ip发生编化，需要重新扫描 + if (mSearchStatus == 0) { + //重置索引 + addressIndex = 0; + scanHostBeanList.clear(); + hostsCache.clear(); + mBstatus = true; + //扫描失败后重新启动搜索 + mSearchStatus = 0; + pingAllIp(); + } else { + sendCommand(); + } + break; + default: + break; + } + } + }; + + private HostBean mCurrentHostBean; + + private void setScanInfo() { + ip = NetScanInfo.getUnsignedLongFromIp(net.ip); + if (prefs.getBoolean(NetScanPrefs.KEY_IP_CUSTOM, + NetScanPrefs.DEFAULT_IP_CUSTOM)) { + // Custom IP + start = NetScanInfo.getUnsignedLongFromIp(prefs.getString( + NetScanPrefs.KEY_IP_START, NetScanPrefs.DEFAULT_IP_START)); + end = NetScanInfo.getUnsignedLongFromIp(prefs.getString( + NetScanPrefs.KEY_IP_END, NetScanPrefs.DEFAULT_IP_END)); + } else { + // Custom CIDR + if (prefs.getBoolean(NetScanPrefs.KEY_CIDR_CUSTOM, + NetScanPrefs.DEFAULT_CIDR_CUSTOM)) { + net.cidr = Integer.parseInt(prefs.getString( + NetScanPrefs.KEY_CIDR, NetScanPrefs.DEFAULT_CIDR)); + } + // Detected IP + int shift = (32 - net.cidr); + if (net.cidr < 31) { + start = (ip >> shift << shift) + 1; + end = (start | ((1 << shift) - 1)) - 1; + } else { + start = (ip >> shift << shift); + end = (start | ((1 << shift) - 1)); + } + // Reset ip start-end (is it really convenient ?) + Editor edit = prefs.edit(); + edit.putString(NetScanPrefs.KEY_IP_START, + NetScanInfo.getIpFromLongUnsigned(start)); + edit.putString(NetScanPrefs.KEY_IP_END, + NetScanInfo.getIpFromLongUnsigned(end)); + edit.commit(); + } + + } + + public void setNetwork(long ip, long start, long end) { + this.ip = ip; + this.start = start; + this.end = end; + } + + @Override + protected void onPreExecute() { + size = (int) (end - start + 1); + scanHostBeanList.clear(); + doRateControl = prefs.getBoolean(NetScanPrefs.KEY_RATECTRL_ENABLE, + NetScanPrefs.DEFAULT_RATECTRL_ENABLE); + } + + @Override + protected void onProgressUpdate(final HostBean... host) { + if (!isCancelled()) { + if (host[0] != null) { + host[0].position = hosts.size(); + //android 10 获取不到mac地址，所以不进行过滤 + if (Build.VERSION.SDK_INT >= 29 || !host[0].hardwareAddress.equalsIgnoreCase(NOMAC)/*&&host[0].hardwareAddress.startsWith("14:")*/) + hosts.add(host[0]); + Log.e("AAA", "hardwareAddress" + host[0].hardwareAddress + "\n" + host[0].hostname); + } + if (size > 0) { + // discover.setProgress((int) (hosts_done * 10000 / size)); + } + } + } + + @Override + protected void onPostExecute(Void unused) { + Log.e("AAA", "扫描完成"); + sendConnectCommand(); + } + + @Override + protected Void doInBackground(Void... params) { + //与董普校讨论去掉while，调用时自己控制 + //while (true) { + Log.e("mBstatus", "doInBackground===" + mBstatus); + /*if (mBstatus) { + if (mSearchStatus == 1) + return null;*/ + pingAllIp(); + //} + return null; + } + + private void pingAllIp() { + if (mBstatus) { + if (mSearchStatus == 1) + return; + } + mSearchStatus = 1; + Log.v(TAG, "start=" + NetScanInfo.getIpFromLongUnsigned(start) + " (" + + start + "), end=" + NetScanInfo.getIpFromLongUnsigned(end) + + " (" + end + "), length=" + size); + mPool = Executors.newFixedThreadPool(THREADS); + if (ip <= end && ip >= start) { + Log.i(TAG, "Back and forth scanning"); + // gateway + launch(start); + + // hosts + long pt_backward = ip; + long pt_forward = ip + 1; + long size_hosts = size - 1; + + if (size_hosts > 0) { + for (int i = 0; i < size_hosts; i++) { + // Set pointer if of limits + if (pt_backward <= start) { + pt_move = 2; + } else if (pt_forward > end) { + pt_move = 1; + } + // Move back and forth + if (pt_move == 1) { + launch(pt_backward); + pt_backward--; + pt_move = 2; + } else if (pt_move == 2) { + launch(pt_forward); + pt_forward++; + pt_move = 1; + } + } + } + + } else { + Log.i(TAG, "Sequencial scanning"); + for (long i = start; i <= end; i++) { + launch(i); + } + } + + mPool.shutdown(); + //暂时注释掉线程池管理类阻塞住，等待线程返回的相关代码 + try { + if (!mPool.awaitTermination(TIMEOUT_SCAN, TimeUnit.SECONDS)) { + mPool.shutdownNow(); + Log.e(TAG, "Shutting down pool"); + if (!mPool.awaitTermination(TIMEOUT_SHUTDOWN, TimeUnit.SECONDS)) { + Log.e(TAG, "Pool did not terminate"); + } + } + } catch (InterruptedException e) { + Log.e(TAG, e.getMessage()); + mPool.shutdownNow(); + Thread.currentThread().interrupt(); + } finally { + } + + + } + + @Override + protected void onCancelled() { + if (mPool != null) { + synchronized (mPool) { + mPool.shutdownNow(); + } + } + super.onCancelled(); + } + + private void launch(long i) { + if (!mPool.isShutdown()) { + mPool.execute(new CheckRunnable(NetScanInfo + .getIpFromLongUnsigned(i))); + } + } + + private int getRate() { + if (doRateControl) { + return mRateControl.rate; + } + + return Integer.parseInt(prefs.getString( + NetScanPrefs.KEY_TIMEOUT_DISCOVER, + NetScanPrefs.DEFAULT_TIMEOUT_DISCOVER)); + } + + private class CheckRunnable implements Runnable { + private String addr; + private String hardwareAddress; + + CheckRunnable(String addr) { + this.addr = addr; + } + + @Override + public void run() { + // Log.e(TAG, "run=" + addr); + // Create host object + + final HostBean host = new HostBean(); + host.responseTime = getRate(); + host.ipAddress = addr; + + try { + + InetAddress h = InetAddress.getByName(addr); + // Rate control check + if (doRateControl && mRateControl.indicator != null + && hosts_done % mRateMult == 0) { + mRateControl.adaptRate(); + } + // Arp Check #1 + //android10 不能访问proc/net 目录 + if (Build.VERSION.SDK_INT < 29) { + hardwareAddress = getHardwareAddress(addr); + } + if (hardwareAddress != null && !NOMAC.equals(hardwareAddress)) { + host.hardwareAddress = hardwareAddress; + Log.e(TAG, "CheckRunnable" + addr); + Log.e(TAG, "CheckRunnable" + host.hardwareAddress + "===" + hardwareAddress); + publish(host); + return; + } + // Native InetAddress check + if (h.isReachable(getRate())) { + Log.e(TAG, "found using InetAddress ping " + addr); + publish(host); + if (doRateControl && mRateControl.indicator == null) { + mRateControl.indicator = addr; + mRateControl.adaptRate(); + } + return; + } + + + } catch (IOException e) { + publish(null); + Log.e(TAG, e.getMessage()); + } + } + + } + + //解析地址 + public String getHardwareAddress(String ip) { + try { + if (ip != null) { + String hw = NOMAC; + String ptrn = String.format(NetScanInfo.MAC_RE, ip.replace(".", "\\.")); + Pattern pattern = Pattern.compile(ptrn); + BufferedReader bufferedReader = new BufferedReader(new FileReader("/proc/net/arp"), NetScanInfo.BUF); + String line; + Matcher matcher; + while ((line = bufferedReader.readLine()) != null) { + matcher = pattern.matcher(line); + if (matcher.matches()) { + hw = matcher.group(1); + break; + } + } + bufferedReader.close(); + return hw; + } else { + Log.e(TAG, "ip is null"); + } + } catch (IOException e) { + Log.e(TAG, "Can't open/read file ARP: " + e.getMessage()); + return NOMAC; + } + return NOMAC; + } + + private void publish(final HostBean host) { + hosts_done++; + if (host == null) { + publishProgress((HostBean) null); + return; + } + + // if (mDiscover != null) { + // final ActivityNet discover = mDiscover.get(); + // if (discover != null) { + // Is gateway ? + if (net.gatewayIp.equals(host.ipAddress)) { + host.deviceType = HostBean.TYPE_GATEWAY; + } + + // FQDN + // Static + if (host.hostname == null) { + // DNS + if (prefs.getBoolean(NetScanPrefs.KEY_RESOLVE_NAME, + NetScanPrefs.DEFAULT_RESOLVE_NAME) == true) { + try { + host.hostname = (InetAddress.getByName(host.ipAddress)) + .getCanonicalHostName(); + } catch (UnknownHostException e) { + Log.e(TAG, e.getMessage()); + } + } + } + + publishProgress(host); + } + + // 发送测试命令 + private void sendConnectCommand() { + sendCommand(); + } + + /** + * 发送 + */ + private void sendCommand() { + if (!mBstatus && addressIndex < hostsCache.size()) { + mCurrentHostBean = hostsCache.get(addressIndex); + addressIndex++; + //Log.e(TAG, "ipAddress:" + mCurrentHostBean.ipAddress.toString()); + RequestApi.setApiWifiIp(mCurrentHostBean.ipAddress.toString()); + command.getWifiTestStatus(mCurrentHostBean, getTag()); + } else if (mBstatus && addressIndex < hosts.size()) { + mCurrentHostBean = hosts.get(addressIndex); + addressIndex++; + //Log.e(TAG, "ipAddress:" + mCurrentHostBean.ipAddress.toString()); + RequestApi.setApiWifiIp(mCurrentHostBean.ipAddress.toString()); + command.getWifiTestStatus(mCurrentHostBean, getTag()); + } else { + if (scanHostBeanList != null && scanHostBeanList.size() > 0) { + + JSONArray jsonArray = new JSONArray(); + + for (int i = 0; i < scanHostBeanList.size(); i++) { + try { + JSONObject jobj = new JSONObject(); + jobj.put("ipAddress", scanHostBeanList.get(i).ipAddress); + jobj.put("hardwareAddress", scanHostBeanList.get(i).hardwareAddress); + //过滤重复内容 + if (!jsonArray.toString().contains(jobj.toString())) + jsonArray.put(jobj); + } catch (Exception e) { + + } + } + PreferencesUtils.saveSpText(mContext, "cacheHostBean", jsonArray.toString()); + } + cameraEventListener.OnSearchResponse(getTag(), scanHostBeanList); + } + } + + public int getTag() { + return tag; + } + + public void setTag(int tag) { + this.tag = tag; + } +} diff --git a/collect-library/src/main/java/com/navinfo/collect/library/sensor/Camera.java b/collect-library/src/main/java/com/navinfo/collect/library/sensor/Camera.java new file mode 100644 index 00000000..28290e06 --- /dev/null +++ b/collect-library/src/main/java/com/navinfo/collect/library/sensor/Camera.java @@ -0,0 +1,96 @@ +package com.navinfo.collect.library.sensor; + +import android.content.Context; + +import com.navinfo.collect.library.garminvirbxe.Command; +import com.navinfo.collect.library.garminvirbxe.SensorParams; + +public class Camera extends ISensor { + + private Context mContext; + private Command conmand; + + public Camera(Context mContext) { + this.mContext = mContext; + conmand = new Command(mContext); + } + + @Override + public enmSensorType GetSensorType() { + return enmSensorType.SENSOR_CAMEAR; + } + + @Override + public enmConnectionStatus GetConnectionStatus() { + return null; + } + + @Override + public enmConnectionStatus Connect(SensorParams params) { + // TODO Auto-generated method stub + return null; + } + + @Override + public enmConnectionStatus DisConnect() { + // TODO Auto-generated method stub + return null; + } + + @Override + public enmSignalQuality GetSignalQuality() { + // TODO Auto-generated method stub + return null; + } + + @Override + public void snapPicture(String picuuid) { + + } + + + @Override + public void StopRecording() { + conmand.StopRecording(null,0); + } + + + @Override + public void StartRecording() { + conmand.StartRecording(null,0); + } + + @Override + public int RegisterSensorEvent(SensorEventListener sensorEventLister) { + // TODO Auto-generated method stub + return 0; + } + + @Override + public void SetMode(SensorWorkingMode sensorWorkingMode) { + // TODO Auto-generated method stub + + } + + @Override + public void Search(boolean isReadCache) { + // TODO Auto-generated method stub + + } + + @Override + public void StopSearch() { + // TODO Auto-generated method stub + + } + + @Override + public void GetGpsStatus() { + // TODO Auto-generated method stub + + } + + public void OnConnectionStatusChanged(enmConnectionStatus cs){ + + } +} diff --git a/collect-library/src/main/java/com/navinfo/collect/library/sensor/ISensor.java b/collect-library/src/main/java/com/navinfo/collect/library/sensor/ISensor.java new file mode 100644 index 00000000..863cd5b1 --- /dev/null +++ b/collect-library/src/main/java/com/navinfo/collect/library/sensor/ISensor.java @@ -0,0 +1,83 @@ +package com.navinfo.collect.library.sensor; + +import com.navinfo.collect.library.garminvirbxe.SensorParams; + +public abstract class ISensor { + + public enum enmSensorType { + SENSOR_LOCATION, /* !< 位置传感器 */ + SENSOR_CAMEAR /* !< 图像传感器 */ + + }; + + public enum enmSensorModel { + LOCATION_GPS_INTERANL, /* !< 设备内部GPS */ + LOCATION_GPS_BLUETOOTH, /* !< 蓝牙GPS */ + LOCATION_SINS, + LOCATION_BAIDU, /* !< BaiDu location api */ + CAMERA_GARMIN_VIRB_XE, /* !< Garmin Virb xe 运动相机 */ + CAMERA_UNKNOWN, /* !< 未知相机类型 */ + LOCATION_SINS_BAIDU_MIX /* 百度和惯导混合定位*/ + } + + + //连接状态枚举 + public enum enmConnectionStatus { + + DISCONNECTTED/*断开连接*/, CONNECTTING/*连接中*/, CONNECTTED/*连接*/ + + } + + + //信号质量枚举 + public enum enmSignalQuality { + NO_SIGNAL/*无信号*/, POOR/*弱信号*/, MODERATE/*中等信号*/, PERFECT/*强信号*/ + } + + + + public enum SensorWorkingMode { + LOCATION_GPS_INTERNAL, /* !< 设备内部GPS */ + LOCATION_GPS_BLUETOOTH, /* !< 外接蓝牙GPS */ + LOCATION_GPS_HYBIRD, /* !< 混合模式 */ + + CAMEAR_PHOTO_12MP, /* !< 相机拍照模式 1200万像素 */ + CAMEAR_PHOTO_7MP, /* !< 相机拍照模式 7百万像素 */ + CAMEAR_PHOTO_CONTINUOUS_PHOTO, /* !< 相机自身连拍模式 */ + + CAMERA_VEDIO_1080P, /* !< 相机录像模式 1008P */ + CAMEAR_VEDIO_720P, /* !< 相机录像模式 720P */ + CAMERA_VEDIO_TIMELAPSE, /* !< 相机录像模式 缩时 */ + + CAMERA_PHOTO_SINGLE/*单拍模式*/ + } + + + public abstract enmSensorType GetSensorType(); + + public abstract enmConnectionStatus GetConnectionStatus(); + + public abstract enmConnectionStatus Connect(SensorParams params); + + public abstract enmConnectionStatus DisConnect(); + + public abstract enmSignalQuality GetSignalQuality(); + + public abstract void GetGpsStatus(); + + public abstract void snapPicture(String picuuid); + + public abstract void Search(boolean isReadCache); + + public abstract void StopSearch(); + + public abstract void StartRecording(); + + public abstract void StopRecording(); + + public abstract int RegisterSensorEvent( + SensorEventListener sensorEventLister); + + public abstract void SetMode(SensorWorkingMode sensorWorkingMode); + +} diff --git a/collect-library/src/main/java/com/navinfo/collect/library/sensor/SensorEventListener.java b/collect-library/src/main/java/com/navinfo/collect/library/sensor/SensorEventListener.java new file mode 100644 index 00000000..72131966 --- /dev/null +++ b/collect-library/src/main/java/com/navinfo/collect/library/sensor/SensorEventListener.java @@ -0,0 +1,14 @@ +package com.navinfo.collect.library.sensor; + +import com.navinfo.collect.library.sensor.ISensor.enmConnectionStatus; +import com.navinfo.collect.library.sensor.ISensor.enmSignalQuality; + +public interface SensorEventListener { + + public void OnSensorEvent(); + + public void OnConnectionStatusChanged(enmConnectionStatus cs); + + public void OnSignalQualityChanged(enmSignalQuality sq); + +} diff --git a/collect-library/src/main/java/com/navinfo/collect/library/utils/DateUtils.java b/collect-library/src/main/java/com/navinfo/collect/library/utils/DateUtils.java new file mode 100644 index 00000000..9cc897e7 --- /dev/null +++ b/collect-library/src/main/java/com/navinfo/collect/library/utils/DateUtils.java @@ -0,0 +1,60 @@ +package com.navinfo.collect.library.utils; + +import org.apache.commons.net.ntp.NTPUDPClient; +import org.apache.commons.net.ntp.NtpV3Packet; +import org.apache.commons.net.ntp.TimeInfo; + +import java.io.IOException; +import java.net.InetAddress; +import java.text.SimpleDateFormat; +import java.util.Date; + + +/** + * + * @author manle + * + * Contains function adapt date times + */ + +public class DateUtils { + + /** + * Get date after sync from NTP + * @param hosts {@link String[]} hosts server NTP + * @param timeOut {@link Integer} milisecod + * @return Date + */ + public static Date getNTPDate(String[] hosts, int timeOut) { + NTPUDPClient client = new NTPUDPClient(); + client.setDefaultTimeout(timeOut); + for (String host : hosts) { + try { + InetAddress hostAddr = InetAddress.getByName(host); + TimeInfo info = client.getTime(hostAddr); + NtpV3Packet message = info.getMessage(); + long serverTime = message.getTransmitTimeStamp().getTime(); + + Date date = new Date(serverTime); + return date; + + } + catch (IOException e) { + } + } + client.close(); + return null; + } + + /** + * Format time + * @param date + * @return + */ + public static String formatTime(final Date date){ + SimpleDateFormat timeFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS"); + String time = timeFormat.format(date); + return time; + + } +} diff --git a/collect-library/src/main/java/com/navinfo/collect/library/utils/NetScanInfo.java b/collect-library/src/main/java/com/navinfo/collect/library/utils/NetScanInfo.java new file mode 100644 index 00000000..0b2dc7c8 --- /dev/null +++ b/collect-library/src/main/java/com/navinfo/collect/library/utils/NetScanInfo.java @@ -0,0 +1,330 @@ + +package com.navinfo.collect.library.utils; + + +import android.content.Context; +import android.content.SharedPreferences; +import android.net.ConnectivityManager; +import android.net.NetworkInfo; +import android.net.wifi.SupplicantState; +import android.net.wifi.WifiInfo; +import android.net.wifi.WifiManager; +import android.preference.PreferenceManager; +import android.telephony.TelephonyManager; +import android.util.Log; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileReader; +import java.io.IOException; +import java.io.InputStreamReader; +import java.net.Inet4Address; +import java.net.Inet6Address; +import java.net.InetAddress; +import java.net.NetworkInterface; +import java.net.SocketException; +import java.util.Enumeration; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +// TODO: IPv6 support + +public class NetScanInfo { + private final static String TAG = "NetInfo"; + public static final int BUF = 8 * 1024; + private static final String CMD_IP = " -f inet addr show %s"; + private static final String PTN_IP1 = "\\s*inet [0-9\\.]+\\/([0-9]+) brd [0-9\\.]+ scope global %s$"; + private static final String PTN_IP2 = "\\s*inet [0-9\\.]+ peer [0-9\\.]+\\/([0-9]+) scope global %s$"; // FIXME: + // Merge + // with + // PTN_IP1 + private static final String PTN_IF = "^%s: ip [0-9\\.]+ mask ([0-9\\.]+) flags.*"; + private static final String NOIF = "0"; + public static final String NOIP = "0.0.0.0"; + public static final String NOMASK = "255.255.255.255"; + public static final String NOMAC = "00:00:00:00:00:00"; + private Context ctxt; + private WifiInfo info; + private SharedPreferences prefs; + + public String intf = "eth0"; + public String ip = NOIP; + public int cidr = 24; + + public int speed = 0; + public String ssid = null; + public String bssid = null; + public String carrier = null; + public String macAddress = NOMAC; + public String netmaskIp = NOMASK; + public String gatewayIp = NOIP; + + private final static String REQ = "select vendor from oui where mac=?"; + // 0x1 is HW Type: Ethernet (10Mb) [JBP] + // 0x2 is ARP Flag: completed entry (ha valid) + public final static String MAC_RE = "^%s\\s+0x1\\s+0x2\\s+([:0-9a-fA-F]+)\\s+\\*\\s+\\w+$"; + + public NetScanInfo(final Context ctxt) { + this.ctxt = ctxt; + prefs = PreferenceManager.getDefaultSharedPreferences(ctxt); + getIp(); + getWifiInfo(); + + } + + @Override + public int hashCode() { + int ip_custom = prefs.getBoolean(NetScanPrefs.KEY_IP_CUSTOM, + NetScanPrefs.DEFAULT_IP_CUSTOM) ? 1 : 0; + int ip_start = prefs.getString(NetScanPrefs.KEY_IP_START, + NetScanPrefs.DEFAULT_IP_START).hashCode(); + int ip_end = prefs.getString(NetScanPrefs.KEY_IP_END, NetScanPrefs.DEFAULT_IP_END) + .hashCode(); + int cidr_custom = prefs.getBoolean(NetScanPrefs.KEY_CIDR_CUSTOM, + NetScanPrefs.DEFAULT_CIDR_CUSTOM) ? 1 : 0; + int cidr = prefs.getString(NetScanPrefs.KEY_CIDR, NetScanPrefs.DEFAULT_CIDR) + .hashCode(); + return 42 + intf.hashCode() + ip.hashCode() + cidr + ip_custom + + ip_start + ip_end + cidr_custom + cidr; + } + + public void getIp() { + intf = prefs.getString(NetScanPrefs.KEY_INTF, NetScanPrefs.DEFAULT_INTF); + try { + if (intf == NetScanPrefs.DEFAULT_INTF || NOIF.equals(intf)) { + // Automatic interface selection + for (Enumeration en = NetworkInterface + .getNetworkInterfaces(); en.hasMoreElements();) { + NetworkInterface ni = en.nextElement(); + intf = ni.getName(); + ip = getInterfaceFirstIp(ni); + if (ip != NOIP) { +/* Log.i("AAA",intf+""); + Log.i("AAA",new String(ni.getHardwareAddress())+"");*/ + break; + } + } + } else { + // Defined interface from Prefs + ip = getInterfaceFirstIp(NetworkInterface.getByName(intf)); + } + } catch (SocketException e) { + Log.e(TAG, e.getMessage()); + } + getCidr(); + } + + private String getInterfaceFirstIp(NetworkInterface ni) { + if (ni != null) { + for (Enumeration nis = ni.getInetAddresses(); nis + .hasMoreElements();) { + InetAddress ia = nis.nextElement(); + if (!ia.isLoopbackAddress()) { + if (ia instanceof Inet6Address) { + Log.i(TAG, "IPv6 detected and not supported yet!"); + continue; + } + return ia.getHostAddress(); + } + } + } + return NOIP; + } + + private void getCidr() { + if (netmaskIp != NOMASK) { + cidr = IpToCidr(netmaskIp); + } else { + String match; + // Running ip tools + try { + if ((match = runCommand("/system/xbin/ip", + String.format(CMD_IP, intf), + String.format(PTN_IP1, intf))) != null) { + cidr = Integer.parseInt(match); + return; + } else if ((match = runCommand("/system/xbin/ip", + String.format(CMD_IP, intf), + String.format(PTN_IP2, intf))) != null) { + cidr = Integer.parseInt(match); + return; + } else if ((match = runCommand("/system/bin/ifconfig", " " + + intf, String.format(PTN_IF, intf))) != null) { + cidr = IpToCidr(match); + return; + } else { + Log.i(TAG, "cannot find cidr, using default /24"); + } + } catch (NumberFormatException e) { + Log.i(TAG, e.getMessage() + + " -> cannot find cidr, using default /24"); + } + } + } + + // FIXME: Factorize, this isn't a generic runCommand() + private String runCommand(String path, String cmd, String ptn) { + try { + if (new File(path).exists() == true) { + String line; + Matcher matcher; + Pattern ptrn = Pattern.compile(ptn); + Process p = Runtime.getRuntime().exec(path + cmd); + BufferedReader r = new BufferedReader(new InputStreamReader( + p.getInputStream()), BUF); + while ((line = r.readLine()) != null) { + matcher = ptrn.matcher(line); + if (matcher.matches()) { + return matcher.group(1); + } + } + } + } catch (Exception e) { + Log.e(TAG, "Can't use native command: " + e.getMessage()); + return null; + } + return null; + } + + public boolean getMobileInfo() { + TelephonyManager tm = (TelephonyManager) ctxt + .getSystemService(Context.TELEPHONY_SERVICE); + if (tm != null) { + carrier = tm.getNetworkOperatorName(); + } + return false; + } + + public boolean getWifiInfo() { + WifiManager wifi = (WifiManager) ctxt + .getSystemService(Context.WIFI_SERVICE); + if (wifi != null) { + info = wifi.getConnectionInfo(); + // Set wifi variables + speed = info.getLinkSpeed(); + ssid = info.getSSID(); + bssid = info.getBSSID(); + macAddress = info.getMacAddress(); + gatewayIp = getIpFromIntSigned(wifi.getDhcpInfo().gateway); + // broadcastIp = getIpFromIntSigned((dhcp.ipAddress & dhcp.netmask) + // | ~dhcp.netmask); + netmaskIp = getIpFromIntSigned(wifi.getDhcpInfo().netmask); + return true; + } + return false; + } + + public String getNetIp() { + int shift = (32 - cidr); + int start = ((int) getUnsignedLongFromIp(ip) >> shift << shift); + return getIpFromLongUnsigned(start); + } + + public SupplicantState getSupplicantState() { + return info.getSupplicantState(); + } + + public static boolean isConnected(Context ctxt) { + NetworkInfo nfo = ((ConnectivityManager) ctxt + .getSystemService(Context.CONNECTIVITY_SERVICE)) + .getActiveNetworkInfo(); + if (nfo != null) { + return nfo.isConnected(); + } + return false; + } + + //获取本地ip地址 + public static String getLocAddress(){ + + String ipaddress = ""; + + try { + Enumeration en = NetworkInterface.getNetworkInterfaces(); + // 遍历所用的网络接口 + while (en.hasMoreElements()) { + NetworkInterface networks = en.nextElement(); + // 得到每一个网络接口绑定的所有ip + Enumeration address = networks.getInetAddresses(); + // 遍历每一个接口绑定的所有ip + while (address.hasMoreElements()) { + InetAddress ip = address.nextElement(); + if (!ip.isLoopbackAddress() + && ip instanceof Inet4Address) { + ipaddress = ip.getHostAddress(); + } + } + } + } catch (SocketException e) { + Log.e("", "获取本地ip地址失败"); + e.printStackTrace(); + } + + return ipaddress; + + } + + public static long getUnsignedLongFromIp(String ip_addr) { + String[] a = ip_addr.split("\\."); + return (Integer.parseInt(a[0]) * 16777216 + Integer.parseInt(a[1]) + * 65536 + Integer.parseInt(a[2]) * 256 + Integer.parseInt(a[3])); + } + + public static String getIpFromIntSigned(int ip_int) { + String ip = ""; + for (int k = 0; k < 4; k++) { + ip = ip + ((ip_int >> k * 8) & 0xFF) + "."; + } + return ip.substring(0, ip.length() - 1); + } + + public static String getIpFromLongUnsigned(long ip_long) { + String ip = ""; + for (int k = 3; k > -1; k--) { + ip = ip + ((ip_long >> k * 8) & 0xFF) + "."; + } + return ip.substring(0, ip.length() - 1); + } + + private int IpToCidr(String ip) { + double sum = -2; + String[] part = ip.split("\\."); + for (String p : part) { + sum += 256D - Double.parseDouble(p); + } + return 32 - (int) (Math.log(sum) / Math.log(2d)); + } + + //根据ip解析mac + public String getHardwareAddress(String ip) { + try { + synchronized (this){ + if (ip != null) { + Log.e(TAG, "开始=="+ip); + String hw = NOMAC; + String ptrn = String.format(MAC_RE, ip.replace(".", "\\.")); + Pattern pattern = Pattern.compile(ptrn); + BufferedReader bufferedReader = new BufferedReader(new FileReader("/proc/net/arp"), BUF); + String line; + Matcher matcher; + while ((line = bufferedReader.readLine()) != null) { + matcher = pattern.matcher(line); + if (matcher.matches()) { + hw = matcher.group(1); + break; + } + } + bufferedReader.close(); + Log.e(TAG, "结束=="+hw); + return hw; + } else { + Log.e(TAG, "ip is null"); + } + } + } catch (IOException e) { + Log.e(TAG, "Can't open/read file ARP: " + e.getMessage()); + return NOMAC; + } + return NOMAC; + } +} diff --git a/collect-library/src/main/java/com/navinfo/collect/library/utils/NetScanPrefs.java b/collect-library/src/main/java/com/navinfo/collect/library/utils/NetScanPrefs.java new file mode 100644 index 00000000..2b3d1776 --- /dev/null +++ b/collect-library/src/main/java/com/navinfo/collect/library/utils/NetScanPrefs.java @@ -0,0 +1,32 @@ +package com.navinfo.collect.library.utils; + +public class NetScanPrefs { + + public final static String KEY_RESOLVE_NAME = "resolve_name"; + public final static boolean DEFAULT_RESOLVE_NAME = true; + + public static final String KEY_RATECTRL_ENABLE = "ratecontrol_enable"; + public static final boolean DEFAULT_RATECTRL_ENABLE = true; + + public final static String KEY_TIMEOUT_DISCOVER = "timeout_discover"; + public final static String DEFAULT_TIMEOUT_DISCOVER = "500"; + + public static final String KEY_INTF = "interface"; + public static final String DEFAULT_INTF = null; + + public static final String KEY_IP_START = "ip_start"; + public static final String DEFAULT_IP_START = "0.0.0.0"; + + public static final String KEY_IP_END = "ip_end"; + public static final String DEFAULT_IP_END = "0.0.0.0"; + + public static final String KEY_IP_CUSTOM = "ip_custom"; + public static final boolean DEFAULT_IP_CUSTOM = false; + + public static final String KEY_CIDR_CUSTOM = "cidr_custom"; + public static final boolean DEFAULT_CIDR_CUSTOM = false; + + public static final String KEY_CIDR = "cidr"; + public static final String DEFAULT_CIDR = "24"; + +} diff --git a/collect-library/src/main/java/com/navinfo/collect/library/utils/PreferencesUtils.java b/collect-library/src/main/java/com/navinfo/collect/library/utils/PreferencesUtils.java new file mode 100644 index 00000000..7b261854 --- /dev/null +++ b/collect-library/src/main/java/com/navinfo/collect/library/utils/PreferencesUtils.java @@ -0,0 +1,94 @@ +package com.navinfo.collect.library.utils; + +import android.content.Context; +import android.content.SharedPreferences; + +public class PreferencesUtils { + protected static final String XML_NAME = "cjzq_trade"; + protected static final String KEEP_NOTIFICATION_FLAG = "notification_flag"; + + private static SharedPreferences getSharedPreferences(Context context) { + return context.getSharedPreferences(XML_NAME, Context.MODE_PRIVATE); + } + + public static String getMsgNotificationFlag(Context context) { + SharedPreferences sp = getSharedPreferences(context); + return sp.getString(KEEP_NOTIFICATION_FLAG, "1"); + } + + /** + * + * @param context + * @param flag + */ + public static void saveMsgNotificationFlag(Context context, String flag) { + SharedPreferences sp = getSharedPreferences(context); + SharedPreferences.Editor editor = sp.edit(); + editor.putString(KEEP_NOTIFICATION_FLAG, flag); + editor.commit(); + } + + /** + * 保存sp值 + * + * @param context + * @param name + * @param flag + */ + public static void saveSpText(Context context, String key, String value) { + SharedPreferences sp = getSharedPreferences(context); + SharedPreferences.Editor editor = sp.edit(); + editor.putString(key, value); + editor.commit(); + } + + /** + * 获取值 + * + * @param context + * @param name + * @return + */ + public static String getSpText(Context context, String key) { + SharedPreferences sp = getSharedPreferences(context); + return sp.getString(key, ""); + } + + /** + * 移除值 + * + * @param context + * @param name + * @return + */ + public static void removeSpText(Context context, String name) { + SharedPreferences sp = getSharedPreferences(context); + SharedPreferences.Editor editor = sp.edit(); + editor.remove(name); + editor.commit(); + } + + public static String getConnectIp(Context context, String key) { + SharedPreferences sp = getSharedPreferences(context); + return sp.getString(key, ""); + } + + public static void saveConnectIp(Context context,String key, String ip) { + SharedPreferences sp = getSharedPreferences(context); + SharedPreferences.Editor editor = sp.edit(); + editor.putString(key, ip); + editor.commit(); + } + + public static String getConnectWifiName(Context context) { + SharedPreferences sp = getSharedPreferences(context); + return sp.getString("connectwifiname", ""); + } + + public static void saveConnectWifiName(Context context, String name) { + SharedPreferences sp = getSharedPreferences(context); + SharedPreferences.Editor editor = sp.edit(); + editor.putString("connectwifiname", name); + editor.commit(); + } +} diff --git a/collect-library/src/main/java/com/navinfo/collect/library/utils/SensorUtils.java b/collect-library/src/main/java/com/navinfo/collect/library/utils/SensorUtils.java new file mode 100644 index 00000000..8a57410c --- /dev/null +++ b/collect-library/src/main/java/com/navinfo/collect/library/utils/SensorUtils.java @@ -0,0 +1,124 @@ +package com.navinfo.collect.library.utils; + +import android.content.Context; +import android.graphics.Bitmap; +import android.net.ConnectivityManager; +import android.net.NetworkInfo; +import android.os.Environment; +import android.text.format.DateUtils; + +import com.navinfo.collect.library.garminvirbxe.CameraGarminVirbXE; + +import org.apache.commons.lang3.StringUtils; +import java.io.BufferedOutputStream; +import java.io.File; +import java.io.FileOutputStream; +import java.io.IOException; +import java.util.Date; + +public class SensorUtils { + public static String STR_CAMERA_PICTURE_SAVEPATH = Environment + .getExternalStorageDirectory() + "/Sensor/Camera/DCIM/"; + public static String ntpHosts = "0.ir.pool.ntp.org,1.ir.pool.ntp.org,2.ir.pool.ntp.org,3.ir.pool.ntp.org"; + + // 由于连接命令和扫描测试通讯命令相同，需要通过不通返回来确认。 + public final static int HADNLE_STATUS_OK = 1; // 获取状态成功返回handle + public final static int HADNLE_STATUS_FAIL = 0; // 获取状态失败返回handle + public final static int HADNLE_CONNECT_OK = 2; // 连接成功返回handle + public final static int HADNLE_CONNECT_FAIL = 3; // 连接失败返回handle + public final static int HADNLE_SNAPPICTURE = 4; // 失败返回handle + + public final static int HADNLE_MONITORING = 5; // 状态监控失败返回handle + + /** + * 保存文件 + * + * @param bm + * @param fileName + * @throws IOException + */ + public static void saveFile(Bitmap bm, String fileName) throws IOException { + String savePath = CameraGarminVirbXE.getCameraPcitureSavePath(); + File dirFile = new File(savePath); + if (!dirFile.exists()) { + dirFile.mkdirs(); + } + File myCaptureFile = new File(savePath + fileName); + BufferedOutputStream bos = new BufferedOutputStream( + new FileOutputStream(myCaptureFile)); + bm.compress(Bitmap.CompressFormat.JPEG, 80, bos); + bos.flush(); + bos.close(); + } + + /* + * Java文件操作 获取文件扩展名 + */ + public static String getExtensionName(String filename) { + if ((filename != null) && (filename.length() > 0)) { + int dot = filename.lastIndexOf('.'); + if ((dot > -1) && (dot < (filename.length() - 1))) { + return filename.substring(dot + 1); + } + } + return filename; + } + + /* + * Java文件操作 获取不带扩展名的文件名 + */ + public static String getFileNameNoEx(String filename) { + if ((filename != null) && (filename.length() > 0)) { + int dot = filename.lastIndexOf('.'); + if ((dot > -1) && (dot < (filename.length()))) { + return filename.substring(0, dot); + } + } + return filename; + } + + /** + * 检测网络是否连接 + * + * @return + */ + public static boolean isNetworkAvailable(Context context) + { + // 获取手机所有连接管理对象（包括对wi-fi,net等连接的管理） + ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE); + + if (connectivityManager == null){ + return false; + }else{ + // 获取NetworkInfo对象 + NetworkInfo[] networkInfo = connectivityManager.getAllNetworkInfo(); + + if (networkInfo != null && networkInfo.length > 0){ + for (int i = 0; i < networkInfo.length; i++){ + System.out.println(i + "===状态===" + networkInfo[i].getState()); + // System.out.println(i + "===类型===" + networkInfo[i].getTypeName()); + // 判断当前网络状态是否为连接状态 + if (networkInfo[i].getState() == NetworkInfo.State.CONNECTED){ + return true; + } + } + } + } + return false; + } + + /** + * 同步ntp服务器的网络时间 + * @return + */ + public static Date syncNow(){ + String[] hostsArrayNTP = null; + if(StringUtils.isNotBlank(ntpHosts)){ + hostsArrayNTP =ntpHosts.trim().split(","); + } + + Date dateNTP = com.navinfo.collect.library.utils.DateUtils.getNTPDate(hostsArrayNTP, 5000); + + return dateNTP; + } +}