升级AiCloudSDK
删除废弃modules

Signed-off-by: donghongyu <donghongyu@zhidaoauto.com>
This commit is contained in:
donghongyu
2022-03-18 19:25:30 +08:00
parent eb978fbfb5
commit 1c3da7244d
1449 changed files with 12 additions and 49355 deletions

View File

@@ -214,10 +214,10 @@ public abstract class MainMoGoApplication extends AbsMogoApplication {
Double.parseDouble(latitude),
Double.parseDouble(longitude));
} catch (NumberFormatException e) {
e.printStackTrace();
// e.printStackTrace();
httpDnsSimpleLocation = new HttpDnsSimpleLocation("010", 1, 1);
}
CallerLogger.INSTANCE.d(M_MAIN + TAG, "使用缓存GPS信息" + httpDnsSimpleLocation);
//CallerLogger.INSTANCE.d(M_MAIN + TAG, "使用缓存GPS信息" + httpDnsSimpleLocation);
}
return httpDnsSimpleLocation;
});

View File

@@ -63,23 +63,23 @@ SERVICE_CHAIN_VERSION=1.0.53
LOGLIB_VERSION=1.2.19
######## MogoAiCloudSDK Version ########
# 网络请求
MOGO_NETWORK_VERSION=1.3.31
MOGO_NETWORK_VERSION=1.3.32
# 鉴权
MOGO_PASSPORT_VERSION=1.3.31
MOGO_PASSPORT_VERSION=1.3.32
# 常链接
MOGO_SOCKET_VERSION=1.3.31
MOGO_SOCKET_VERSION=1.3.32
# 数据采集
MOGO_REALTIME_VERSION=1.3.31
MOGO_REALTIME_VERSION=1.3.32
# 探路,道路事件发布,获取
MOGO_TANLU_VERSION=1.3.31
MOGO_TANLU_VERSION=1.3.32
# 直播推流
MOGO_LIVE_VERSION=1.3.31
MOGO_LIVE_VERSION=1.3.32
# 直播拉流
MOGO_TRAFFICLIVE_VERSION=1.3.31
MOGO_TRAFFICLIVE_VERSION=1.3.32
# 定位服务
MOGO_LOCATION_VERSION=1.3.31
MOGO_LOCATION_VERSION=1.3.32
# 远程通讯模块
MOGO_TELEMATIC_VERSION=1.3.31
MOGO_TELEMATIC_VERSION=1.3.32
######## MogoAiCloudSDK Version ########
# 自研地图
MAP_SDK_VERSION=2.0.9.1
@@ -155,5 +155,5 @@ MOGO_OCH_TAXI_VERSION=2.0.66
# mogoAiCloud sdk services
MOGO_AICLOUD_SERVICES_SDK_VERSION=2.1.16.10
# v2x-sdk
MOGO_V2X_SDK_VERSION=1.3.31
MOGO_V2X_SDK_VERSION=1.3.32
################# 旧版本架构模块版本 #################

View File

@@ -1 +0,0 @@
/build

File diff suppressed because it is too large Load Diff

View File

@@ -1,84 +0,0 @@
plugins {
id 'com.android.library'
id 'kotlin-android'
id 'kotlin-android-extensions'
id 'kotlin-kapt'
id 'com.alibaba.arouter'
}
android {
compileSdkVersion rootProject.ext.android.compileSdkVersion
// buildToolsVersion rootProject.ext.android.buildToolsVersion
defaultConfig {
minSdkVersion rootProject.ext.android.minSdkVersion
targetSdkVersion rootProject.ext.android.targetSdkVersion
versionCode Integer.valueOf(VERSION_CODE)
versionName getValueFromRootProperties("${project.name.replace("-", "_").toUpperCase()}_VERSION")
testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
consumerProguardFiles "consumer-rules.pro"
//ARouter apt 参数
kapt {
useBuildCache = false
arguments {
arg("AROUTER_MODULE_NAME", project.getName())
}
}
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
}
}
compileOptions {
sourceCompatibility 1.8
targetCompatibility 1.8
}
packagingOptions {
exclude 'META-INF/proguard/coroutines.pro'
exclude 'META-INF/*'
}
lintOptions {
abortOnError false
}
}
dependencies {
implementation fileTree(dir: 'libs', include: ['*.jar'])
implementation rootProject.ext.dependencies.androidxappcompat
implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
implementation rootProject.ext.dependencies.arouter
kapt rootProject.ext.dependencies.aroutercompiler
if (Boolean.valueOf(USE_MAVEN_PACKAGE)) {
implementation rootProject.ext.dependencies.mogo_core_utils
implementation rootProject.ext.dependencies.mogomapapi
implementation rootProject.ext.dependencies.mogocommons
implementation rootProject.ext.dependencies.mogo_core_utils
implementation rootProject.ext.dependencies.mogo_core_data
implementation rootProject.ext.dependencies.mogo_core_function_call
} else {
implementation project(':core:mogo-core-utils')
implementation project(':libraries:mogo-map-api')
implementation project(':foudations:mogo-commons')
implementation project(':core:mogo-core-utils')
implementation project(':core:mogo-core-data')
implementation project(':core:mogo-core-function-call')
}
implementation rootProject.ext.dependencies.mogocustommap
}
apply from: new File(rootProject.rootDir, "gradle/upload.gradle").toString()

View File

@@ -1,14 +0,0 @@
#-----自研地图-----
-keepattributes EnclosingMethod
-keep class com.autonavi.nge.**{*;}
-keep class io.netty.**{*;}
-keep class com.zhidaoauto.map.sdk.inner.abs.**{*;}
-keep class com.zhidaoauto.map.sdk.inner.panel.**{*;}
-keep class com.zhidaoauto.map.sdk.inner.search.**{*;}
-keep class com.zhidaoauto.map.sdk.inner.element.**{*;}
-keep class com.zhidaoauto.map.sdk.inner.obj.**{*;}
-keep class com.zhidaoauto.map.sdk.open.**{*;}
-keepattributes Exceptions,InnerClasses,...
-keep class com.zhidaoauto.map.sdk.open.camera.CameraPosition{ *; }

View File

@@ -1,3 +0,0 @@
GROUP=com.mogo.map
POM_ARTIFACT_ID=map-custom
VERSION_CODE=1

View File

@@ -1,116 +0,0 @@
group:com.zhidaoauto.machine:map:1.0.0-vr-
version note:
8.5.15
增加限速接口:
MapDataApi.getLimitSpeed(lon: Double,lat: Double,angle: Float)
8.5.16
增加远中近视角切换接口:
mapAutoView.getMapAutoViewHelper()?.setMapViewVisualAngle(type
type 0=近景 1=中景 2=远景
视角切换监听事件
mapAutoView.setOnMapViewVisualAngleChangeListener
8.5.17
更新了顺义数据
8.5.19
修改自车模型
8.5.22
修改自车模型
2D锚点缩放功能
普通模式poi显示问题
8.5.24
优化渲染时间
更新衡阳数据
临时处理绘制3D模型策略
8.5.25
修改远景下拖动地图偶现黑屏问题
关闭部分多余日志
8.5.26
更新顺义高精数据
优化渲染效率
修改切换后台黑屏问题
8.5.28
修改远视角高度bug并修正切换动画
修改路牌显示
修改红绿灯摄像头显示bug
优化渲染效率
8.5.29
添加了3D锚点动画
近远景切换,会导致车道线渲染不全
修改地图移动方法
8.5.31
修改近景切换
添加自动开启定位开关
修改桥模型
mapAutoView.getMapAutoViewHelper()?.setNearViewAnglePositionLonLatPoint(112.57392375608,26.830652231402))切换近视角
8.5.32
解决崩溃问题
8.5.33
更新顺义衡阳数
8.5.34
高精数据放到redis
8.5.35
修改绿化带显示问题
暂时对sdk去掉混淆方便crash定位
解决bugly #304037 问题
8.5.38
修改崩溃bug
更换最新的摄像头和红绿灯
8.5.40
修改崩溃bug
更新路牌数据
修改近视角切换
8.5.47
修改绿化带相关
修改crash bug
更新衡阳数据
8.5.48
fix crash
8.5.49
1.更新衡阳数据包含38Km和城区200km
2.新增路牌
8.5.53
修改崩溃
8.5.54
1.更新衡阳数据
2. 新增路牌
8.5.55
修改路牌数据以及图片
8.5.56
日志修改crash
8.5.58
修改画线问题
8.5.60
修改崩溃
8.5.63
修改infoWindow崩溃
8.5.64
修改崩溃

View File

@@ -1,21 +0,0 @@
# Add project specific ProGuard rules here.
# You can control the set of applied configuration files using the
# proguardFiles setting in build.gradle.
#
# For more details, see
# http://developer.android.com/guide/developing/tools/proguard.html
# If your project uses WebView with JS, uncomment the following
# and specify the fully qualified class name to the JavaScript interface
# class:
#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
# public *;
#}
# Uncomment this to preserve the line number information for
# debugging stack traces.
#-keepattributes SourceFile,LineNumberTable
# If you keep the line number information, uncomment this to
# hide the original source file name.
#-renamesourcefileattribute SourceFile

View File

@@ -1,7 +0,0 @@
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.mogo.map.impl.custom">
<application>
</application>
</manifest>

View File

@@ -1,77 +0,0 @@
package com.mogo.map.impl.custom;
import static com.mogo.map.marker.MarkerType.MAP_STATIC;
import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger;
import com.mogo.map.impl.custom.marker.AMapMarkerWrapper;
import com.mogo.map.impl.custom.marker.MarkerWrapperClickHelper;
import com.mogo.map.marker.IMogoMarker;
import com.mogo.map.marker.IMogoMarkerClickListener;
import com.mogo.map.marker.MogoMarkerOptions;
import com.mogo.map.marker.MogoMarkersHandler;
import com.zhidaoauto.map.sdk.open.marker.Marker;
import java.util.Map;
/**
* @author congtaowang
* @since 2019-12-24
* <p>
* marker 点击事件处理
*/
public class AMapMarkerClickHandler {
private static volatile AMapMarkerClickHandler sInstance;
private AMapMarkerClickHandler() {
}
public static AMapMarkerClickHandler getInstance() {
if (sInstance == null) {
synchronized (AMapMarkerClickHandler.class) {
if (sInstance == null) {
sInstance = new AMapMarkerClickHandler();
}
}
}
return sInstance;
}
public synchronized void release() {
sInstance = null;
}
private Object readResolve() {
// 阻止反序列化,必须实现 Serializable 接口
return sInstance;
}
public boolean handleMarkerClicked(Marker marker) {
if (marker == null) {
return false;
}
//地图道路上静态数暂时只过滤traffic类型下发点击事件
if (MarkerWrapperClickHelper.getInstance().isStaticMarker(marker.getId())) {
IMogoMarker iMogoMarker = new AMapMarkerWrapper(marker, new MogoMarkerOptions());
iMogoMarker.setOwner(MAP_STATIC); //TODO 后续可能由于类型比较多需要owner匹配机制,以及控制owner细粒度
CallerLogger.INSTANCE.d("AMapMarkerWrapper", "traffic marker 点击回调");
return MogoMarkersHandler.getInstance().onStaticMarkerClicked(iMogoMarker);
}
Map<String, IMogoMarker> mogoMarkerMap = MarkerWrapperClickHelper.getInstance().getMogoMarkerMap();
if (mogoMarkerMap.containsKey(marker.getId())) {
IMogoMarker mogoMarker = mogoMarkerMap.get(marker.getId());
final IMogoMarkerClickListener listener = mogoMarker.getOnMarkerClickListener();
CallerLogger.INSTANCE.d("AMapMarkerWrapper", "marker 点击回调 mogoMarker " + mogoMarker + ", marker :" + marker);
if (listener != null) {
boolean result = listener.onMarkerClicked(mogoMarker);
if (result) {
return true;
}
}
return MogoMarkersHandler.getInstance().onMarkerClicked(mogoMarker);
}
return false;
}
}

View File

@@ -1,111 +0,0 @@
package com.mogo.map.impl.custom;
import com.mogo.map.IMogoUiSettings;
import com.zhidaoauto.map.sdk.open.view.MapAutoViewHelper;
import java.lang.reflect.Method;
/**
* @author congtaowang
* @since 2019-12-18
* <p>
* 代理自研地图UiSettings
*/
public class AMapUiSettingsWrapper implements IMogoUiSettings {
private MapAutoViewHelper mUiSettings;
public AMapUiSettingsWrapper( MapAutoViewHelper mUiSettings ) {
this.mUiSettings = mUiSettings;
}
@Override
public void setScaleControlsEnabled( boolean enabled ) {
if ( mUiSettings != null ) {
}
}
@Override
public void setZoomControlsEnabled( boolean enabled ) {
if ( mUiSettings != null ) {
mUiSettings.setZoomGesturesEnabled( enabled );
}
}
@Override
public void setCompassEnabled( boolean enabled ) {
if ( mUiSettings != null ) {
if(enabled){
mUiSettings.showDirection();
}else{
mUiSettings.hiddenDirection();
}
}
}
@Override
public void setMyLocationButtonEnabled( boolean enabled ) {
if ( mUiSettings != null ) {
if(enabled){
mUiSettings.showLocation();
}else{
mUiSettings.hiddenLocation();
}
}
}
@Override
public void setScrollGesturesEnabled( boolean enabled ) {
if ( mUiSettings != null ) {
mUiSettings.setScrollGesturesEnabled( enabled );
}
}
@Override
public void setZoomGesturesEnabled( boolean enabled ) {
if ( mUiSettings != null ) {
mUiSettings.setZoomGesturesEnabled( enabled );
}
}
@Override
public void setTiltGesturesEnabled( boolean enabled ) {
if ( mUiSettings != null ) {
mUiSettings.setTiltGesturesEnabled( enabled );
}
}
@Override
public void setRotateGesturesEnabled( boolean enabled ) {
if ( mUiSettings != null ) {
mUiSettings.setRotateGesturesEnabled( enabled );
}
}
@Override
public void setAllGesturesEnabled( boolean enabled ) {
if ( mUiSettings != null ) {
mUiSettings.setAllGesturesEnabled( enabled );
}
}
@Override
public void setIndoorSwitchEnabled( boolean enabled ) {
if ( mUiSettings != null ) {
// mUiSettings.setIndoorSwitchEnabled( enabled );
}
}
@Override
public void setLogoEnable( boolean enabled ) {
if ( mUiSettings != null ) {
try {
Method method = mUiSettings.getClass().getMethod( "setLogoEnable", boolean.class );
method.setAccessible( true );
method.invoke( mUiSettings, enabled );
} catch ( Exception e ) {
e.printStackTrace();
}
}
}
}

View File

@@ -1,327 +0,0 @@
package com.mogo.map.impl.custom;
import android.content.Context;
import android.graphics.Point;
import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger;
import com.mogo.map.IMogoMap;
import com.mogo.map.IMogoUiSettings;
import com.mogo.map.impl.custom.marker.AMapInfoWindowAdapter;
import com.mogo.map.impl.custom.marker.AMapMarkerWrapper;
import com.mogo.map.impl.custom.overlay.AMapPolylineWrapper;
import com.mogo.map.impl.custom.uicontroller.AMapUIController;
import com.mogo.map.impl.custom.utils.ObjectUtils;
import com.mogo.map.marker.IMogoMarker;
import com.mogo.map.marker.MogoMarkerOptions;
import com.mogo.map.marker.MogoMarkersHandler;
import com.mogo.map.overlay.IMogoPolyline;
import com.mogo.map.overlay.MogoPolylineOptions;
import com.mogo.map.uicontroller.IMogoMapUIController;
import com.zhidaoauto.map.sdk.open.MapAutoApi;
import com.zhidaoauto.map.sdk.open.data.MapDataApi;
import com.zhidaoauto.map.sdk.open.data.SinglePointRoadInfo;
import com.zhidaoauto.map.sdk.open.marker.Marker;
import com.zhidaoauto.map.sdk.open.marker.MarkerHelper;
import com.zhidaoauto.map.sdk.open.marker.MarkerOptions;
import com.zhidaoauto.map.sdk.open.marker.MarkerSimpleData;
import com.zhidaoauto.map.sdk.open.marker.MultiPointOverlayOptions;
import com.zhidaoauto.map.sdk.open.poyline.Polyline;
import com.zhidaoauto.map.sdk.open.poyline.PolylineOptions;
import com.zhidaoauto.map.sdk.open.query.LonLatPoint;
import com.zhidaoauto.map.sdk.open.tools.MapTools;
import com.zhidaoauto.map.sdk.open.view.MapAutoView;
import com.zhidaoauto.map.sdk.open.view.MapAutoViewHelper;
import java.util.ArrayList;
import java.util.List;
import mogo.telematics.pad.MessagePad;
/**
* @author congtaowang
* @since 2019-12-18
* <p>
* 代理自研AMap
*/
public class AMapWrapper implements IMogoMap {
private static final String TAG = "AMapWrapper";
private static MapAutoViewHelper sAMap;
private IMogoMapUIController mUIcontroller;
private MapAutoViewHelper mAMap;
private MapAutoView mMapView;
private IMogoUiSettings mUiSettings;
public AMapWrapper(MapAutoViewHelper map, MapAutoView mapView, IMogoMapUIController controller) {
CallerLogger.INSTANCE.i(TAG, "autoop--AMapWrapper: init" + this);
this.mAMap = map;
sAMap = map;
this.mMapView = mapView;
mUIcontroller = controller;
// 设置实现自定义 info window
MapAutoApi.INSTANCE.setInfoWindowAdapter(new AMapInfoWindowAdapter());
AMapUIController.getInstance().initClient(mUIcontroller);
}
public static MapAutoViewHelper getAMap() {
return sAMap;
}
@Override
public IMogoUiSettings getUiSettings() {
if (!checkAMap()) {
return null;
}
if (mUiSettings == null) {
mUiSettings = new AMapUiSettingsWrapper(mAMap);
}
return mUiSettings;
}
@Override
public IMogoMapUIController getUIController() {
return mUIcontroller;
}
@Override
public IMogoMarker addMarker(String tag, MogoMarkerOptions options) {
//CallerLogger.INSTANCE.i(TAG, "autoop-addMarker: " + tag + ",MogoMarkerOptions:" + options + ",AMap:" + (mAMap != null) + ",this:" + this);
if (!checkAMap()) {
return null;
}
MarkerOptions markerOptions = ObjectUtils.fromMogo(options);
if (markerOptions == null) {
CallerLogger.INSTANCE.e(TAG, "marker参数为空");
return null;
}
final IMogoMarker mogoMarker = new AMapMarkerWrapper(mAMap.addMarker(markerOptions), options);
if (options.isAutoManager()) {
MogoMarkersHandler.getInstance().add(tag, mogoMarker);
}
return mogoMarker;
}
@Override
public void updateBatchMarkerPosition(ArrayList<MessagePad.TrackedObject> optionsArrayList) {
if (!checkAMap()) {
return;
}
ArrayList<MarkerSimpleData> markerOptionsArrayList = new ArrayList<>();
for (MessagePad.TrackedObject mogoMarkerOptions : optionsArrayList) {
MarkerSimpleData markerOptions = ObjectUtils.fromTrafficData(mogoMarkerOptions);
if (markerOptions == null) {
CallerLogger.INSTANCE.e(TAG, "marker参数为空");
break;
}
markerOptionsArrayList.add(markerOptions);
}
MarkerHelper.INSTANCE.updateBatchMarkerPositon(markerOptionsArrayList, false, 8.0f, 0, 100);
}
@Override
public String addPreVehicleModel(int type, int modelRes) {
try {
return MarkerHelper.INSTANCE.addPreVehicleModel(type, modelRes);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
@Override
public void removeMarker(String uuidString) {
try {
MarkerHelper.INSTANCE.removeMarker(uuidString);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public ArrayList<IMogoMarker> addMarkers(String tag, ArrayList<MogoMarkerOptions> options, boolean moveToCenter) {
if (!checkAMap()) {
return null;
}
if (options == null || options.isEmpty()) {
return null;
}
ArrayList<Marker> markers = new ArrayList<>();
ArrayList<MarkerOptions> markerOptions = new ArrayList<>();
ArrayList<IMogoMarker> mogoMarkers = new ArrayList<>();
for (MogoMarkerOptions option : options) {
if (option == null) {
continue;
}
MarkerOptions mo = ObjectUtils.fromMogo(option);
if (mo == null) {
continue;
}
markerOptions.add(mo);
}
if (markerOptions.isEmpty()) {
return null;
}
MultiPointOverlayOptions multiPointOverlayOptions = new MultiPointOverlayOptions();
multiPointOverlayOptions.setData(markerOptions);
multiPointOverlayOptions.setMarkerIcon(R.drawable.marker_blue);
List<MarkerOptions> data = mAMap.addMarkers(multiPointOverlayOptions).getOptions().getData();
for (int i = 0; i < data.size(); i++) {
markers.add(new Marker(data.get(i)));
}
if (markers == null || markers.isEmpty()) {
return null;
}
for (int i = 0; i < markers.size(); i++) {
Marker marker = markers.get(i);
if (marker == null) {
continue;
}
mogoMarkers.add(new AMapMarkerWrapper(marker, options.get(i)));
}
MogoMarkersHandler.getInstance().add(tag, mogoMarkers);
return mogoMarkers;
}
@Override
public void clear() {
if (checkAMap()) {
mAMap.clearPanel();
}
}
@Override
public void clear(boolean isKeepMyLocationOverlay) {
if (checkAMap()) {
mAMap.clearPanel();
}
}
@Override
public void setPointToCenter(int x, int y) {
if (checkAMap()) {
LonLatPoint lonLatPoint = MapTools.INSTANCE.fromScreenLocation(new Point(x, y));
mAMap.setCenter(lonLatPoint);
}
}
@Override
public void setTouchPoiEnable(boolean touchPoiEnable) {
if (checkAMap()) {
mAMap.setTouchPoiEnable(touchPoiEnable);
}
}
@Override
public void setTrafficEnable(boolean enable) {
if (checkAMap()) {
mAMap.setTraffic(enable);
}
}
@Override
public void showBuildings(boolean enabled) {
if (checkAMap()) {
mAMap.showBuildings(enabled);
}
}
@Override
public void showIndoorMap(boolean enable) {
if (checkAMap()) {
// mAMap.showIndoorMap( enable );
}
}
@Override
public void showMapText(boolean enable) {
if (checkAMap()) {
mAMap.showMapText(enable);
}
}
@Override
public void stopAnimation() {
if (checkAMap()) {
// mAMap.stopAnimation();
}
}
@Override
public float getScalePerPixel() {
if (checkAMap()) {
return mAMap.getScalePerPixel();
}
return 0;
}
@Override
public void changeZoom(float zoom) {
CallerLogger.INSTANCE.d(TAG, "changeZoom : " + zoom);
if (checkAMap()) {
mAMap.setZoom((int) zoom);
}
}
@Override
public float getZoomLevel() {
if (checkAMap()) {
try {
return mAMap.getZoom();
} catch (Exception e) {
}
}
return 0;
}
@Override
public IMogoPolyline addPolyline(MogoPolylineOptions options) {
if (checkAMap()) {
PolylineOptions polylineOptions = ObjectUtils.fromMogo(options);
CallerLogger.INSTANCE.d(TAG, "addPolyline :" + polylineOptions.toString());
if (polylineOptions == null) {
return null;
}
Polyline polyline = null;
if (polylineOptions.getLineWidth() > 0) {
polyline = mAMap.drawThickLine(polylineOptions);
} else {
polyline = mAMap.drawLine(polylineOptions);
}
return new AMapPolylineWrapper(polyline, options);
}
return null;
}
@Override
public String getMapVersion() {
return MapAutoApi.INSTANCE.getSDKVersion();
}
private boolean checkAMap() {
mAMap = mMapView.getMapAutoViewHelper();
sAMap = mAMap;
if (mAMap == null) {
CallerLogger.INSTANCE.e(TAG, "自研map实例为空请检查");
return false;
}
return true;
}
@Override
public float getRoadWidth(double lon, double lat, float angle, boolean isGpsLocation, boolean isRTK) {
SinglePointRoadInfo singlePointRoadInfo = MapDataApi.INSTANCE.getSinglePointMatchRoad(lon, lat, angle, isGpsLocation, isRTK);
return singlePointRoadInfo != null ? singlePointRoadInfo.getLaneWidth() : 0;
}
private Context getContext() {
return mMapView.getContext();
}
}

View File

@@ -1,92 +0,0 @@
package com.mogo.map.impl.custom;
import android.content.Context;
import com.alibaba.android.arouter.facade.annotation.Route;
import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger;
import com.mogo.map.IMogoMapApiBuilder;
import com.mogo.map.IMogoMapView;
import com.mogo.map.MapApiPath;
import com.mogo.map.impl.custom.location.ALocationClient;
import com.mogo.map.impl.custom.search.GeocodeSearchClient;
import com.mogo.map.impl.custom.search.PoiSearchClient;
import com.mogo.map.impl.custom.uicontroller.AMapUIController;
import com.mogo.map.location.IMogoLocationClient;
import com.mogo.map.search.geo.IMogoGeoSearch;
import com.mogo.map.search.poisearch.IMogoPoiSearch;
import com.mogo.map.search.poisearch.query.MogoPoiSearchQuery;
import com.mogo.map.search.traffic.IMogoTrafficSearch;
import com.mogo.map.uicontroller.IMogoMapUIController;
import com.zhidaoauto.map.sdk.open.MapAutoApi;
import com.zhidaoauto.map.sdk.open.MapParams;
import com.zhidaoauto.map.sdk.open.view.MapAutoView;
/**
* @author congtaowang
* @since 2020/12/9
* <p>
* 描述
*/
@Route(path = MapApiPath.PATH)
public class CustomMapApiBuilder implements IMogoMapApiBuilder {
private static final String TAG = "CustomMapApiBuilder";
@Override
public IMogoGeoSearch getGeoSearch(Context context) {
return new GeocodeSearchClient(context);
}
@Override
public IMogoLocationClient getLocationClient(Context context) {
return new ALocationClient(context);
}
@Override
public IMogoMapUIController getMapUIController() {
return AMapUIController.getInstance();
}
@Override
public IMogoPoiSearch getPoiSearchClient(Context context, MogoPoiSearchQuery query) {
return new PoiSearchClient(context, query);
}
@Override
public IMogoMapView getMapView(Context context) {
CallerLogger.INSTANCE.d(TAG, "setDebugMode==true");
MapParams mapParams = MapParams.Companion.init();
mapParams.setDebugMode(false)
//todo 1-使用本地地图数据0-使用在线地图数据
//.setDataFileSource(1)
.setCoordinateType(MapParams.COORDINATETYPE_GCJ02)
.setPerspectiveMode(MapParams.MAP_PERSPECTIVE_3D)
// .setZoom( 20 )
// .setPointToCenter( 0.734375f, 0.5f )
//todo 2D模式下需要注意ADAS部分遮挡
.setPointToCenter(0.5f, 0.5f)
.setStyleMode(MapParams.MAP_STYLE_VR);
MapAutoApi.INSTANCE.init(context, mapParams);
MapAutoView mapAutoView = new MapAutoView(context);
//mapAutoView.registerRenderListener(l -> CallerLogger.INSTANCE.i(TAG, "renderTime: " + l));
IMogoMapView mapView = new AMapViewWrapper(mapAutoView);
return mapView;
}
@Override
public IMogoTrafficSearch getTrafficSearch() {
return null;
}
@Override
public void destroy() {
}
@Override
public void init(Context context) {
CallerLogger.INSTANCE.d(TAG, "init");
}
}

View File

@@ -1,187 +0,0 @@
package com.mogo.map.impl.custom;
import com.mogo.commons.debug.DebugConfig;
import com.zhidaoauto.map.sdk.open.location.MogoLocation;
import java.util.ArrayList;
import java.util.List;
public
/**
* @author congtaowang
* @since 2020/12/25
*
* 地图样式控制
*/
class MapStyleController {
private static volatile MapStyleController sInstance;
private boolean mIsInVrMode = false;
private List< VrAreaFilter > mVrAreaFilters = new ArrayList<>();
private MapStyleController() {
mVrAreaFilters.add( new ShunYiArea() );
mVrAreaFilters.add( new OCHArea() );
// mVrAreaFilters.add( new HuiXinXiJieArea() );
}
public static MapStyleController getInstance() {
if ( sInstance == null ) {
synchronized ( MapStyleController.class ) {
if ( sInstance == null ) {
sInstance = new MapStyleController();
}
}
}
return sInstance;
}
public synchronized void release() {
sInstance = null;
}
private Object readResolve() {
// 阻止反序列化,必须实现 Serializable 接口
return sInstance;
}
public void onLocationChanged( MogoLocation location, IMapStyleAutoChangedListener listener ) {
if ( location == null ) {
return;
}
// 网约车不自动切换vr、2d模式
if ( DebugConfig.isOCHModule() ) {
return;
}
boolean isInVrMode = false;
for ( VrAreaFilter vrAreaFilter : mVrAreaFilters ) {
if ( vrAreaFilter == null ) {
continue;
}
isInVrMode |= vrAreaFilter.isVrArea( location );
if ( isInVrMode ) {
break;
}
}
if ( isInVrMode ) {
if ( !mIsInVrMode ) {
// 第一次进入 vr 区域,自动变为 vr 模式
mIsInVrMode = true;
if ( listener != null ) {
listener.onStyleAutoChanged( true );
}
}
} else {
if ( mIsInVrMode ) {
// 驶出 vr 区域,自动变为 2d 模式
mIsInVrMode = false;
if ( listener != null ) {
listener.onStyleAutoChanged( false );
}
}
}
}
public interface IMapStyleAutoChangedListener {
void onStyleAutoChanged( boolean isVrMode );
}
public interface VrAreaFilter {
default boolean isVrArea( MogoLocation location ) {
if ( location == null ) {
return false;
}
return location.getLat() > getLeftBottomLat() && location.getLon() > getLeftBottomLon()
&& location.getLat() < getRightTopLat() && location.getLon() < getRightTopLon();
}
double getLeftBottomLat();
double getLeftBottomLon();
double getRightTopLat();
double getRightTopLon();
}
public static class ShunYiArea implements VrAreaFilter {
// 顺义一期高精地图范围(目前圈定了一个矩形区域,认为都是高精地图区域)
private final double leftBottomLat = 40.18728;
private final double leftBottomLon = 116.71194;
private final double rightTopLat = 40.20671;
private final double rightTopLon = 116.74804;
@Override
public double getLeftBottomLat() {
return leftBottomLat;
}
@Override
public double getLeftBottomLon() {
return leftBottomLon;
}
@Override
public double getRightTopLat() {
return rightTopLat;
}
@Override
public double getRightTopLon() {
return rightTopLon;
}
}
public static class OCHArea implements VrAreaFilter {
@Override
public double getLeftBottomLat() {
return 39.97645;
}
@Override
public double getLeftBottomLon() {
return 116.41673;
}
@Override
public double getRightTopLat() {
return 0;
}
@Override
public double getRightTopLon() {
return 0;
}
}
public static class HuiXinXiJieArea implements VrAreaFilter {
@Override
public double getLeftBottomLat() {
return 39.96741320378243;
}
@Override
public double getLeftBottomLon() {
return 116.41045709250723;
}
@Override
public double getRightTopLat() {
return 39.98232698552779;
}
@Override
public double getRightTopLon() {
return 116.41879656379113;
}
}
}

View File

@@ -1,87 +0,0 @@
package com.mogo.map.impl.custom;
import com.zhidaoauto.map.sdk.open.query.LonLatPoint;
import java.util.List;
/**
* 道路数据缓存
*
* @author tongchenfei
*/
public class RoadCacheWrapper {
private List<LonLatPoint> road;
private double lastDistanceDiff;
private int roadLength = -1;
private float laneWidth = -1;
public RoadCacheWrapper(List<LonLatPoint> road) {
setRoad(road);
}
public List<LonLatPoint> getRoad() {
return road;
}
public void setRoad(List<LonLatPoint> road) {
this.road = road;
if(road!=null) {
roadLength = road.size();
}
}
public double getLastDistanceDiff() {
return lastDistanceDiff;
}
public void setLastDistanceDiff(double lastDistanceDiff) {
this.lastDistanceDiff = lastDistanceDiff;
}
public double getLastLat(){
if (roadLength != -1) {
return road.get(roadLength - 1).getLatitude();
}
return 0;
}
public double getLastLon(){
if (roadLength != -1) {
return road.get(roadLength - 1).getLongitude();
}
return 0;
}
public float getLaneWidth() {
return laneWidth;
}
public void setLaneWidth(float laneWidth) {
this.laneWidth = laneWidth;
}
public boolean inCache(double lon, double lat) {
if (roadLength > 0) {
LonLatPoint start = road.get(0);
LonLatPoint end = road.get(roadLength - 1);
boolean latInRoad = false;
boolean lonInRoad = false;
if (start.getLatitude() > end.getLatitude()) {
latInRoad = lat <= start.getLatitude() && lat >= end.getLatitude();
}else{
latInRoad = lat >= start.getLatitude() && lat <= end.getLatitude();
}
if (start.getLongitude() > end.getLongitude()) {
lonInRoad = lon <= start.getLongitude() && lon >= end.getLongitude();
}else{
lonInRoad = lon >= start.getLongitude() && lon <= end.getLongitude();
}
return latInRoad && lonInRoad;
}
return false;
}
}

View File

@@ -1,153 +0,0 @@
package com.mogo.map.impl.custom.location;
import android.content.Context;
import android.os.Trace;
import com.mogo.eagle.core.function.call.map.CallerMapLocationListenerManager;
import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger;
import com.mogo.eagle.core.utilcode.util.UiThreadHandler;
import com.mogo.map.impl.custom.utils.ObjectUtils;
import com.mogo.map.location.IMogoLocationClient;
import com.mogo.map.location.IMogoLocationListener;
import com.mogo.eagle.core.data.map.MogoLocation;
import com.mogo.map.location.MogoLocationListenerRegister;
import com.zhidaoauto.map.sdk.open.location.LocationClient;
import com.zhidaoauto.map.sdk.open.location.LocationListener;
import com.zhidaoauto.map.sdk.open.location.RTKAutopilotLocationBean;
import org.jetbrains.annotations.NotNull;
import java.util.Iterator;
import java.util.Set;
/**
* @author congtaowang
* @since 2019-12-19
* <p>
* 自研定位
*/
public class ALocationClient implements IMogoLocationClient {
private static final String TAG = "ALocationClient";
private MogoLocation mLastLocation;
private final LocationListener mListener = new InternalLocationListener();
private boolean mIsDestroyed = false;
public ALocationClient( Context context ) {
mClient = new LocationClient( context );
mClient.registerListener( mListener );
mLastLocation = ObjectUtils.fromLocation( mClient.getLastKnownMogoLocation() );
if ( mLastLocation == null ) {
mLastLocation = new MogoLocation();
}
}
private LocationClient mClient;
@Override
public void start() {
start( 2_000L );
}
@Override
public void start( long interval ) {
if ( mIsDestroyed ) {
destroyWarming();
return;
}
if ( mClient != null ) {
mClient.start();
}
}
@Override
public void stop() {
if ( mIsDestroyed ) {
destroyWarming();
return;
}
if ( mClient != null && mClient.isAGpsStarted() ) {
mClient.stop();
}
}
@Override
public void addLocationListener( IMogoLocationListener listener ) {
// do not impl.
}
@Override
public void removeLocationListener( IMogoLocationListener listener ) {
// do not impl.
}
@Override
public MogoLocation getLastKnowLocation() {
if ( mIsDestroyed ) {
destroyWarming();
return null;
}
return mLastLocation;
}
@Override
public synchronized void destroy() {
mIsDestroyed = true;
if ( mClient != null ) {
mClient.unRegisterListener( mListener );
mClient.destory();
}
mClient = null;
mLastLocation = null;
}
private class InternalLocationListener implements LocationListener {
@Override
public void onLocationChanged( @NotNull com.zhidaoauto.map.sdk.open.location.MogoLocation location ) {
if ( mIsDestroyed ) {
destroyWarming();
return;
}
if ( location == null ||
location.getLat() == 0.0D ||
location.getLon() == 0.0D ) {
return;
}
Trace.beginSection( "timer.onLocationChanged" );
mLastLocation = ObjectUtils.fromLocation( location );
UiThreadHandler.post(() -> CallerMapLocationListenerManager.INSTANCE.invokeMapLocationChangeListener(mLastLocation));
Set< IMogoLocationListener > listeners = MogoLocationListenerRegister.getInstance().getListeners();
synchronized ( listeners ) {
Iterator< IMogoLocationListener > listenerIterator = listeners.iterator();
while ( listenerIterator.hasNext() ) {
listenerIterator.next().onLocationChanged( mLastLocation.clone() );
}
}
Trace.endSection();
}
}
private void destroyWarming() {
CallerLogger.INSTANCE.w( TAG, "location client has destroyed." );
}
@Override
public void updateLocation(Object locationToUpdate) {
if (locationToUpdate == null) {
return;
}
if (locationToUpdate instanceof MogoLocation) {
return;
}
if (locationToUpdate instanceof RTKAutopilotLocationBean) {
RTKAutopilotLocationBean current = (RTKAutopilotLocationBean) locationToUpdate;
if (mClient != null) {
mClient.updateRTKAutoPilotLocation(current);
}
}
}
}

View File

@@ -1,48 +0,0 @@
package com.mogo.map.impl.custom.marker;
import android.view.View;
import com.mogo.map.impl.custom.AMapMarkerClickHandler;
import com.mogo.map.marker.IMogoInfoWindowAdapter;
import com.mogo.map.marker.IMogoMarker;
import com.zhidaoauto.map.sdk.open.abs.marker.InfoWindowAdapter;
import com.zhidaoauto.map.sdk.open.marker.Marker;
import com.zhidaoauto.map.sdk.open.marker.OnInfoWindowClickListener;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.io.FileInputStream;
/**
* @author congtaowang
* @since 2019-12-24
* <p>
* 自定义infowindow
*/
public final class AMapInfoWindowAdapter implements InfoWindowAdapter, OnInfoWindowClickListener {
public View getInfoWindow( Marker marker ) {
if ( marker.getMObject() instanceof IMogoMarker ) {
IMogoMarker mogoMarker = ( ( IMogoMarker ) marker.getMObject() );
IMogoInfoWindowAdapter delegate = mogoMarker.getInfoWindowAdapter();
if ( delegate != null ) {
final View infoView = delegate.getInfoWindow( mogoMarker );
marker.setOnInfoWindowClickListener( this );
return infoView;
}
}
return null;
}
@Override
public void onInfoWindowClick( @NotNull Marker marker ) {
AMapMarkerClickHandler.getInstance().handleMarkerClicked( marker );
}
@Nullable
@Override
public View getInfoContents( @Nullable Marker marker ) {
return null;
}
}

View File

@@ -1,600 +0,0 @@
package com.mogo.map.impl.custom.marker;
import android.graphics.Bitmap;
import android.graphics.Point;
import android.text.TextUtils;
import android.view.View;
import android.view.animation.Interpolator;
import com.mogo.eagle.core.data.map.MogoLatLng;
import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger;
import com.mogo.map.impl.custom.utils.ObjectUtils;
import com.mogo.map.marker.IMogoInfoWindowAdapter;
import com.mogo.map.marker.IMogoMarker;
import com.mogo.map.marker.IMogoMarkerClickListener;
import com.mogo.map.marker.IMogoMarkerIconViewCreator;
import com.mogo.map.marker.MogoMarkerOptions;
import com.mogo.map.marker.anim.OnMarkerAnimationListener;
import com.zhidaoauto.map.sdk.open.abs.marker.MarkerAnimationListener;
import com.zhidaoauto.map.sdk.open.marker.Animation;
import com.zhidaoauto.map.sdk.open.marker.BitmapDescriptor;
import com.zhidaoauto.map.sdk.open.marker.BitmapDescriptorFactory;
import com.zhidaoauto.map.sdk.open.marker.Marker;
import com.zhidaoauto.map.sdk.open.marker.MarkerOptions;
import com.zhidaoauto.map.sdk.open.marker.MarkerScaleAnimation;
import com.zhidaoauto.map.sdk.open.marker.MarkerTranslateAnimation;
import com.zhidaoauto.map.sdk.open.query.LonLatPoint;
import com.zhidaoauto.map.sdk.open.tools.MapTools;
import org.jetbrains.annotations.NotNull;
import java.util.ArrayList;
import java.util.List;
import java.util.Observable;
import java.util.Observer;
/**
* @author congtaowang
* @since 2019-12-18
* <p>
* 自研marker
*/
public class AMapMarkerWrapper implements IMogoMarker, Observer {
private final String TAG = AMapMarkerWrapper.class.getName();
private Marker mMarker;
private Object mObject;
private IMogoMarkerClickListener mMogoMarkerClickListener;
private IMogoInfoWindowAdapter mMogoInfoWindowAdapter;
private boolean mIsDestroy = false;
private MogoMarkerOptions mMogoMarkerOptions;
private String mOwner;
public AMapMarkerWrapper(Marker marker, MogoMarkerOptions mogoMarkerOptions) {
this.mMarker = marker;
if (marker != null) {
// 设置自研 marker 的object对象为 IMogoMarker 实例。!!!!
marker.setMObject(this);
if (!TextUtils.isEmpty(mogoMarkerOptions.getAnchorColor())) {
marker.setAnchorColor(mogoMarkerOptions.getAnchorColor());
}
MarkerWrapperClickHelper.getInstance().setMogoMarkerMap(marker.getId(), this);
}
setObject(mogoMarkerOptions.getObject());
this.mMogoMarkerOptions = mogoMarkerOptions;
mMogoMarkerOptions.addObserver(this);
}
@Override
public void update(Observable o, Object arg) {
if (isDestroyed()) {
return;
}
setMarkerOptions(mMogoMarkerOptions);
}
@Override
public void destroy() {
if (mMogoMarkerOptions != null) {
mMogoMarkerOptions.deleteObservers();
mMogoMarkerOptions = null;
}
if (mMarker != null) {
mMarker.remove();
mMarker.setMObject(null);
mMarker.setOnInfoWindowClickListener(null);
mMarker = null;
}
mMogoInfoWindowAdapter = null;
mMogoMarkerClickListener = null;
mObject = null;
mIsDestroy = true;
}
@Override
public void remove() {
destroy();
}
@Override
public void hideInfoWindow() {
if (mMarker != null) {
mMarker.hideInfoWindow();
}
}
@Override
public void setAlpha(float alpha) {
if (mMarker != null) {
mMarker.setAlpha(alpha);
}
}
@Override
public void setAnchor(float anchorU, float anchorV) {
if (mMarker != null) {
mMarker.setAnchor(anchorU, anchorV);
}
}
@Override
public void setDraggable(boolean paramBoolean) {
if (mMarker != null) {
mMarker.setDraggable(paramBoolean);
}
}
@Override
public void setIcon(Bitmap icon) {
if (icon == null || icon.isRecycled()) {
return;
}
if (mMarker != null) {
mMarker.setIcon(icon);
}
}
@Override
public void setIcons(ArrayList<Bitmap> icons) {
if (icons == null || icons.isEmpty()) {
return;
}
ArrayList<BitmapDescriptor> descriptors = new ArrayList<>();
for (Bitmap icon : icons) {
if (icon == null || icon.isRecycled()) {
continue;
}
descriptors.add(BitmapDescriptorFactory.INSTANCE.fromBitmap(icon));
}
if (descriptors.isEmpty()) {
return;
}
if (mMarker != null) {
mMarker.setIcons(descriptors);
}
}
@Override
public void setInfoWindowEnable(boolean enabled) {
if (mMarker != null) {
if (enabled) {
mMarker.showInfoWindow();
} else {
mMarker.hideInfoWindow();
}
}
}
@Override
public void setMarkerOptions(MogoMarkerOptions opt) {
final MarkerOptions options = ObjectUtils.fromMogo(opt);
if (options == null) {
return;
}
if (mMarker != null) {
mMarker.setMarkerOptions(options);
setObject(opt.getObject());
}
}
@Override
public void setObject(Object object) {
mObject = object;
}
@Override
public Object getObject() {
return mObject;
}
@Override
public void setPeriod(int period) {
if (mMarker != null) {
mMarker.setPeriod(period);
}
}
@Override
public void setPosition(double lat, double lng) {
if (mMarker != null) {
mMarker.setPosition(new LonLatPoint(lng, lat));
}
}
@Override
public MogoLatLng getPosition() {
if (mMarker != null) {
final LonLatPoint latLng = mMarker.getPosition();
return ObjectUtils.fromAMap(latLng);
}
return null;
}
@Override
public void setRotateAngle(float rotate) {
if (mMarker != null) {
mMarker.setRotateAngle(rotate);
}
}
@Override
public void setSnippet(String snippet) {
if (mMarker != null) {
mMarker.setSnippet(snippet);
}
}
@Override
public void setTitle(String title) {
if (mMarker != null) {
mMarker.setTitle(title);
}
}
@Override
public void setToTop() {
if (mMarker != null) {
mMarker.setToTop();
}
}
@Override
public void setVisible(boolean visible) {
if (mMarker != null) {
mMarker.setVisible(visible);
}
}
@Override
public void setZIndex(int zIndex) {
if (mMarker != null) {
mMarker.setZIndex(zIndex);
}
}
@Override
public void showInfoWindow() {
if (mMarker != null) {
mMarker.showInfoWindow();
}
}
@Override
public String getMarkerAssInfo() {
if (mMarker != null) {
return mMarker.getMarkeOptions().getAssInfo();
}
return null;
}
@Override
public void setOnMarkerClickListener(IMogoMarkerClickListener listener) {
mMogoMarkerClickListener = listener;
}
@Override
public IMogoMarkerClickListener getOnMarkerClickListener() {
return mMogoMarkerClickListener;
}
@Override
public void setInfoWindowAdapter(IMogoInfoWindowAdapter adapter) {
mMogoInfoWindowAdapter = adapter;
}
@Override
public IMogoInfoWindowAdapter getInfoWindowAdapter() {
return mMogoInfoWindowAdapter;
}
@Override
public void setMarkerIconView(IMogoMarkerIconViewCreator creator) {
if (creator != null) {
View iconView = creator.createView(this);
if (iconView != null) {
mMarker.setIcon(iconView);
}
}
}
@Override
public boolean isDestroyed() {
return mIsDestroy;
}
@Override
public void setOwner(String mOwner) {
this.mOwner = mOwner;
}
@Override
public String getOwner() {
if (mOwner != null) {
return mOwner;
}
if (mMogoMarkerOptions != null) {
return mMogoMarkerOptions.getOwner();
}
return null;
}
@Override
public void setPositionByPixels(Point position) {
if (mMarker != null) {
mMarker.setPosition(MapTools.INSTANCE.fromScreenLocation(position));
}
}
public Marker getMarker() {
return mMarker;
}
@Override
public MogoMarkerOptions getMogoMarkerOptions() {
return mMogoMarkerOptions;
}
@Override
public void startScaleAnimation(float fromX, float toX, float fromY, float toY, int duration, Interpolator interpolator) {
if (isDestroyed()) {
return;
}
startScaleAnimation(fromX, toX, fromY, toY, duration, interpolator, null);
}
@Override
public void startScaleAnimation(float fromX, float toX, float fromY, float toY, int duration, Interpolator interpolator, OnMarkerAnimationListener listener) {
if (isDestroyed()) {
return;
}
MarkerScaleAnimation animationScale = new MarkerScaleAnimation(fromX, toX);
animationScale.setDuration(duration);
// animationScale.setFillMode(Animation.FILL_MODE_FORWARDS);
// animationScale.setInterpolator(interpolator);
animationScale.setAnimationListener(new MarkerAnimationListener() {
@Override
public void onAnimationEnd(@NotNull Animation animation) {
if (isDestroyed()) {
return;
}
if (listener != null) {
listener.onAnimEnd();
}
}
@Override
public void onAnimationRepeat(@NotNull Animation animation) {
}
@Override
public void onAnimationStart(@NotNull Animation animation) {
if (isDestroyed()) {
return;
}
if (listener != null) {
listener.onAnimStart();
}
}
});
mMarker.setMarkerScaleAnimation(animationScale);
mMarker.startAnimation();
}
@Override
public void startJumpAnimation(float high, long duration, Interpolator interpolator, OnMarkerAnimationListener listener) {
if (isDestroyed() || high <= 0.0f || interpolator == null || duration < 0) {
return;
}
try {
final LonLatPoint latLng = ObjectUtils.fromMogo(getPosition());
// Point point = AMapWrapper.getAMap().getProjection().toScreenLocation(latLng);
// point.y -= WindowUtils.dip2px(AbsMogoApplication.getApp(), high);
// LatLng target = AMapWrapper.getAMap().getProjection().fromScreenLocation(point);
//使用TranslateAnimation,填写一个需要移动的目标点
MarkerTranslateAnimation animation = new MarkerTranslateAnimation(latLng);
// animation.setInterpolator(interpolator);
animation.setAnimationListener(new MarkerAnimationListener() {
@Override
public void onAnimationEnd(@NotNull Animation animation) {
if (isDestroyed()) {
return;
}
if (listener != null) {
listener.onAnimEnd();
}
}
@Override
public void onAnimationRepeat(@NotNull Animation animation) {
}
@Override
public void onAnimationStart(@NotNull Animation animation) {
if (isDestroyed()) {
return;
}
if (listener != null) {
listener.onAnimStart();
}
}
});
//整个移动所需要的时间
animation.setDuration(duration * 1000);
//设置动画
mMarker.setTranslateAnimation(animation);
mMarker.startAnimation();
} catch (Exception e) {
CallerLogger.INSTANCE.e(TAG, "error : " + e);
}
}
@Override
public void setClickable(boolean clickable) {
if (mMarker != null) {
mMarker.setClickable(clickable);
}
}
@Override
public void startSmooth(List<MogoLatLng> points, int duration) {
startSmoothInMs(points, duration * 1000L);
}
@Override
public void startSmoothInMs(List<MogoLatLng> points, long duration) {
if (isDestroyed()) {
return;
}
if (mMarker == null) {
return;
}
if (points == null || points.isEmpty()) {
return;
}
ArrayList<LonLatPoint> newPoints = new ArrayList<>();
for (int i = 0; i < points.size(); i++) {
LonLatPoint point = ObjectUtils.fromMogo(points.get(i));
if (point == null) {
continue;
}
newPoints.add(point);
}
if (newPoints.isEmpty()) {
return;
}
mMarker.startSmooth(newPoints, (int) duration);
}
@Override
public void startScaleAnimationWithAlpha(float fromX, float toX, float fromY, float toY, float fromAlpha, float toAlpha, int duration, Interpolator interpolator, OnMarkerAnimationListener listener) {
}
@Override
public boolean isInfoWindowShowing() {
return mMarker.isInfoWindowShown();
}
@Override
public void setGps(boolean isGps) {
if (mMarker != null) {
mMarker.setGps(isGps);
}
}
@Override
public String use3DResource(int model3D) {
try {
mMarker.marker3DIcon(model3D);
return mMarker.getMarkeOptions().getMarkerIconName();
} catch (Exception e) {
CallerLogger.INSTANCE.e(TAG, "use3DResource has exception : " + e);
}
return null;
}
@Override
public void use3DResource(String resName) {
try {
mMarker.getMarkeOptions().setVrIcon(true);
mMarker.setMarkerOptions(mMarker.getMarkeOptions().setMarkerIconName(resName));
} catch (Exception e) {
CallerLogger.INSTANCE.e(TAG,"use3DResource has exception : " + e);
}
}
@Override
public void use2DResource(String resName) {
try {
mMarker.getMarkeOptions().setVrIcon(false);
mMarker.setMarkerOptions(mMarker.getMarkeOptions().setMarkerIconName(resName));
} catch (Exception e) {
CallerLogger.INSTANCE.e(TAG, "use3DResource has exception : " + e);
}
}
private String mLastAnchorColor = "";
@Override
public void setAnchorColor(String anchorColor) {
if (TextUtils.equals(mLastAnchorColor, anchorColor)) {
return;
}
if (mMogoMarkerOptions != null) {
mMogoMarkerOptions.anchorColor(anchorColor);
}
if (mMarker != null) {
mMarker.setAnchorColor(anchorColor);
}
mLastAnchorColor = anchorColor;
}
@Override
public void updateInfoWindowView(View view) {
try {
mMarker.setInfoWindowView(view);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void updateInfoWindowView(String viewResName) {
try {
mMarker.setMarkerInfoName(viewResName);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void setInfoWindowOffset(int offsetX, int offsetY) {
try {
mMarker.setInfoWindowOffset(offsetX, offsetY);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void addDynamicAnchorPosition(MogoLatLng latLng, float angle, long duration) {
mMarker.addDynamicAnchorPostion(new LonLatPoint(latLng.lon, latLng.lat, angle), System.currentTimeMillis(), (int) duration);
}
@Override
public String getMarkerResName() {
if (mMarker != null) {
try {
return mMarker.getMarkeOptions().getMarkerIconName();
} catch (Exception e) {
e.printStackTrace();
}
}
return "";
}
@Override
public String getMarkerInfoResName() {
if (mMarker != null) {
try {
return mMarker.getMarkeOptions().getMarkerInfoName();
} catch (Exception e) {
e.printStackTrace();
}
}
return "";
}
}

View File

@@ -1,43 +0,0 @@
package com.mogo.map.impl.custom.marker;
import com.mogo.map.marker.IMogoMarker;
import java.util.HashMap;
import java.util.Map;
public class MarkerWrapperClickHelper {
private volatile static MarkerWrapperClickHelper markerWrapperClickHelper;
private final Map<String, IMogoMarker> mogoMarkerMap = new HashMap<>();
private MarkerWrapperClickHelper(){
}
public void setMogoMarkerMap(String id,IMogoMarker iMogoMarker){
if(isStaticMarker(id)){
return;
}
this.mogoMarkerMap.put(id,iMogoMarker);
}
public Map<String, IMogoMarker> getMogoMarkerMap() {
return mogoMarkerMap;
}
public static MarkerWrapperClickHelper getInstance(){
if (markerWrapperClickHelper == null) {
synchronized (MarkerWrapperClickHelper.class) {
if (markerWrapperClickHelper == null) {
markerWrapperClickHelper = new MarkerWrapperClickHelper();
}
}
}
return markerWrapperClickHelper;
}
public boolean isStaticMarker(String id){
return id.contains("traffic");
}
}

View File

@@ -1,197 +0,0 @@
package com.mogo.map.impl.custom.overlay;
import com.mogo.eagle.core.data.map.MogoLatLng;
import com.mogo.map.impl.custom.utils.ObjectUtils;
import com.mogo.map.overlay.IMogoPolyline;
import com.mogo.map.overlay.MogoPolylineOptions;
import com.zhidaoauto.map.sdk.open.poyline.Polyline;
import com.zhidaoauto.map.sdk.open.poyline.PolylineOptions;
import com.zhidaoauto.map.sdk.open.query.LonLatPoint;
import java.util.ArrayList;
import java.util.List;
/**
* @author congtaowang
* @since 2020-03-10
* <p>
* 描述
*/
public class AMapPolylineWrapper implements IMogoPolyline {
private Polyline mPolyline;
private MogoPolylineOptions mOptions;
private boolean mIsDestroyed = false;
public AMapPolylineWrapper( Polyline mPolyline,
MogoPolylineOptions mOptions ) {
this.mPolyline = mPolyline;
this.mOptions = mOptions;
}
@Override
public void destroy() {
remove();
}
@Override
public void remove() {
if ( mPolyline != null ) {
mPolyline.remove();
}
mIsDestroyed = true;
}
@Override
public String getId() {
if ( mPolyline != null ) {
return mPolyline.getId();
}
return null;
}
@Override
public void setPoints( List< MogoLatLng > lonLats ) {
if ( lonLats == null || lonLats.isEmpty() ) {
mPolyline.setPoints( new ArrayList<LonLatPoint>() );
return;
}
ArrayList< LonLatPoint > points = new ArrayList<>();
for ( MogoLatLng lonLat : lonLats ) {
LonLatPoint latLng = ObjectUtils.fromMogo( lonLat );
if ( latLng == null ) {
continue;
}
points.add( latLng );
}
mPolyline.setPoints( points );
}
@Override
public List< MogoLatLng > getPoints() {
if ( mPolyline == null ) {
return null;
}
ArrayList< MogoLatLng > lonLats = new ArrayList<>();
List< LonLatPoint > points = mPolyline.getPoints();
if ( points != null ) {
for ( LonLatPoint latLng : points ) {
MogoLatLng lonLat = ObjectUtils.fromAMap( latLng );
if ( lonLat == null ) {
continue;
}
lonLats.add( lonLat );
}
}
return lonLats;
}
@Override
public void setGeodesic( boolean draw ) {
if ( mPolyline != null ) {
mPolyline.setGeodesic( draw );
}
}
@Override
public boolean isGeodesic() {
return mPolyline == null ? false : mPolyline.isGeodesic();
}
@Override
public void setDottedLine( boolean dottedLine ) {
if ( mPolyline != null ) {
mPolyline.setDottedLine( dottedLine );
}
}
@Override
public boolean isDottedLine() {
return mPolyline == null ? false : mPolyline.isDottedLine();
}
@Override
public void setWidth( float width ) {
if ( mPolyline != null ) {
mPolyline.setWidth( width );
}
}
@Override
public float getWidth() {
if ( mPolyline != null ) {
return mPolyline.getWidth();
}
return 0;
}
@Override
public void setColor( int color ) {
if ( mPolyline != null ) {
mPolyline.setColor( color );
}
}
@Override
public int getColor() {
if ( mPolyline != null ) {
return mPolyline.getColor();
}
return 0;
}
@Override
public void setZIndex( float zIndex ) {
if ( mPolyline != null ) {
mPolyline.setZIndex( zIndex );
}
}
@Override
public float getZIndex() {
if ( mPolyline != null ) {
return mPolyline.getZIndex();
}
return 0;
}
@Override
public void setVisible( boolean visible ) {
if ( mPolyline != null ) {
mPolyline.setVisible( visible );
}
}
@Override
public boolean isVisible() {
if ( mPolyline != null ) {
return mPolyline.isVisible();
}
return false;
}
@Override
public void setTransparency( float transparency ) {
if ( mPolyline != null ) {
mPolyline.setTransparency( transparency );
}
}
@Override
public void setOption( MogoPolylineOptions option ) {
PolylineOptions target = ObjectUtils.fromMogo( option );
if ( target == null ) {
return;
}
mOptions = option;
if ( mPolyline != null ) {
mPolyline.setOption( target );
}
}
@Override
public boolean isDestroyed() {
return false;
}
}

View File

@@ -1,110 +0,0 @@
package com.mogo.map.impl.custom.search;
import android.content.Context;
import com.mogo.map.exception.MogoMapException;
import com.mogo.map.impl.custom.utils.ObjectUtils;
import com.mogo.map.search.geo.IMogoGeoSearch;
import com.mogo.map.search.geo.IMogoGeoSearchListener;
import com.mogo.map.search.geo.MogoGeocodeAddress;
import com.mogo.map.search.geo.MogoRegeocodeAddress;
import com.mogo.map.search.geo.query.MogoGeocodeQuery;
import com.mogo.map.search.geo.query.MogoRegeocodeQuery;
import com.zhidaoauto.map.sdk.open.exception.MapException;
import com.zhidaoauto.map.sdk.open.query.GeocodeAddress;
import com.zhidaoauto.map.sdk.open.query.GeocodeResult;
import com.zhidaoauto.map.sdk.open.query.GeocodeSearch;
import com.zhidaoauto.map.sdk.open.query.OnGeocodeSearchListener;
import com.zhidaoauto.map.sdk.open.query.RegeocodeAddress;
import com.zhidaoauto.map.sdk.open.query.RegeocodeResult;
import com.zhidaoauto.map.sdk.open.query.RegeocodeQuery;
import java.util.ArrayList;
import java.util.List;
/**
* @author congtaowang
* @since 2019-12-19
* <p>
* 地理编码/逆地理编码自研实现
*/
public class GeocodeSearchClient implements IMogoGeoSearch, OnGeocodeSearchListener {
private GeocodeSearch mClient;
private IMogoGeoSearchListener mListener;
public GeocodeSearchClient( Context context ) {
mClient = new GeocodeSearch( context );
mClient.setOnGeocodeSearchListener( this );
}
@Override
public void setGeoSearchListener( IMogoGeoSearchListener listener ) {
mListener = listener;
}
@Override
public MogoRegeocodeAddress getFromLocation( MogoRegeocodeQuery query ) throws MogoMapException {
try {
RegeocodeQuery regeocodeQuery = ObjectUtils.fromMogo(query);
RegeocodeAddress regeocodeAddress = mClient.getFromLocation(regeocodeQuery);
return ObjectUtils.fromAMap( regeocodeAddress );
} catch ( Exception e ) {
throw new MogoMapException( e );
}
}
@Override
public List< MogoGeocodeAddress > getFromLocationName( MogoGeocodeQuery query ) throws MogoMapException {
try {
List<GeocodeAddress> geocodeAddress = mClient.getFromLocationName( ObjectUtils.fromMogo( query ) );
if ( geocodeAddress != null ) {
List< MogoGeocodeAddress > mogoGeocodeAddresses = new ArrayList<>();
for ( GeocodeAddress address : geocodeAddress ) {
MogoGeocodeAddress mogoGeocodeAddress = ObjectUtils.fromAMap( address );
if ( mogoGeocodeAddress != null ) {
mogoGeocodeAddresses.add( mogoGeocodeAddress );
}
}
return mogoGeocodeAddresses;
}
return new ArrayList<>();
} catch ( Exception e ) {
throw new MogoMapException( e );
}
}
@Override
public void getFromLocationAsyn( MogoRegeocodeQuery query ) {
if ( mClient != null ) {
mClient.getFromLocationAsyn( ObjectUtils.fromMogo( query ) );
}
}
@Override
public void getFromLocationNameAsyn( MogoGeocodeQuery query ) {
if ( mClient != null ) {
mClient.getFromLocationNameAsyn( ObjectUtils.fromMogo( query ) );
}
}
@Override
public void onRegeocodeSearched(RegeocodeResult regeocodeResult, int i ) {
if ( mListener != null ) {
mListener.onRegeocodeSearched( ObjectUtils.fromAMap( regeocodeResult ) );
}
}
@Override
public void onGeocodeSearched(GeocodeResult geocodeResult, int i ) {
if ( mListener != null ) {
mListener.onGeocodeSearched( ObjectUtils.fromAMap( geocodeResult ) );
}
}
@Override
public void destroy() {
mClient = null;
mListener = null;
}
}

View File

@@ -1,87 +0,0 @@
package com.mogo.map.impl.custom.search;
import android.content.Context;
import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger;
import com.mogo.map.impl.custom.utils.ObjectUtils;
import com.mogo.map.search.inputtips.IMogoInputtipsListener;
import com.mogo.map.search.inputtips.IMogoInputtipsSearch;
import com.mogo.map.search.inputtips.MogoTip;
import com.mogo.map.search.inputtips.query.MogoInputtipsQuery;
import com.zhidaoauto.map.sdk.open.query.Inputtips;
import com.zhidaoauto.map.sdk.open.query.InputtipsListener;
import com.zhidaoauto.map.sdk.open.query.InputtipsQuery;
import com.zhidaoauto.map.sdk.open.query.Tip;
import java.util.ArrayList;
import java.util.List;
/**
* @author congtaowang
* @since 2019-12-20
* <p>
* 自研地图 inputtips搜索实现
*/
public class InputtipsSearch implements IMogoInputtipsSearch, InputtipsListener {
private static final String TAG = "InputtipsSearch";
private Inputtips mClient;
private InputtipsQuery mQuery;
private IMogoInputtipsListener mListener;
public InputtipsSearch(Context context, MogoInputtipsQuery query) {
mQuery = ObjectUtils.fromMogo(query);
mClient = new Inputtips(context, mQuery);
mClient.setInputtipsListener(this);
}
@Override
public void setQuery(MogoInputtipsQuery query) {
this.mQuery = ObjectUtils.fromMogo(query);
}
@Override
public void setInputtipsListener(IMogoInputtipsListener listener) {
this.mListener = listener;
}
@Override
public void requestInputtipsAsyn() {
if (mClient != null) {
mClient.requestInputtipsAsyn();
}
}
@Override
public void onGetInputtips(List list, int i) {
if (i == 0) {
if (mListener != null) {
mListener.onGetInputtips(getResult(list));
}
} else {
CallerLogger.INSTANCE.e(TAG, "errorcode = " + i);
}
}
private List<MogoTip> getResult(List<Tip> tips) {
List<MogoTip> mogoTips = new ArrayList<>();
if (tips != null) {
//只添加有坐标的结果
for (Tip tip : tips) {
MogoTip mogoTip = ObjectUtils.fromAMap(tip);
if (mogoTip != null && mogoTip.getPoint() != null) {
mogoTips.add(mogoTip);
}
}
}
return mogoTips;
}
@Override
public void destroy() {
mClient = null;
mListener = null;
mQuery = null;
}
}

View File

@@ -1,142 +0,0 @@
package com.mogo.map.impl.custom.search;
import android.content.Context;
import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger;
import com.mogo.map.exception.MogoMapException;
import com.mogo.map.impl.custom.utils.ObjectUtils;
import com.mogo.map.search.geo.MogoPoiItem;
import com.mogo.map.search.poisearch.IMogoPoiSearch;
import com.mogo.map.search.poisearch.IMogoPoiSearchListener;
import com.mogo.map.search.poisearch.MogoPoiResult;
import com.mogo.map.search.poisearch.MogoSearchBound;
import com.mogo.map.search.poisearch.query.MogoPoiSearchQuery;
import com.zhidaoauto.map.sdk.open.query.OnPoiSearchListener;
import com.zhidaoauto.map.sdk.open.query.PoiItem;
import com.zhidaoauto.map.sdk.open.query.PoiSearch;
import com.zhidaoauto.map.sdk.open.query.PoiSearchResult;
import org.jetbrains.annotations.Nullable;
import java.util.List;
/**
* @author congtaowang
* @since 2019-12-24
* <p>
* poi搜索自研实现
* <p>
* 错误码对照表https://lbs.amap.com/api/android-sdk/guide/map-tools/error-code
*/
public class PoiSearchClient implements IMogoPoiSearch, OnPoiSearchListener {
private static final String TAG = "PoiSearchClient";
private MogoPoiSearchQuery mQuery;
private PoiSearch mClient;
private IMogoPoiSearchListener mListener;
private MogoSearchBound mBound;
public PoiSearchClient(Context context, MogoPoiSearchQuery query) {
try {
mQuery = query;
mClient = new PoiSearch(context, ObjectUtils.fromMogo(mQuery));
mClient.setOnPoiSearchListener(this);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void setPoiSearchListener(IMogoPoiSearchListener listener) {
mListener = listener;
}
@Override
public void searchPOIAsyn() {
if (mClient != null) {
mClient.searchPOIAsyn();
}
}
@Override
public MogoPoiResult searchPOI() throws MogoMapException {
if (mClient != null) {
try {
PoiSearchResult search = mClient.searchPOI();
return ObjectUtils.fromAMap(search);
} catch (Exception e) {
throw new MogoMapException(e);
}
}
return null;
}
@Override
public void setQuery(MogoPoiSearchQuery query) {
mQuery = query;
if (mClient != null) {
mClient.setQuery(ObjectUtils.fromMogo(mQuery));
}
}
@Override
public MogoPoiItem searchPOIId(String poiId) throws MogoMapException {
if (mClient != null) {
try {
PoiItem poiItem = mClient.searchPOIId(poiId);
return ObjectUtils.fromAMap(poiItem);
} catch (Exception e) {
throw new MogoMapException(e);
}
}
return null;
}
@Override
public void searchPOIIdAsyn(String poiId) {
if (mClient != null) {
mClient.searchPOIIdAsyn(poiId);
}
}
@Override
public void setBound(MogoSearchBound bound) {
mBound = bound;
if (mClient != null) {
mClient.setBound(ObjectUtils.fromMogo(mBound));
}
}
@Override
public void onPoiSearched(PoiSearchResult poiResult, int errorCode) {
if (errorCode != 0) {
CallerLogger.INSTANCE.e(TAG, "errorCode is " + errorCode);
}
if (mListener != null) {
mListener.onPoiSearched(ObjectUtils.fromAMap(poiResult), errorCode);
}
}
@Override
public void onPoiItemSearched(PoiItem poiItem, int errorCode) {
if (errorCode != 0) {
CallerLogger.INSTANCE.e(TAG, "errorCode is " + errorCode);
}
if (mListener != null) {
mListener.onPoiItemSearched(ObjectUtils.fromAMap(poiItem), errorCode);
}
}
@Override
public void destroy() {
mQuery = null;
mClient = null;
mListener = null;
mBound = null;
}
@Override
public void onPoiCategorySearched(@Nullable List list, int errorCode) {
}
}

View File

@@ -1,392 +0,0 @@
package com.mogo.map.impl.custom.uicontroller;
import android.graphics.Point;
import android.graphics.Rect;
import android.location.Location;
import android.view.View;
import com.mogo.eagle.core.data.map.MogoLatLng;
import com.mogo.map.uicontroller.CarCursorOption;
import com.mogo.map.uicontroller.EnumMapUI;
import com.mogo.map.uicontroller.IMogoMapUIController;
import com.mogo.map.uicontroller.MapCameraPosition;
import com.mogo.map.uicontroller.MapControlResult;
import com.mogo.map.uicontroller.VisualAngleMode;
import com.zhidaoauto.map.sdk.open.MapAutoApi;
import org.json.JSONObject;
import java.util.List;
import mogo.telematics.pad.MessagePad;
/**
* @author congtaowang
* @since 2019-12-26
* <p>
* 描述
*/
public class AMapUIController implements IMogoMapUIController {
private static final String TAG = "AMapUIController";
private static volatile AMapUIController sInstance;
private IMogoMapUIController mClient;
private AMapUIController() {
}
public static AMapUIController getInstance() {
if (sInstance == null) {
synchronized (AMapUIController.class) {
if (sInstance == null) {
sInstance = new AMapUIController();
}
}
}
return sInstance;
}
public void initClient(IMogoMapUIController client) {
this.mClient = client;
}
public synchronized void release() {
sInstance = null;
}
@Override
public void setTrafficEnabled(boolean visible) {
if (mClient != null) {
mClient.setTrafficEnabled(visible);
}
}
@Override
public MapControlResult changeZoom(boolean zoom) {
if (mClient != null) {
return mClient.changeZoom(zoom);
}
return MapControlResult.ERROR;
}
@Override
public MapControlResult changeZoom(float zoom) {
if (mClient != null) {
return mClient.changeZoom(zoom);
}
return MapControlResult.ERROR;
}
@Override
public void changeMapMode(EnumMapUI mode) {
if (mClient != null) {
mClient.changeMapMode(mode);
}
}
@Override
public void changeMapVisualAngle(VisualAngleMode angelMode, MogoLatLng mogoLatLng) {
if (mClient != null) {
mClient.changeMapVisualAngle(angelMode, mogoLatLng);
}
}
@Override
public VisualAngleMode getCurrentMapVisualAngle() {
if (mClient != null) {
return mClient.getCurrentMapVisualAngle();
}
return null;
}
@Override
public void moveToCenter(MogoLatLng latLng, boolean animate) {
if (mClient != null) {
mClient.moveToCenter(latLng, animate);
}
}
@Override
public void showMyLocation(boolean visible) {
if (mClient != null) {
mClient.showMyLocation(visible);
}
}
@Override
public void showMyLocation(View view) {
if (mClient != null) {
mClient.showMyLocation(view);
}
}
@Override
public void recoverLockMode() {
if (mClient != null) {
mClient.recoverLockMode();
}
}
@Override
public void loseLockMode() {
if (mClient != null) {
mClient.loseLockMode();
}
}
@Override
public void setLockZoom(int var1) {
if (mClient != null) {
mClient.setLockZoom(var1);
}
}
@Override
public void displayOverview(Rect bounds) {
if (mClient != null) {
mClient.displayOverview(bounds);
}
}
@Override
public float getScalePerPixel() {
if (mClient != null) {
return mClient.getScalePerPixel();
}
return 0;
}
@Override
public float getZoomLevel() {
if (mClient != null) {
return mClient.getZoomLevel();
}
return 0;
}
@Override
public float getRoadWidth(double lon, double lat, float angle, boolean isGpsLocation, boolean isRTK) {
if (mClient != null) {
return mClient.getRoadWidth(lon, lat, angle, isGpsLocation, isRTK);
}
return 0;
}
@Override
public MogoLatLng getCameraNorthEastPosition() {
if (mClient != null) {
return mClient.getCameraNorthEastPosition();
}
return null;
}
@Override
public MogoLatLng getCameraSouthWestPosition() {
if (mClient != null) {
return mClient.getCameraSouthWestPosition();
}
return null;
}
@Override
public MogoLatLng getWindowCenterLocation() {
if (mClient != null) {
return mClient.getWindowCenterLocation();
}
return null;
}
@Override
public void setPointToCenter(double mapCenterX, double mapCenterY) {
if (mClient != null) {
mClient.setPointToCenter(mapCenterX, mapCenterY);
}
}
@Override
public Point getLocationPointInScreen(MogoLatLng latLng) {
if (mClient != null) {
return mClient.getLocationPointInScreen(latLng);
}
return null;
}
@Override
public MogoLatLng getLocationMogoLatLngInScreen(Point point) {
if (mClient != null) {
return mClient.getLocationMogoLatLngInScreen(point);
}
return null;
}
@Override
public void setRenderFps(int fps) {
if (mClient != null) {
mClient.setRenderFps(fps);
}
}
@Override
public void showBounds(String tag, MogoLatLng carPosition, List<MogoLatLng> lonLats, Rect bound, boolean lockCarPosition) {
if (mClient != null) {
mClient.showBounds(tag, carPosition, lonLats, bound, lockCarPosition);
}
}
@Override
public void forceRender() {
if (mClient != null) {
mClient.forceRender();
}
}
@Override
public float calculateLineDistance(MogoLatLng p1, MogoLatLng p2) throws Exception {
if (mClient != null) {
return mClient.calculateLineDistance(p1, p2);
}
return 0;
}
@Override
public EnumMapUI getCurrentUiMode() {
if (mClient != null) {
return mClient.getCurrentUiMode();
}
return null;
}
@Override
public void changeMyLocation(Location location) {
if (mClient != null) {
mClient.changeMyLocation(location);
}
}
@Override
public boolean isCarLocked() {
if (mClient != null) {
return mClient.isCarLocked();
}
return false;
}
@Override
public void setCarCursorOption(CarCursorOption option) {
if (mClient != null) {
mClient.setCarCursorOption(option);
}
}
@Override
public MapCameraPosition getMapCameraPosition() {
if (mClient != null) {
return mClient.getMapCameraPosition();
}
return null;
}
@Override
public void changeBearing(float bearing) {
if (mClient != null) {
mClient.changeBearing(bearing);
}
}
@Override
public void changeMapViewAngle(int type) {
if (mClient != null) {
mClient.changeMapViewAngle(type);
}
}
@Override
public void changeCurrentIcon(int iconId) {
if (mClient != null) {
mClient.changeCurrentIcon(iconId);
}
}
@Override
public long getTileId(double lon, double lat) {
return MapAutoApi.INSTANCE.getTileID(lon, lat, 13); // 13为默认获取瓦片层级级别
}
@Override
public int getSpeedLimmit(double lon, double lat, float angle) {
return mClient.getSpeedLimmit(lon,lat,angle);
}
@Override
public void emphasizeMyLocation() {
}
@Override
public void rtkEnable(boolean enable) {
if (mClient != null) {
mClient.rtkEnable(enable);
}
}
@Override
public void syncLocation2Map(JSONObject data) {
if (mClient != null) {
mClient.syncLocation2Map(data);
}
}
@Override
public void syncLocation2Map(MessagePad.GnssInfo gnssInfo) {
if (mClient != null) {
mClient.syncLocation2Map(gnssInfo);
}
}
@Override
public void openVrMode(boolean zoomGestureEnable) {
if (mClient != null) {
mClient.openVrMode(zoomGestureEnable);
}
}
@Override
public double[] matchRoad(String id, double lon, double lat, double angle, boolean isGpsLocation, boolean isRTK) {
if (mClient != null) {
return mClient.matchRoad(id, lon, lat, angle, isGpsLocation, isRTK);
}
return null;
}
@Override
public String getMarkerInfoResName(String speedVal) {
if (mClient != null) {
return mClient.getMarkerInfoResName(speedVal);
}
return null;
}
@Override
public void setMarkerInfoResName(String speedVal, String val) {
if (mClient != null) {
mClient.setMarkerInfoResName(speedVal, val);
}
}
@Override
public void clearRoadCacheById(String id) {
if (mClient != null) {
mClient.clearRoadCacheById(id);
}
}
@Override
public void setMapDAngle(float angle) {
if (mClient != null) {
mClient.setMapDAngle(angle);
}
}
}

View File

@@ -1,135 +0,0 @@
package com.mogo.map.impl.custom.utils;
import com.mogo.eagle.core.data.map.MogoLatLng;
import com.mogo.map.exception.MogoMapException;
import com.zhidaoauto.map.sdk.open.camera.LatLngBounds;
import com.zhidaoauto.map.sdk.open.query.LonLatPoint;
import java.util.List;
/**
* @author congtaowang
* @since 2020-03-04
* <p>
* 地图工具类
*/
public class MogoMapUtils {
private static final String TAG = "MogoMapUtils";
public static LatLngBounds getLatLngBounds(MogoLatLng carPosition, List< MogoLatLng > lonLats, boolean lockCarPosition ) throws Exception {
if ( lonLats == null || lonLats.isEmpty() ) {
throw new MogoMapException( "经纬度不能为null或空集合" );
}
LatLngBounds.Builder builder = new LatLngBounds.Builder();
for ( MogoLatLng lonLat : lonLats ) {
builder.include( ObjectUtils.fromMogo( lonLat ) );
}
if ( carPosition != null && !lockCarPosition ) {
builder.include( ObjectUtils.fromMogo( carPosition ) );
}
LatLngBounds latLngBounds = builder.build();
if ( !lockCarPosition ) {
return latLngBounds;
}
if ( carPosition == null ) {
throw new MogoMapException( "自车位置经纬度信息不能为空" );
}
if ( latLngBounds.getNortheast() == null && latLngBounds.getSouthwest() == null ) {
return null;
}
double south = 0.0;
double west = 0.0;
double east = 0.0;
double north = 0.0;
double dLat = 0.0;
double dLon = 0.0;
if ( latLngBounds.getNortheast() == null ) {
dLat = Math.abs( carPosition.lat - latLngBounds.getSouthwest().getLatitude() );
dLon = Math.abs( carPosition.lon - latLngBounds.getSouthwest().getLongitude() );
} else if ( latLngBounds.getSouthwest() == null ) {
dLat = Math.abs( carPosition.lat - latLngBounds.getNortheast().getLatitude() );
dLon = Math.abs( carPosition.lon - latLngBounds.getNortheast().getLongitude() );
} else {
final double dLat1 = Math.abs( carPosition.lat - latLngBounds.getSouthwest().getLatitude() );
final double dLon1 = Math.abs( carPosition.lon - latLngBounds.getSouthwest().getLongitude() );
final double dLat2 = Math.abs( carPosition.lat - latLngBounds.getNortheast().getLatitude() );
final double dLon2 = Math.abs( carPosition.lon - latLngBounds.getNortheast().getLongitude() );
dLat = dLat1 > dLat2 ? dLat1 : dLat2;
dLon = dLon1 > dLon2 ? dLon1 : dLon2;
}
west = carPosition.lat - dLat;
south = carPosition.lon + dLon;
east = carPosition.lat + dLat;
north = carPosition.lon - dLon;
if ( south == 0.0 || west == 0.0 || east == 0.0 || north == 0.0 ) {
return null;
}
if ( east < west ) {
double tmp = east;
east = west;
west = tmp;
}
if( north < south ){
double tmp = north;
north = south;
south = tmp;
}
return new LatLngBounds.Builder().include( new LonLatPoint( east, north ) ).include( new LonLatPoint( west, south ) ).build();
}
public static float calculateLineDistance(LonLatPoint var0, LonLatPoint var1) {
if (var0 != null && var1 != null) {
try {
double var2 = var0.getLongitude();
double var4 = var0.getLatitude();
double var6 = var1.getLongitude();
double var8 = var1.getLatitude();
var2 *= 0.01745329251994329D;
var4 *= 0.01745329251994329D;
var6 *= 0.01745329251994329D;
var8 *= 0.01745329251994329D;
double var10 = Math.sin(var2);
double var12 = Math.sin(var4);
double var14 = Math.cos(var2);
double var16 = Math.cos(var4);
double var18 = Math.sin(var6);
double var20 = Math.sin(var8);
double var22 = Math.cos(var6);
double var24 = Math.cos(var8);
double[] var28 = new double[3];
double[] var29 = new double[3];
var28[0] = var16 * var14;
var28[1] = var16 * var10;
var28[2] = var12;
var29[0] = var24 * var22;
var29[1] = var24 * var18;
var29[2] = var20;
return (float)(Math.asin(Math.sqrt((var28[0] - var29[0]) * (var28[0] - var29[0]) + (var28[1] - var29[1]) * (var28[1] - var29[1]) + (var28[2] - var29[2]) * (var28[2] - var29[2])) / 2.0D) * 1.27420015798544E7D);
} catch (Throwable var26) {
var26.printStackTrace();
return 0.0F;
}
} else {
try {
throw new Exception("非法坐标值");
} catch (Exception var27) {
var27.printStackTrace();
return 0.0F;
}
}
}
}

View File

@@ -1,707 +0,0 @@
package com.mogo.map.impl.custom.utils;
import android.graphics.Bitmap;
import android.graphics.Color;
import android.text.TextUtils;
import android.view.View;
import com.mogo.eagle.core.data.map.MogoLatLng;
import com.mogo.eagle.core.data.map.MogoLocation;
import com.mogo.eagle.core.data.traffic.TrafficData;
import com.mogo.map.marker.MogoMarkerOptions;
import com.mogo.map.overlay.MogoPolylineOptions;
import com.mogo.map.search.geo.MogoGeocodeAddress;
import com.mogo.map.search.geo.MogoGeocodeResult;
import com.mogo.map.search.geo.MogoPoiItem;
import com.mogo.map.search.geo.MogoRegeocodeAddress;
import com.mogo.map.search.geo.MogoRegeocodeResult;
import com.mogo.map.search.geo.query.MogoGeocodeQuery;
import com.mogo.map.search.geo.query.MogoRegeocodeQuery;
import com.mogo.map.search.inputtips.MogoTip;
import com.mogo.map.search.inputtips.query.MogoInputtipsQuery;
import com.mogo.map.search.poisearch.MogoPoiResult;
import com.mogo.map.search.poisearch.MogoSearchBound;
import com.mogo.map.search.poisearch.query.MogoPoiSearchQuery;
import com.mogo.map.uicontroller.MapCameraPosition;
import com.zhidaoauto.map.sdk.open.camera.CameraPosition;
import com.zhidaoauto.map.sdk.open.marker.BitmapDescriptor;
import com.zhidaoauto.map.sdk.open.marker.BitmapDescriptorFactory;
import com.zhidaoauto.map.sdk.open.marker.MarkerOptions;
import com.zhidaoauto.map.sdk.open.marker.MarkerSimpleData;
import com.zhidaoauto.map.sdk.open.poyline.PolylineOptions;
import com.zhidaoauto.map.sdk.open.query.GeocodeAddress;
import com.zhidaoauto.map.sdk.open.query.GeocodeQuery;
import com.zhidaoauto.map.sdk.open.query.GeocodeResult;
import com.zhidaoauto.map.sdk.open.query.InputtipsQuery;
import com.zhidaoauto.map.sdk.open.query.LonLatPoint;
import com.zhidaoauto.map.sdk.open.query.PoiItem;
import com.zhidaoauto.map.sdk.open.query.PoiSearchItem;
import com.zhidaoauto.map.sdk.open.query.PoiSearchResult;
import com.zhidaoauto.map.sdk.open.query.Query;
import com.zhidaoauto.map.sdk.open.query.RegeocodeAddress;
import com.zhidaoauto.map.sdk.open.query.RegeocodeQuery;
import com.zhidaoauto.map.sdk.open.query.RegeocodeResult;
import com.zhidaoauto.map.sdk.open.query.SearchBound;
import com.zhidaoauto.map.sdk.open.query.Tip;
import java.util.ArrayList;
import java.util.List;
import mogo.telematics.pad.MessagePad;
/**
* @author congtaowang
* @since 2019-12-18
* <p>
* 业务对象和实际对象转换
*/
public class ObjectUtils {
public static MarkerOptions fromMogo(MogoMarkerOptions opt) {
if (opt == null) {
return null;
}
ArrayList<BitmapDescriptor> descriptors = new ArrayList<>();
final ArrayList<Bitmap> icons = opt.getIcons();
if (icons != null && !icons.isEmpty()) {
for (Bitmap icon : icons) {
if (icon == null || icon.isRecycled()) {
continue;
}
descriptors.add(new BitmapDescriptor(icon));
}
}
MarkerOptions markerOptions = new MarkerOptions()
.setGps(opt.isGps())
.position(new LonLatPoint(opt.getLongitude(), opt.getLatitude()))
.anchor(opt.getU(), opt.getV())
.icons(descriptors)
.period(opt.getPeriod())
.controlAngle(opt.isControlAngle())
.rotateAngle(opt.getRotate())
.setFlat(opt.isFlat())
.visible(opt.isVisible())
.infoWindowEnable(opt.isInifoWindowEnable())
.scale(opt.getScale())
.alpha(opt.getAlpha())
.setInfoWindowOffset(opt.getOffsetX(), opt.getOffsetY())
.zIndex(opt.getzIndex());
try {
if (!TextUtils.isEmpty(opt.getAnchorColor())) {
Color.parseColor(opt.getAnchorColor());
markerOptions.anchorColor(opt.getAnchorColor());
}
} catch (Exception e) {
//e.printStackTrace();
}
markerOptions.vrEnable(opt.is3DMode());
if (!TextUtils.isEmpty(opt.getResName())) {
markerOptions.setMarkerIconName(opt.getResName());
} else {
BitmapDescriptor descriptor = getBitmapDescriptorFromMogo(opt);
if (descriptor != null) {
markerOptions.markerIcon(descriptor);
}
if (opt.getIcon3DRes() != 0) {
markerOptions.marker3DIcon(opt.getIcon3DRes());
}
}
if (!TextUtils.isEmpty(opt.getTitle())) {
markerOptions.title(opt.getTitle());
}
if (!TextUtils.isEmpty(opt.getSnippet())) {
markerOptions.snippet(opt.getSnippet());
}
return markerOptions;
}
public static MarkerSimpleData fromTrafficData(MessagePad.TrackedObject trafficData) {
if (trafficData == null) {
return null;
}
MarkerSimpleData markerOptions = null;
try {
markerOptions = new MarkerSimpleData();
markerOptions.setId(trafficData.getUuid());
markerOptions.setMarkerType(trafficData.getType());
markerOptions.setRotateAngle((float) trafficData.getHeading());
markerOptions.setLat(trafficData.getLatitude());
markerOptions.setLon(trafficData.getLongitude());
} catch (Exception e) {
e.printStackTrace();
}
return markerOptions;
}
private static BitmapDescriptor getBitmapDescriptorFromMogo(MogoMarkerOptions options) {
if (options == null) {
return null;
}
Bitmap icon = options.getIcon();
if (icon != null) {
return BitmapDescriptorFactory.INSTANCE.fromBitmap(icon);
}
View view = options.getIconView();
if (view != null) {
return BitmapDescriptorFactory.INSTANCE.fromView(view);
}
return null;
}
public static MogoLocation fromLocation(com.zhidaoauto.map.sdk.open.location.MogoLocation aLocation) {
if (aLocation == null) {
return null;
}
MogoLocation location = new MogoLocation();
location.setLocType(1); // 定位类型
location.setSatellite(4);
location.setSpeed(aLocation.getSpeed());
location.setLatitude(aLocation.getLat());
location.setLongitude(aLocation.getLon());
location.setAltitude(aLocation.getAltitude());
location.setBearing((float) aLocation.getHeading());
location.setCityCode(aLocation.getCityCode());
location.setCityName(aLocation.getCity());
location.setProvider(aLocation.getProvider());
location.setAddress(aLocation.getAddress());
location.setDistrict(aLocation.getDistrict());
location.setProvince(aLocation.getProvince());
location.setAdCode(aLocation.getAdCode());
// location.setAccuracy( aLocation.getAccuracy() );
// location.setTime( aLocation.getTime() );
// location.setLocationDetail( aLocation.getLocationDetail() );
// location.setPoiName( aLocation.getPoiName() );
// location.setAoiName( aLocation.getAoiName() );
// location.setErrCode( aLocation.getErrorCode() );
// location.setErrInfo( aLocation.getErrorInfo() );
// location.setStreetNum( aLocation.getStreetNum() );
// location.setDescription( aLocation.getDescription() );
// location.setBuildingId( aLocation.getBuildingId() );
// location.setFloor( aLocation.getFloor() );
// location.setGpsAccuracyStatus( aLocation.getGpsAccuracyStatus() );
return location;
}
public static LonLatPoint fromMogo(MogoLatLng latLng) {
if (latLng == null) {
return null;
}
return new LonLatPoint(latLng.lon, latLng.lat);
}
// public static NaviLatLng fromMogoAsNavi( MogoLatLng latLng ) {
// if ( latLng == null ) {
// return null;
// }
// return new NaviLatLng( latLng.lat, latLng.lng );
// }
// public static LatLng fromMogo2( MogoLatLng latLng ) {
// if ( latLng == null ) {
// return null;
// }
// return new LatLng( latLng.lat, latLng.lng );
// }
public static MogoLatLng fromAMap(LonLatPoint point) {
if (point == null) {
return null;
}
return new MogoLatLng(point.getLatitude(), point.getLongitude());
}
// public static MogoLatLng CameraPositionfromAMap( LatLng point ) {
// if ( point == null ) {
// return null;
// }
// return new MogoLatLng( point.latitude, point.longitude );
// }
public static GeocodeQuery fromMogo(MogoGeocodeQuery query) {
if (query == null) {
return null;
}
GeocodeQuery q = new GeocodeQuery(query.getLocationName(), query.getCity());
return q;
}
public static RegeocodeQuery fromMogo(MogoRegeocodeQuery query) {
if (query == null) {
return null;
}
RegeocodeQuery q = new RegeocodeQuery(fromMogo(query.getPoint()), 1000);
return q;
}
// public static MogoAoiItem fromAMap( AoiItem amapItem ) {
// if ( amapItem == null ) {
// return null;
// }
// MogoAoiItem mogoAoiItem = new MogoAoiItem();
// mogoAoiItem.setAdCode( amapItem.getAdCode() );
// mogoAoiItem.setAoiArea( amapItem.getAoiArea() );
// mogoAoiItem.setAoiCenterPoint( fromAMap( amapItem.getAoiCenterPoint() ) );
// mogoAoiItem.setAoiId( amapItem.getAoiId() );
// mogoAoiItem.setAoiName( amapItem.getAoiName() );
// return mogoAoiItem;
// }
//
// public static MogoBusinessArea fromAMap( BusinessArea amapItem ) {
// if ( amapItem == null ) {
// return null;
// }
// MogoBusinessArea mogoBusinessArea = new MogoBusinessArea();
// mogoBusinessArea.setCenterPoint( fromAMap( amapItem.getCenterPoint() ) );
// mogoBusinessArea.setName( amapItem.getName() );
// return mogoBusinessArea;
// }
//
//
// public static MogoCrossroad fromAMap( Crossroad amapItem ) {
// if ( amapItem == null ) {
// return null;
// }
// MogoCrossroad mogoCrossroad = new MogoCrossroad();
// mogoCrossroad.setDirection( amapItem.getDirection() );
// mogoCrossroad.setDistance( amapItem.getDistance() );
// mogoCrossroad.setFirstRoadId( amapItem.getFirstRoadId() );
// mogoCrossroad.setFirstRoadName( amapItem.getFirstRoadName() );
// mogoCrossroad.setSecondRoadId( amapItem.getSecondRoadId() );
// mogoCrossroad.setSecondRoadName( amapItem.getSecondRoadName() );
// return mogoCrossroad;
// }
public static MogoGeocodeAddress fromAMap(GeocodeAddress address) {
if (address == null) {
return null;
}
MogoGeocodeAddress mogoGeocodeAddress = new MogoGeocodeAddress();
mogoGeocodeAddress.setAdcode(address.getAdcode());
mogoGeocodeAddress.setBuilding(address.getBuilding());
mogoGeocodeAddress.setCity(address.getCity());
mogoGeocodeAddress.setDistrict(address.getDistrict());
mogoGeocodeAddress.setFormatAddress(address.getFormatAddress());
mogoGeocodeAddress.setLatlng(fromAMap(address.getLonlat()));
mogoGeocodeAddress.setLevel(address.getLevel());
mogoGeocodeAddress.setNeighborhood(address.getNeighborhood());
mogoGeocodeAddress.setProvince(address.getProvince());
mogoGeocodeAddress.setTownship(address.getTownship());
return mogoGeocodeAddress;
}
public static MogoGeocodeResult fromAMap(GeocodeResult result) {
if (result == null || result.getGeocodeAddressList() == null) {
return null;
}
MogoGeocodeResult mogoGeocodeResult = new MogoGeocodeResult();
final List<MogoGeocodeAddress> addresses = new ArrayList<>();
List<GeocodeAddress> list = result.getGeocodeAddressList();
for (GeocodeAddress geocodeAddress : list) {
final MogoGeocodeAddress mogoGeocodeAddress = fromAMap(geocodeAddress);
if (mogoGeocodeAddress != null) {
addresses.add(mogoGeocodeAddress);
}
}
mogoGeocodeResult.setAddresses(addresses);
return mogoGeocodeResult;
}
// public static MogoIndoorData fromAMap( IndoorData data ) {
// if ( data == null ) {
// return null;
// }
// MogoIndoorData mogoIndoorData = new MogoIndoorData();
// mogoIndoorData.setFloor( data.getFloor() );
// mogoIndoorData.setFloorName( data.getFloorName() );
// mogoIndoorData.setPoiId( data.getPoiId() );
// return mogoIndoorData;
// }
//
// public static MogoPhoto fromAMap( Photo photo ) {
// if ( photo == null ) {f
// return null;
// }
// MogoPhoto mogoPhoto = new MogoPhoto();
// mogoPhoto.setTitle( photo.getTitle() );
// mogoPhoto.setUrl( photo.getUrl() );
// return mogoPhoto;
// }
//
// public static MogoPoiItemExtension fromAMap( PoiItemExtension poiItemExtension ) {
// if ( poiItemExtension == null ) {
// return null;
// }
// MogoPoiItemExtension mogoPoiItemExtension = new MogoPoiItemExtension();
// mogoPoiItemExtension.setOpentime( poiItemExtension.getOpentime() );
// mogoPoiItemExtension.setRating( poiItemExtension.getmRating() );
// return mogoPoiItemExtension;
// }
//
// public static MogoRegeocodeRoad fromAMap( RegeocodeRoad regeocodeRoad ) {
// if ( regeocodeRoad == null ) {
// return null;
// }
// MogoRegeocodeRoad mogoRegeocodeRoad = new MogoRegeocodeRoad();
// mogoRegeocodeRoad.setDirection( regeocodeRoad.getDirection() );
// mogoRegeocodeRoad.setDistance( regeocodeRoad.getDistance() );
// mogoRegeocodeRoad.setId( regeocodeRoad.getId() );
// mogoRegeocodeRoad.setName( regeocodeRoad.getName() );
// mogoRegeocodeRoad.setPoint( fromAMap( regeocodeRoad.getLatLngPoint() ) );
// return mogoRegeocodeRoad;
// }
//
// public static MogoStreetNumber fromAMap( StreetNumber streetNumber ) {
// if ( streetNumber == null ) {
// return null;
// }
// MogoStreetNumber mogoStreetNumber = new MogoStreetNumber();
// mogoStreetNumber.setDirection( streetNumber.getDirection() );
// mogoStreetNumber.setDistance( streetNumber.getDistance() );
// mogoStreetNumber.setLatLonPoint( fromAMap( streetNumber.getLatLonPoint() ) );
// mogoStreetNumber.setNumber( streetNumber.getNumber() );
// mogoStreetNumber.setStreet( streetNumber.getStreet() );
// return mogoStreetNumber;
// }
// public static MogoSubPoiItem fromAMap( SubPoiItem subPoiItem ) {
// if ( subPoiItem == null ) {
// return null;
// }
// MogoSubPoiItem mogoSubPoiItem = new MogoSubPoiItem();
// mogoSubPoiItem.setDistance( subPoiItem.getDistance() );
// mogoSubPoiItem.setPoiId( subPoiItem.getPoiId() );
// mogoSubPoiItem.setPoint( fromAMap( subPoiItem.getLatLonPoint() ) );
// mogoSubPoiItem.setSnippet( subPoiItem.getSnippet() );
// mogoSubPoiItem.setSubName( mogoSubPoiItem.getSubName() );
// mogoSubPoiItem.setSubTypeDes( mogoSubPoiItem.getSubTypeDes() );
// mogoSubPoiItem.setTitle( mogoSubPoiItem.getTitle() );
// return mogoSubPoiItem;
// }
public static MogoPoiItem fromAMap(PoiItem poiItem) {
if (poiItem == null) {
return null;
}
MogoPoiItem mogoPoiItem = new MogoPoiItem();
mogoPoiItem.setAdCode(poiItem.getAdCode());
mogoPoiItem.setAdName(poiItem.getAdName());
mogoPoiItem.setBusinessArea(poiItem.getBusinessArea());
mogoPoiItem.setCityCode(poiItem.getCityCode());
mogoPoiItem.setCityName(poiItem.getCityName());
mogoPoiItem.setDirection(poiItem.getDirection());
mogoPoiItem.setDistance(poiItem.getDistance());
mogoPoiItem.setEmail(poiItem.getEmail());
mogoPoiItem.setEnter(fromAMap(poiItem.getEnter()));
mogoPoiItem.setExit(fromAMap(poiItem.getExit()));
// mogoPoiItem.setIndoorData( fromAMap( poiItem.getIndoorData() ) );
mogoPoiItem.setParkingType(poiItem.getParkingType());
// mogoPoiItem.setIndoorMap( poiItem.isIndoorMap() );
// if ( poiItem.getPhotos() != null ) {
// List< MogoPhoto > mogoPhotos = new ArrayList<>();
// for ( Photo photo : poiItem.getPhotos() ) {
// MogoPhoto mogoPhoto = fromAMap( photo );
// if ( mogoPhoto != null ) {
// mogoPhotos.add( mogoPhoto );
// }
// }
// mogoPoiItem.setPhotos( mogoPhotos );
// }
// mogoPoiItem.setPoiExtension( fromAMap( poiItem.getPoiExtension() ) );
mogoPoiItem.setPoiId(poiItem.getPoiId());
mogoPoiItem.setPoint(fromAMap(poiItem.getLonLatPoint()));
mogoPoiItem.setPostcode(poiItem.getPostcode());
mogoPoiItem.setProvinceCode(poiItem.getProvinceCode());
mogoPoiItem.setProvinceName(poiItem.getProvinceName());
mogoPoiItem.setShopID(poiItem.getShopID());
mogoPoiItem.setSnippet(poiItem.getSnippet());
// if ( poiItem.getSubPois() != null ) {
// List< MogoSubPoiItem > mogoSubPoiItems = new ArrayList<>();
// for ( SubPoiItem subPois : poiItem.getSubPois() ) {
// MogoSubPoiItem mogoSubPoiItem = fromAMap( subPois );
// if ( mogoPoiItem != null ) {
// mogoSubPoiItems.add( mogoSubPoiItem );
// }
// }
// mogoPoiItem.setSubPois( mogoSubPoiItems );
// }
mogoPoiItem.setTel(poiItem.getTel());
mogoPoiItem.setTypeCode(poiItem.getTypeCode());
mogoPoiItem.setTitle(poiItem.getTitle());
mogoPoiItem.setTypeDes(poiItem.getTypeDes());
mogoPoiItem.setWebsite(poiItem.getWebsite());
return mogoPoiItem;
}
public static MogoRegeocodeAddress fromAMap(RegeocodeAddress regeocodeAddress) {
if (regeocodeAddress == null) {
return null;
}
MogoRegeocodeAddress mogoRegeocodeAddress = new MogoRegeocodeAddress();
mogoRegeocodeAddress.setAdCode(regeocodeAddress.getAdCode());
// if ( regeocodeAddress.getAois() != null ) {
// List< MogoAoiItem > items = new ArrayList<>();
// for ( AoiItem aois : regeocodeAddress.getAois() ) {
// final MogoAoiItem mogoAoiItem = fromAMap( aois );
// if ( mogoAoiItem != null ) {
// items.add( mogoAoiItem );
// }
// }
// mogoRegeocodeAddress.setAois( items );
// }
mogoRegeocodeAddress.setBuilding(regeocodeAddress.getBuilding());
// if ( regeocodeAddress.getBusinessAreas() != null ) {
// List< MogoBusinessArea > mogoBusinessAreas = new ArrayList<>();
// for ( BusinessArea businessArea : regeocodeAddress.getBusinessAreas() ) {
// MogoBusinessArea mogoBusinessArea = fromAMap( businessArea );
// if ( mogoBusinessArea != null ) {
// mogoBusinessAreas.add( mogoBusinessArea );
// }
// }
// mogoRegeocodeAddress.setBusinessAreas( mogoBusinessAreas );
// }
mogoRegeocodeAddress.setCity(regeocodeAddress.getCity());
mogoRegeocodeAddress.setCityCode(regeocodeAddress.getCityCode());
mogoRegeocodeAddress.setCountry(regeocodeAddress.getCountry());
// if ( regeocodeAddress.getCrossroads() != null ) {
// List< MogoCrossroad > mogoCrossroads = new ArrayList<>();
// for ( Crossroad crossroad : regeocodeAddress.getCrossroads() ) {
//
// MogoCrossroad mogoCrossroad = fromAMap( crossroad );
// if ( mogoCrossroad != null ) {
// mogoCrossroads.add( mogoCrossroad );
// }
// }
// mogoRegeocodeAddress.setCrossroads( mogoCrossroads );
// }
mogoRegeocodeAddress.setDistrict(regeocodeAddress.getDistrict());
mogoRegeocodeAddress.setFormatAddress(regeocodeAddress.getFormatAddress());
mogoRegeocodeAddress.setNeighborhood(regeocodeAddress.getNeighborhood());
if (regeocodeAddress.getPoiList() != null) {
List<MogoPoiItem> mogoPoiItems = new ArrayList<>();
List<PoiItem> list = regeocodeAddress.getPoiList();
for (PoiItem pois : list) {
MogoPoiItem mogoPoiItem = fromAMap(pois);
mogoPoiItems.add(mogoPoiItem);
}
mogoRegeocodeAddress.setPois(mogoPoiItems);
}
mogoRegeocodeAddress.setProvince(regeocodeAddress.getProvince());
// if ( regeocodeAddress.getRoads() != null ) {
// List< MogoRegeocodeRoad > mogoRegeocodeRoads = new ArrayList<>();
// for ( RegeocodeRoad road : regeocodeAddress.getRoads() ) {
// MogoRegeocodeRoad mogoRegeocodeRoad = fromAMap( road );
// if ( mogoRegeocodeRoad != null ) {
// mogoRegeocodeRoads.add( mogoRegeocodeRoad );
// }
// }
// mogoRegeocodeAddress.setRoads( mogoRegeocodeRoads );
// }
// mogoRegeocodeAddress.setStreetNumber( fromAMap( regeocodeAddress.getStreetNumber() ) );
mogoRegeocodeAddress.setTowncode(regeocodeAddress.getTowncode());
mogoRegeocodeAddress.setTownship(regeocodeAddress.getTownship());
return mogoRegeocodeAddress;
}
public static MogoRegeocodeResult fromAMap(RegeocodeResult regeocodeResult) {
if (regeocodeResult == null) {
return null;
}
MogoRegeocodeResult mogoRegeocodeResult = new MogoRegeocodeResult();
mogoRegeocodeResult.setRegeocodeAddress(fromAMap(regeocodeResult.getRegeocodeAddress()));
return mogoRegeocodeResult;
}
public static InputtipsQuery fromMogo(MogoInputtipsQuery query) {
if (query == null) {
return null;
}
InputtipsQuery inputtipsQuery = new InputtipsQuery(query.getKeyword(), query.getCity());
inputtipsQuery.setCityLimit(query.isCityLimit());
inputtipsQuery.setLocation(fromMogo(query.getLocation()));
inputtipsQuery.setType(query.getType());
return inputtipsQuery;
}
public static MogoTip fromAMap(Tip tip) {
if (tip == null) {
return null;
}
MogoTip mogoTip = new MogoTip();
mogoTip.setAdCode(tip.getAdcode());
mogoTip.setAddress(tip.getAddress());
mogoTip.setDistrict(tip.getDistrict());
mogoTip.setName(tip.getName());
mogoTip.setPoiID(tip.getPoiID());
mogoTip.setPoint(fromAMap(tip.getLatPoint()));
mogoTip.setTypeCode(tip.getTypeCode());
return mogoTip;
}
// public static MogoPoi fromAMap( Poi poi ) {
// if ( poi == null ) {
// return null;
// }
// MogoPoi mogoPoi = new MogoPoi();
// mogoPoi.setCoordinate( fromAMap( poi.getCoordinate() ) );
// mogoPoi.setName( poi.getName() );
// mogoPoi.setPoiId( poi.getPoiId() );
// return mogoPoi;
// }
public static MogoPoiSearchQuery fromAMap(Query query) {
if (query == null) {
return null;
}
MogoPoiSearchQuery mogoPoiSearchQuery = new MogoPoiSearchQuery(query.getKeyword(), query.getCategory(), query.getCity());
// mogoPoiSearchQuery.setBuilding( query.getBuilding() );
mogoPoiSearchQuery.setCityLimit(query.getCityLimit());
mogoPoiSearchQuery.setDistanceSort(query.getDistanceSort());
mogoPoiSearchQuery.setLocation(fromAMap(query.getLocation()));
mogoPoiSearchQuery.setPageNum(query.getPageNum());
mogoPoiSearchQuery.setPageSize(query.getPageSize());
return mogoPoiSearchQuery;
}
public static Query fromMogo(MogoPoiSearchQuery query) {
if (query == null || query.getQuery() == null) {
return null;
}
Query psq = new Query(query.getQuery(), "", "");
String category = getCategory(query.getQuery());
if (!category.equals(""))
psq = new Query("", "", getCategory(query.getQuery()));
// psq.setBuilding( query.getBuilding() );
psq.setCityLimit(query.isCityLimit());
psq.setDistanceSort(query.isDistanceSort());
psq.setLocation(fromMogo(query.getLocation()));
psq.setPageNum(query.getPageNum());
psq.setPageSize(query.getPageSize());
return psq;
}
public static MogoSearchBound fromAMap(SearchBound bound) {
if (bound == null) {
return null;
}
if (bound.getShape() == SearchBound.BOUND_SHAPE) {
return new MogoSearchBound(fromAMap(bound.getCenter()), bound.getRange(), bound.isDistanceSort());
} else if (bound.getShape() == SearchBound.POLYGON_SHAPE) {
return new MogoSearchBound(fromAMap(bound.getPolyGonList()));
} else if (bound.getShape() == SearchBound.RECTANGLE_SHAPE) {
return new MogoSearchBound(fromAMap(bound.getLowerLeft()), fromAMap(bound.getUpperRight()));
}
return null;
}
public static List<MogoLatLng> fromAMap(List<LonLatPoint> latLngs) {
if (latLngs == null) {
return null;
}
List<MogoLatLng> result = new ArrayList<>(latLngs.size());
for (LonLatPoint latLng : latLngs) {
result.add(fromAMap(latLng));
}
return result;
}
public static List<LonLatPoint> fromMogo(List<MogoLatLng> latLngs) {
if (latLngs == null) {
return null;
}
List<LonLatPoint> result = new ArrayList<>(latLngs.size());
for (MogoLatLng latLng : latLngs) {
result.add(fromMogo(latLng));
}
return result;
}
public static SearchBound fromMogo(MogoSearchBound bound) {
if (bound == null) {
return null;
}
if (bound.getShape() == MogoSearchBound.SHAPE_BOUND) {
return new SearchBound(fromMogo(bound.getCenterPoint()), bound.getRadiusInMeters(), bound.isDistanceSort());
} else if (bound.getShape() == MogoSearchBound.SHAPE_POLYGON) {
return new SearchBound(fromMogo(bound.getPolyGonList()));
} else if (bound.getShape() == MogoSearchBound.SHAPE_RECTANGLE) {
return new SearchBound(fromMogo(bound.getLowerLeft()), fromMogo(bound.getUpperRight()));
}
return null;
}
public static MogoPoiResult fromAMap(PoiSearchResult result) {
if (result == null) {
return null;
}
MogoPoiResult mogoPoiResult = new MogoPoiResult();
if (result.getItems() != null) {
final List<PoiSearchItem> poiItems = result.getItems();
final ArrayList<MogoPoiItem> mogoPoiItems = new ArrayList<>(poiItems.size());
for (PoiSearchItem poiItem : poiItems) {
mogoPoiItems.add(fromAMap(poiItem.getPoi()));
}
mogoPoiResult.setPois(mogoPoiItems);
}
return mogoPoiResult;
}
public static PolylineOptions fromMogo(MogoPolylineOptions options) {
if (options == null) {
return null;
}
PolylineOptions target = new PolylineOptions();
target.setGps(options.gps());
if (options.getPoints() != null) {
List<LonLatPoint> points = new ArrayList<>();
for (MogoLatLng point : options.getPoints()) {
points.add(fromMogo(point));
}
target.lonLatPoints(points);
}
target.setLineWidth(options.getWidth());
target.zIndex(options.getZIndex());
target.setColor(options.getColor());
target.useGradient(options.isGradient());
if (options.getColorValues() != null) {
target.colorValues(options.getColorValues());
}
// target.transparency( options.getTransparency() );
// target.aboveMaskLayer( options.isAboveMaskLayer() );
// target.lineCapType( PolylineOptions.LineCapType.LineCapRound );
// target.lineJoinType( PolylineOptions.LineJoinType.LineJoinRound );
// target.setDottedLineType( PolylineOptions.DOTTEDLINE_TYPE_CIRCLE );
return target;
}
public static MapCameraPosition fromAMap(CameraPosition position) {
if (position == null) {
return null;
}
return new MapCameraPosition(fromAMap(position.getTarget()), position.getBearing(), position.getTilt(), position.getZoom());
}
private static String getCategory(String key) {
String category = "";
if (key.equals("加油站")) {
category = "6";
} else if (key.equals("停车场")) {
category = "12";
} else if (key.equals("餐馆")) {
category = "22";
} else if (key.equals("洗车")) {
category = "8";
} else if (key.equals("厕所")) {
}
return category;
}
}

View File

@@ -1,138 +0,0 @@
package com.mogo.map.impl.custom.utils;
import com.mogo.cloud.commons.utils.CoordinateUtils;
import com.mogo.eagle.core.data.map.MogoLatLng;
import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger;
import com.zhidaoauto.map.sdk.open.query.LonLatPoint;
import java.util.List;
/**
* 点之间插值工具类
*
* @author tongchenfei
*/
public class PointInterpolatorUtil {
private static final String TAG = "PointInterpolatorUtil";
private static final int DISTANCE_THRESHOLD = 2;
/**
* 在(x1,y1) (x2,y2)中间插入一些点,使每两个点之间距离<={@link #DISTANCE_THRESHOLD},利用如下公式进行计算
* xn = x1 + (x2 - x1)*n/a
* yn = y1 + (y2 - y1)*n/a
* a = (distance/{@link #DISTANCE_THRESHOLD}) +1
* n in 1 .. a-1
* n == 0 时xn = x1
* n == a 时xn = x2
* <p>
* 将xn依次插入x1到x2之间
*
* @param points 待插值点集
* @deprecated 这个方法有问题,并不能算出来想要的值
*/
@Deprecated
public static void interpolate(List<MogoLatLng> points) {
if (points.size() >= 2) {
// 插值
for (int i = 0; i < points.size() - 1; i++) {
MogoLatLng current = points.get(i);
MogoLatLng next = points.get(i + 1);
float distance = CoordinateUtils.calculateLineDistance(current.lon, current.lat, next.lon, next.lat);
CallerLogger.INSTANCE.d(TAG, i + ": " + distance);
if (distance > DISTANCE_THRESHOLD) {
int inter = (int) (distance / DISTANCE_THRESHOLD) + 1;
for (int j = 1; j < inter; j++) {
double newLat = current.lat + (next.lat - current.lat) * j / inter;
double newLon = current.lon + (next.lon - current.lon) * j / inter;
CallerLogger.INSTANCE.d(TAG, "distance: " + distance + ", j: " + j + ", nextLat: " + next.lat + ", nextLon: " + next.lon + ", newLat: " + newLat + ", newLon: " + newLon);
points.add(i + 1, new MogoLatLng(newLat, newLon));
current = points.get(++i);
}
}
}
}
}
/**
* 道路吸附算法
* <p>
* 所谓的道路数据实际就是道路对应的点集每两个点之间是直线但是两点间距并不固定点集内点的数量也不固定点集是有序的按道路方向排序road[0]是起点。
* 为了避免拐弯道路的问题,先使用{@link #getCloseTwoPoint(int, int, double, double, List)}从道路数据里面找出距离目标点最近的两个点记为A、B最近的两个点就在目标点一前一后排列
* 这样的话求一下目标点到AB的垂直映射以及距离{@link #getFootAndMinDistance(double, double, double, double, double, double)},就是吸附后的经纬度和距离
*
* @param lon 目标经度
* @param lat 目标纬度
* @param road 目标道路数据
* @return double[]{吸附后的经度,吸附后的纬度,目标经纬度距离道路的垂直距离}
*/
public static double[] mergeToRoad(double lon, double lat, List<LonLatPoint> road) {
int closeStart = 0;
int closeEnd = road.size() - 1;
int[] result = getCloseTwoPoint(closeStart, closeEnd, lon, lat, road);
LonLatPoint start = road.get(result[0]);
LonLatPoint end = road.get(result[1]);
return getFootAndMinDistance(lon, lat, start.getLongitude(), start.getLatitude(), end.getLongitude(), end.getLatitude());
}
/**
* 获取距离目标点经纬度最近的道路点index
* <p>
* 采用二分查找思想,先用道路数据的起点和终点分别计算距离目标点的距离:
* 若起点距离较远,则说明目标点在整条道路的后半段,则将起点后移至原起点和终点的中间,继续递归计算;
* 同理,若终点距离较远,则目标点在前半段,则终点前移,继续递归计算;
* 递归结束条件是起点index和终点index间隔是1
*
* @param closeStart 距离目标点最近的起始点index
* @param closeEnd 距离目标点最近的终点index
* @param lon 目标点经度
* @param lat 目标点纬度
* @param road 目标道路
* @return int[]{距离目标点最近的起始点index,距离目标点最近的终点index}
*/
private static int[] getCloseTwoPoint(int closeStart, int closeEnd, double lon, double lat, List<LonLatPoint> road) {
if (closeEnd - closeStart == 1) {
return new int[]{closeStart, closeEnd};
}
LonLatPoint start = road.get(closeStart);
LonLatPoint end = road.get(closeEnd);
float startDistance = CoordinateUtils.calculateLineDistance(start.getLongitude(), start.getLatitude(), lon, lat);
float endDistance = CoordinateUtils.calculateLineDistance(end.getLongitude(), end.getLatitude(), lon, lat);
if (startDistance > endDistance) {
closeStart += (closeEnd - closeStart) / 2;
} else {
closeEnd -= (closeEnd - closeStart) / 2;
}
return getCloseTwoPoint(closeStart, closeEnd, lon, lat, road);
}
/**
* 计算垂足以及最短距离
*
* @param x target point lon
* @param y target point lat
* @param x1 线段起点 lon
* @param y1 起点起点 lat
* @param x2 线段终点 lon
* @param y2 线段终点 lat
* @return double[]{footLon,footLat,minDistance} if(footLon == -1) => no foot or foot not in line
*/
private static double[] getFootAndMinDistance(double x, double y, double x1, double y1, double x2, double y2) {
double[] result = new double[]{-1, -1, -1};
double cross = (x2 - x1) * (x - x1) + (y2 - y1) * (y - y1);
if (cross < 0) {
// 垂足没有在线段内,所以也无需计算最短距离
return result;
}
double d2 = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
if (cross > d2) {
// 垂足没有在线段内,所以也无需计算最短距离
return result;
}
double r = cross / d2;
result[0] = x1 + (x2 - x1) * r;
result[1] = y1 + (y2 - y1) * r;
result[2] = CoordinateUtils.calculateLineDistance(result[0], result[1], x, y);
return result;
}
}

View File

@@ -1,23 +0,0 @@
package com.mogo.map.impl.custom.utils;
import java.util.HashMap;
import java.util.Map;
/**
* @author congtaowang
* @since 2021/3/8
*
* 描述
*/
public class ResIdCache {
public static Map< String, String > sMarkerCachesResMd5Values = new HashMap<>();
public static String getVal( String name ) {
return sMarkerCachesResMd5Values.get( name );
}
public static void putVal( String name, String val ) {
sMarkerCachesResMd5Values.put( name, val );
}
}

Binary file not shown.

Before

Width:  |  Height:  |  Size: 4.3 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 4.5 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.4 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.2 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.9 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 4.9 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.8 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 4.9 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.4 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.1 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.6 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 2.6 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 2.3 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.8 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.3 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.5 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.8 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.2 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.7 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.5 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.8 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 2.6 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 2.5 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 4.0 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 4.4 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 4.5 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 4.2 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 4.4 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 4.6 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 4.1 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 4.6 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 4.6 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 4.7 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.3 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 4.0 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 4.5 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 4.6 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 4.3 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 4.5 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 4.5 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 4.1 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 4.6 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 4.6 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 4.8 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.3 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.6 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 2.4 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 516 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 12 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.2 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.2 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 2.8 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 2.7 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 2.9 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 2.8 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 2.5 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 2.4 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.6 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.6 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.6 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.3 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.4 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.7 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.5 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.7 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.4 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 2.9 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.0 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 2.9 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.1 KiB

Some files were not shown because too many files have changed in this diff Show More