Merge remote-tracking branch 'origin/demo/shunyi_vr_map' into demo/shunyi_vr_map

modules/mogo-module-common/src/main/java/com/mogo/module/common/drawer/AdasRecognizedResultDrawer.java

@@ -102,7 +102,7 @@ class AdasRecognizedResultDrawer {
                 points.add( new MogoLatLng( latLng.lat, latLon.lon ) );
             }
             if ( points.size() >= 1 ) {
-                marker.startSmooth( points, 1000 );
+                marker.startSmooth( points, 1 );
             }
         }
     }
@@ -153,7 +153,7 @@ class AdasRecognizedResultDrawer {
         }
         MogoMarkerOptions options = new MogoMarkerOptions()
                 .owner( DataTypes.TYPE_MARKER_ADAS )
-                .icon( BitmapFactory.decodeResource( mContext.getResources(), R.drawable.map_custom_ic_current_location2 ) )
+                .icon( BitmapFactory.decodeResource( mContext.getResources(), R.drawable.module_common_online_car_vr_middle ) )
                 .position( new MogoLatLng( recognizedListResult.latLonList.get( 0 ).lat, recognizedListResult.latLonList.get( 0 ).lon ) );
         return MogoApisHandler.getInstance().getApis().getMapServiceApi().getMarkerManager( mContext ).addMarker( ModuleNames.CARD_TYPE_ROAD_CONDITION, options );
     }

modules/mogo-module-common/src/main/java/com/mogo/module/common/drawer/MarkerDrawer.java

@@ -0,0 +1,261 @@
+package com.mogo.module.common.drawer;
+
+import android.text.TextUtils;
+
+import com.mogo.commons.AbsMogoApplication;
+import com.mogo.map.MogoLatLng;
+import com.mogo.map.marker.IMogoMarker;
+import com.mogo.map.marker.IMogoMarkerClickListener;
+import com.mogo.map.marker.MogoMarkerOptions;
+import com.mogo.module.common.MogoApisHandler;
+import com.mogo.module.common.drawer.marker.IMarkerView;
+import com.mogo.module.common.drawer.marker.MapMarkerAdapter;
+import com.mogo.module.common.drawer.marker.OnlineCarMarkerView;
+import com.mogo.module.common.entity.MarkerExploreWay;
+import com.mogo.module.common.entity.MarkerNoveltyInfo;
+import com.mogo.module.common.entity.MarkerOnlineCar;
+import com.mogo.module.common.entity.MarkerShareMusic;
+import com.mogo.module.common.entity.MarkerShowEntity;
+import com.mogo.utils.logger.Logger;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public
+/**
+ * @author congtaowang
+ * @since 2020/10/28
+ * <p>
+ * 描述
+ */
+class MarkerDrawer {
+
+    public static final int MARKER_Z_INDEX_HIGH = 100;
+    public static final int MARKER_Z_INDEX_LOW = 2;
+
+    private static volatile MarkerDrawer sInstance;
+
+    private MarkerDrawer() {
+    }
+
+    public static MarkerDrawer getInstance() {
+        if ( sInstance == null ) {
+            synchronized ( MarkerDrawer.class ) {
+                if ( sInstance == null ) {
+                    sInstance = new MarkerDrawer();
+                }
+            }
+        }
+        return sInstance;
+    }
+
+    public synchronized void release() {
+        sInstance = null;
+    }
+
+    private Object readResolve() {
+        // 阻止反序列化，必须实现 Serializable 接口
+        return sInstance;
+    }
+
+    public IMogoMarker drawMapMarkerImpl( MarkerShowEntity markerShowEntity, int zIndex, IMogoMarkerClickListener listener ) {
+        if ( markerShowEntity == null || markerShowEntity.getMarkerLocation() == null ) {
+            return null;
+        }
+        MogoMarkerOptions options = new MogoMarkerOptions().owner( markerShowEntity.getMarkerType() ).zIndex( zIndex ).object( markerShowEntity ).latitude( markerShowEntity.getMarkerLocation().getLat() ).longitude( markerShowEntity.getMarkerLocation().getLon() );
+        IMarkerView markerView = MapMarkerAdapter.getMarkerView( AbsMogoApplication.getApp(), markerShowEntity, options );
+        if ( markerView instanceof OnlineCarMarkerView ) {
+            try {
+                options.icon( markerView.getBitmap( ( ( MarkerOnlineCar ) markerShowEntity.getBindObj() ).getCarInfo().getVehicleType() ) );
+            } catch ( Exception e ) {
+                options.icon( markerView.getBitmap( 0 ) );
+            }
+            options.anchor( 0.5f, 0.5f );
+        } else {
+            options.icon( markerView.getView() );
+        }
+
+        IMogoMarker marker = MogoApisHandler.getInstance().getApis().getMapServiceApi().getMarkerManager( AbsMogoApplication.getApp() ).addMarker( markerShowEntity.getMarkerType(), options );
+        marker.setOwner( markerShowEntity.getMarkerType() );
+        markerView.setMarker( marker );
+        marker.setOnMarkerClickListener( listener );
+        markerShowEntity.setMarker( marker );
+        return marker;
+    }
+
+    /**
+     * S =  (A ∩ B) ∪ B
+     * （A ∩ B)作为旧列表需要保留的部分
+     *
+     * @param newList
+     * @return
+     */
+    public Map< String, IMogoMarker > purgeMarkerData( List newList, String markerType ) {
+
+        final long start = System.currentTimeMillis();
+        Map< String, IMogoMarker > existMap = new HashMap<>();
+        List< IMogoMarker > allCarsList = MogoApisHandler.getInstance().getApis().getMapServiceApi().getMarkerManager( AbsMogoApplication.getApp() ).getMarkers( markerType );
+        if ( allCarsList == null || allCarsList.isEmpty() ) {
+            return existMap;
+        }
+        if ( newList == null || newList.isEmpty() ) {
+            return existMap;
+        }
+
+        Map< String, IMogoMarker > allMap = new HashMap<>();
+        for ( IMogoMarker marker : allCarsList ) {
+            String sn = getPrimaryKeyFromMarker( marker );
+            allMap.put( sn, marker );
+        }
+        for ( Object entity : newList ) {
+            String sn = getPrimaryKeyFromEntity( entity );
+            if ( allMap.containsKey( sn ) ) {
+                if ( !isNewVehicleType( entity, allMap.get( sn ) ) ) {
+                    existMap.put( sn, allMap.get( sn ) );
+                }
+            }
+        }
+        for ( String sn : allMap.keySet() ) {
+            if ( !existMap.containsKey( sn ) ) {
+                IMogoMarker dirtyMarker = allMap.get( sn );
+                allCarsList.remove( dirtyMarker );
+                dirtyMarker.destroy();
+            }
+        }
+        allMap.clear();
+        Logger.i( "timer", "purge data cost " + ( System.currentTimeMillis() - start ) + "ms" );
+        return existMap;
+    }
+
+
+    /**
+     * @param maxAmount 展示的最大数量
+     * @param list
+     * @return
+     */
+    public int getAppropriateSize( int maxAmount, List list ) {
+        if ( list == null ) {
+            return 0;
+        }
+        return Math.min( maxAmount, list.size() );
+    }
+
+
+    private boolean isNewVehicleType( Object object, IMogoMarker marker ) {
+        if ( object instanceof MarkerOnlineCar
+                && marker != null
+                && marker.getObject() instanceof MarkerShowEntity
+                && ( ( MarkerShowEntity ) marker.getObject() ).getBindObj() instanceof MarkerOnlineCar ) {
+            try {
+                return ( ( MarkerOnlineCar ) object ).getCarInfo().getVehicleType()
+                        != ( ( MarkerOnlineCar ) ( ( MarkerShowEntity ) marker.getObject() ).getBindObj() ).getCarInfo().getVehicleType();
+            } catch ( Exception e ) {
+
+            }
+        }
+        return false;
+    }
+
+    public String getPrimaryKeyFromEntity( Object entity ) {
+        if ( entity instanceof MarkerExploreWay ) {
+            String id = ( ( MarkerExploreWay ) entity ).getInfoId();
+            if ( !TextUtils.isEmpty( id ) ) {
+                return id;
+            }
+        }
+        return getCarSnFromEntity( entity );
+    }
+
+    private String getPrimaryKeyFromMarker( IMogoMarker marker ) {
+        if ( marker == null || marker.getObject() == null || marker.isDestroyed() ) {
+            return null;
+        }
+        if ( !( marker.getObject() instanceof MarkerShowEntity ) ) {
+            return null;
+        }
+        return getPrimaryKeyFromEntity( ( ( MarkerShowEntity ) marker.getObject() ).getBindObj() );
+    }
+
+    private String getCarSnFromEntity( Object entity ) {
+        try {
+            if ( entity instanceof MarkerOnlineCar ) {
+                return ( ( MarkerOnlineCar ) entity ).getUserInfo().getSn();
+            } else if ( entity instanceof MarkerShareMusic ) {
+                return ( ( MarkerShareMusic ) entity ).getUserInfo().getSn();
+            } else if ( entity instanceof MarkerNoveltyInfo ) {
+                return ( ( MarkerNoveltyInfo ) entity ).getSn();
+            } else if ( entity instanceof MarkerExploreWay ) {
+                return ( ( MarkerExploreWay ) entity ).getUserInfo().getSn();
+            }
+        } catch ( Exception e ) {
+
+        }
+        return "";
+    }
+
+    public String getCarSnFromMarker( IMogoMarker marker ) {
+        if ( marker == null || marker.getObject() == null || marker.isDestroyed() ) {
+            return null;
+        }
+        if ( !( marker.getObject() instanceof MarkerShowEntity ) ) {
+            return null;
+        }
+        return getCarSnFromEntity( ( ( MarkerShowEntity ) marker.getObject() ).getBindObj() );
+    }
+
+    /**
+     * 距离半径计算方式
+     *
+     * @param point1 点一坐标
+     * @param point2 点二坐标
+     * @return 两坐标的距离 单位：米（M）
+     */
+    public static float calculateLineDistance( MogoLatLng point1, MogoLatLng point2 ) {
+        if ( point1 != null && point2 != null ) {
+            return calculateLineDistance( point1.lon, point1.lat, point2.lon, point2.lat );
+        } else {
+            return 0.0F;
+        }
+    }
+
+    /**
+     * @param lon1
+     * @param lat1
+     * @param lon2
+     * @param lat2
+     * @return 两坐标的距离 单位：米（M）
+     */
+    public static float calculateLineDistance( double lon1, double lat1, double lon2, double lat2 ) {
+        try {
+            double var2 = lon1;
+            double var4 = lat1;
+            double var6 = lon2;
+            double var8 = lat2;
+            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;
+        }
+    }
+}

modules/mogo-module-common/src/main/java/com/mogo/module/common/drawer/OnlineCarDrawer.java

@@ -0,0 +1,193 @@
+package com.mogo.module.common.drawer;
+
+import android.graphics.Rect;
+
+import com.mogo.commons.AbsMogoApplication;
+import com.mogo.map.MogoLatLng;
+import com.mogo.map.marker.IMogoMarker;
+import com.mogo.map.marker.IMogoMarkerClickListener;
+import com.mogo.module.common.ModuleNames;
+import com.mogo.module.common.MogoApisHandler;
+import com.mogo.module.common.entity.MarkerCarPois;
+import com.mogo.module.common.entity.MarkerLocation;
+import com.mogo.module.common.entity.MarkerOnlineCar;
+import com.mogo.module.common.entity.MarkerShowEntity;
+import com.mogo.utils.logger.Logger;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public
+/**
+ * @author congtaowang
+ * @since 2020/10/28
+ *
+ * 描述
+ */
+class OnlineCarDrawer {
+
+    private static final String TAG = "OnlineCarDrawer";
+
+    // 平滑移动事件间隔(单位:秒)
+    private static final int SMOOTH_DURATION = 15;
+
+    private static volatile OnlineCarDrawer sInstance;
+
+    private OnlineCarDrawer() {
+    }
+
+    public static OnlineCarDrawer getInstance() {
+        if ( sInstance == null ) {
+            synchronized ( OnlineCarDrawer.class ) {
+                if ( sInstance == null ) {
+                    sInstance = new OnlineCarDrawer();
+                }
+            }
+        }
+        return sInstance;
+    }
+
+    public synchronized void release() {
+        sInstance = null;
+    }
+
+    private Object readResolve() {
+        // 阻止反序列化，必须实现 Serializable 接口
+        return sInstance;
+    }
+
+    /**
+     * 绘制在线车辆marker
+     *
+     * @param onlineCarList
+     */
+    public void drawOnlineCarMarkers( List< MarkerOnlineCar > onlineCarList,
+                                      int maxAmount,
+                                      boolean clearOld,
+                                      boolean showBounds,
+                                      Rect bound,
+                                      MogoLatLng centerPoint,
+                                      IMogoMarkerClickListener listener ) {
+        // 将数据同步给在线车辆，避免每次 perform 的时候去拉取，造成消耗
+        if ( onlineCarList == null || onlineCarList.isEmpty() ) {
+            MogoApisHandler.getInstance().getApis().getMapServiceApi().getMarkerManager( AbsMogoApplication.getApp() ).removeMarkers( ModuleNames.CARD_TYPE_USER_DATA );
+            return;
+        }
+
+        if ( clearOld ) {
+            MogoApisHandler.getInstance().getApis().getMapServiceApi().getMarkerManager( AbsMogoApplication.getApp() ).removeMarkers( ModuleNames.CARD_TYPE_USER_DATA );
+        }
+
+        int size = MarkerDrawer.getInstance().getAppropriateSize( maxAmount, onlineCarList );
+
+        Map< String, IMogoMarker > existCarMap = MarkerDrawer.getInstance().purgeMarkerData( onlineCarList, ModuleNames.CARD_TYPE_USER_DATA );
+
+        List< MogoLatLng > carPoints = new ArrayList<>();
+        for ( int i = 0; i < size; i++ ) {
+            MarkerOnlineCar markerOnlineCar = onlineCarList.get( i );
+            MarkerLocation markerLocation = markerOnlineCar.getLocation();
+            MarkerShowEntity markerShowEntity = new MarkerShowEntity();
+            markerShowEntity.setBindObj( markerOnlineCar );
+            markerShowEntity.setMarkerLocation( markerLocation );
+            markerShowEntity.setMarkerType( markerOnlineCar.getType() );
+
+            if ( markerOnlineCar.getCarInfo() != null ) {
+                markerShowEntity.setTextContent( markerOnlineCar.getUserInfo().getUserName() );
+                markerShowEntity.setIconUrl( markerOnlineCar.getUserInfo().getUserHead() );
+            }
+
+            if ( i <= 5 ) {
+                carPoints.add( new MogoLatLng( markerLocation.getLat(), markerLocation.getLon() ) );
+            }
+
+            String sn = MarkerDrawer.getInstance().getPrimaryKeyFromEntity( markerOnlineCar );
+            IMogoMarker mogoMarker = existCarMap.get( sn );
+            if ( mogoMarker == null || mogoMarker.isDestroyed() ) {
+                mogoMarker = MarkerDrawer.getInstance().drawMapMarkerImpl( markerShowEntity, MarkerDrawer.MARKER_Z_INDEX_LOW, listener );
+            }
+            if ( mogoMarker != null ) {
+                mogoMarker.setVisible( true );
+            }
+            startSmooth( mogoMarker, markerOnlineCar, markerLocation );
+        }
+
+        if ( showBounds && bound != null ) {
+            // 将前6个点显示在固定范围内
+            MogoApisHandler.getInstance().getApis().getMapServiceApi().getMapUIController().showBounds( TAG, centerPoint, carPoints, bound, false );
+        }
+    }
+
+
+    // 平滑移动
+    private void startSmooth( IMogoMarker iMogoMarker, MarkerOnlineCar markerOnlineCar,
+                              MarkerLocation markerLocation ) {
+        if ( iMogoMarker == null ) {
+            return;
+        }
+        List< MarkerCarPois > poiList = markerOnlineCar.getPois();
+        if ( filterErrorPoint( poiList ) ) {
+            return;
+        }
+        if ( poiList == null || poiList.size() < 2 ) {
+            return;
+        }
+
+        List< MogoLatLng > points = new ArrayList<>();
+
+        double lastLat = 0.0d;
+        double lastLon = 0.0d;
+
+        for ( int j = 0; j < poiList.size(); j++ ) {
+            MarkerCarPois poi = poiList.get( j );
+            if ( poi == null || poi.getCoordinates() == null && poi.getCoordinates().size() != 2 ) {
+                continue;
+            }
+            try {
+                double lat = Double.valueOf( poi.getCoordinates().get( 1 ) + "" );
+                double lng = Double.valueOf( poi.getCoordinates().get( 0 ) + "" );
+
+                float distance = MarkerDrawer.calculateLineDistance( lastLon, lastLat, lng, lat );
+                lastLon = lng;
+                lastLat = lat;
+                if ( distance < 0.2f ) {// 距离过短，认为静止不动
+                    continue;
+                }
+
+                points.add( new MogoLatLng( lat, lng ) );
+            } catch ( Exception e ) {
+            }
+        }
+        if ( points.size() >= 1 ) {
+            iMogoMarker.startSmooth( points, SMOOTH_DURATION );
+        } else {
+            Logger.d( TAG, "静止小车，但是有相同的连续坐标" );
+        }
+    }
+
+    /**
+     * 有可能出现终点到起点跳跃的情况，需要用"500M"约束起点和终点
+     *
+     * @param poiList
+     */
+    private boolean filterErrorPoint( List< MarkerCarPois > poiList ) {
+        if ( poiList == null || poiList.size() < 2 ) {
+            return false;
+        }
+        MarkerCarPois start = poiList.get( 0 );
+        MarkerCarPois end = poiList.get( poiList.size() - 1 );
+
+        try {
+            double lat1 = Double.valueOf( start.getCoordinates().get( 1 ) + "" );
+            double lng1 = Double.valueOf( start.getCoordinates().get( 0 ) + "" );
+            double lat2 = Double.valueOf( end.getCoordinates().get( 1 ) + "" );
+            double lng2 = Double.valueOf( end.getCoordinates().get( 0 ) + "" );
+            if ( MarkerDrawer.calculateLineDistance( new MogoLatLng( lat1, lng1 ), new MogoLatLng( lat2, lng2 ) ) >= 500 ) {
+                Logger.d( TAG, "filter point" );
+                return true;
+            }
+        } catch ( Exception e ) {
+        }
+        return false;
+    }
+}

modules/mogo-module-common/src/main/java/com/mogo/module/common/drawer/RoadConditionDrawer.java

@@ -0,0 +1,128 @@
+package com.mogo.module.common.drawer;
+
+import android.view.animation.LinearInterpolator;
+
+import com.mogo.commons.AbsMogoApplication;
+import com.mogo.commons.debug.DebugConfig;
+import com.mogo.map.marker.IMogoMarker;
+import com.mogo.map.marker.IMogoMarkerClickListener;
+import com.mogo.map.marker.anim.OnMarkerAnimationListener;
+import com.mogo.module.common.ModuleNames;
+import com.mogo.module.common.MogoApisHandler;
+import com.mogo.module.common.entity.MarkerExploreWay;
+import com.mogo.module.common.entity.MarkerLocation;
+import com.mogo.module.common.entity.MarkerShowEntity;
+import com.mogo.utils.WorkThreadHandler;
+import com.mogo.utils.logger.Logger;
+
+import java.util.List;
+import java.util.Map;
+
+public
+/**
+ * @author congtaowang
+ * @since 2020/10/28
+ *
+ * 描述
+ */
+class RoadConditionDrawer {
+
+    private static final String TAG = "RoadConditionDrawer";
+
+    private static volatile RoadConditionDrawer sInstance;
+
+    private RoadConditionDrawer() {
+    }
+
+    public static RoadConditionDrawer getInstance() {
+        if ( sInstance == null ) {
+            synchronized ( RoadConditionDrawer.class ) {
+                if ( sInstance == null ) {
+                    sInstance = new RoadConditionDrawer();
+                }
+            }
+        }
+        return sInstance;
+    }
+
+    public synchronized void release() {
+        sInstance = null;
+    }
+
+    private Object readResolve() {
+        // 阻止反序列化，必须实现 Serializable 接口
+        return sInstance;
+    }
+
+    /**
+     * 探路数据
+     *
+     * @param exploreWayList
+     */
+    public void drawRoadConditionMarker( List< MarkerExploreWay > exploreWayList, int maxAmount, IMogoMarkerClickListener listener ) {
+        // 将数据同步给探路，避免探路每次 perform 的时候去拉取，造成消耗
+        if ( exploreWayList == null || exploreWayList.isEmpty() ) {
+            MogoApisHandler.getInstance().getApis().getMapServiceApi().getMarkerManager( AbsMogoApplication.getApp() ).removeMarkers( ModuleNames.CARD_TYPE_ROAD_CONDITION );
+            return;
+        }
+        int size = MarkerDrawer.getInstance().getAppropriateSize( maxAmount, exploreWayList );
+        Map< String, IMogoMarker > existCarMap = MarkerDrawer.getInstance().purgeMarkerData( exploreWayList, ModuleNames.CARD_TYPE_ROAD_CONDITION );
+        Logger.i( TAG, "existCarMap: size = %d", existCarMap.size() );
+        for ( int i = 0; i < size; i++ ) {
+            MarkerExploreWay markerExploreWay = exploreWayList.get( i );
+            if ( !markerExploreWay.getCanLive() ) {
+                MarkerLocation markerLocation = markerExploreWay.getLocation();
+
+                MarkerShowEntity markerShowEntity = new MarkerShowEntity();
+                markerShowEntity.setBindObj( markerExploreWay );
+                markerShowEntity.setMarkerLocation( markerLocation );
+                markerShowEntity.setMarkerType( markerExploreWay.getType() );
+                markerShowEntity.setTextContent( markerExploreWay.getAddr() );
+
+                String sn = MarkerDrawer.getInstance().getPrimaryKeyFromEntity( markerExploreWay );
+                IMogoMarker mogoMarker = existCarMap.get( sn );
+                if ( mogoMarker == null || mogoMarker.isDestroyed() ) {
+                    Logger.d( TAG, "draw road condition, sn = %s", sn );
+                    try {
+                        if ( DebugConfig.isRoadEventAnimated() ) {
+                            post2AddAndStartAnimation( markerShowEntity, i * 100L, listener );
+                        } else {
+                            mogoMarker = MarkerDrawer.getInstance().drawMapMarkerImpl( markerShowEntity, MarkerDrawer.MARKER_Z_INDEX_HIGH, listener );
+                        }
+                    } catch ( Exception e ) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+        }
+    }
+
+    private void post2AddAndStartAnimation( MarkerShowEntity entity, long delay, IMogoMarkerClickListener listener ) {
+        if ( entity == null ) {
+            return;
+        }
+        WorkThreadHandler.getInstance().postDelayed( () -> {
+            if ( entity == null ) {
+                return;
+            }
+            IMogoMarker marker = MarkerDrawer.getInstance().drawMapMarkerImpl( entity, MarkerDrawer.MARKER_Z_INDEX_HIGH, listener );
+            if ( marker == null ) {
+                return;
+            }
+            marker.startScaleAnimationWithAlpha( 0, 1.2f, 0, 1.2f, 0f, 1f, 300, new LinearInterpolator(), new OnMarkerAnimationListener() {
+                @Override
+                public void onAnimStart() {
+                    Logger.d( TAG, " onAnimStart ---1----> " );
+                }
+
+                @Override
+                public void onAnimEnd() {
+                    if ( marker == null || marker.isDestroyed() ) {
+                        return;
+                    }
+                    marker.startScaleAnimation( 1.2f, 1, 1.2f, 1, 100, new LinearInterpolator(), null );
+                }
+            } );
+        }, delay );
+    }
+}

modules/mogo-module-common/src/main/java/com/mogo/module/common/drawer/SnapshotSetDataDrawer.java

@@ -108,7 +108,7 @@ class SnapshotSetDataDrawer {
                 points.add( new MogoLatLng( cloudRoadData.getLat(), cloudRoadData.getLon() ) );
             }
             if ( points.size() >= 1 ) {
-                marker.startSmooth( points, 1000 );
+                marker.startSmooth( points, 1 );
             }
         }
     }
@@ -160,7 +160,7 @@ class SnapshotSetDataDrawer {
         }
         MogoMarkerOptions options = new MogoMarkerOptions()
                 .owner( DataTypes.TYPE_MARKER_CLOUD_DATA )
-                .icon( BitmapFactory.decodeResource( mContext.getResources(), R.drawable.map_custom_ic_current_location2 ) )
+                .icon( BitmapFactory.decodeResource( mContext.getResources(), R.drawable.module_common_online_car_vr_middle ) )
                 .position( new MogoLatLng( data.getLat(), data.getLon() ) );
         return MogoApisHandler.getInstance().getApis().getMapServiceApi().getMarkerManager( mContext ).addMarker( ModuleNames.CARD_TYPE_ROAD_CONDITION, options );
     }

modules/mogo-module-common/src/main/java/com/mogo/module/common/drawer/marker/IMarkerView.java

@@ -0,0 +1,23 @@
+package com.mogo.module.common.drawer.marker;
+
+import android.graphics.Bitmap;
+import android.view.View;
+
+import com.mogo.map.marker.IMogoMarker;
+
+/**
+ * @author congtaowang
+ * @since 2020-02-15
+ * <p>
+ * 描述
+ */
+public interface IMarkerView {
+
+    View getView();
+
+    default Bitmap getBitmap( int type ){
+        return null;
+    }
+
+    void setMarker( IMogoMarker marker );
+}

modules/mogo-module-common/src/main/java/com/mogo/module/common/drawer/marker/MapMarkerAdapter.java

@@ -0,0 +1,39 @@
+package com.mogo.module.common.drawer.marker;
+
+import android.content.Context;
+import android.text.TextUtils;
+
+import com.mogo.map.marker.MogoMarkerOptions;
+import com.mogo.module.common.ModuleNames;
+import com.mogo.module.common.entity.MarkerShowEntity;
+
+/**
+ * author : donghongyu
+ * e-mail : 1358506549@qq.com
+ * date   : 2020-01-1015:55
+ * desc   : 地图Marker的适配器
+ * version: 1.0
+ */
+public class MapMarkerAdapter {
+
+    /**
+     * 获取 MarkerShowEntity 填充好的 MarkerView
+     *
+     * @param context          上下文
+     * @param markerShowEntity 要填充的数据
+     * @return MarkerView
+     */
+    public static IMarkerView getMarkerView(Context context, MarkerShowEntity markerShowEntity, MogoMarkerOptions options) {
+
+        if ( TextUtils.equals( markerShowEntity.getMarkerType(), ModuleNames.CARD_TYPE_USER_DATA ) ) {
+            return OnlineCarMarkerView.getInstance();
+        } else {
+            if (markerShowEntity.isChecked()) {
+                return new MapMarkerInfoView(context, markerShowEntity, options);
+            } else {
+                return new MapMarkerView(context, markerShowEntity, options);
+            }
+        }
+
+    }
+}

modules/mogo-module-common/src/main/java/com/mogo/module/common/drawer/marker/MapMarkerBaseView.java

@@ -0,0 +1,141 @@
+package com.mogo.module.common.drawer.marker;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.os.Looper;
+import android.text.TextUtils;
+import android.util.AttributeSet;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import androidx.annotation.Nullable;
+
+import com.mogo.map.marker.IMogoMarker;
+import com.mogo.map.marker.MogoMarkerOptions;
+import com.mogo.module.common.MogoApisHandler;
+import com.mogo.module.common.R;
+import com.mogo.module.common.entity.MarkerShowEntity;
+import com.mogo.service.imageloader.IMogoImageLoaderListener;
+import com.mogo.service.imageloader.MogoImageView;
+import com.mogo.utils.UiThreadHandler;
+import com.mogo.utils.WindowUtils;
+import com.mogo.utils.logger.Logger;
+
+/**
+ * author : donghongyu
+ * e-mail : 1358506549@qq.com
+ * date   : 2020-01-1310:55
+ * desc   : 地图上抽离的Marker的共性
+ * version: 1.0
+ */
+public abstract class MapMarkerBaseView extends LinearLayout implements IMarkerView {
+    private String TAG = "MapMarkerBaseView";
+
+    protected Context mContext;
+    protected MogoMarkerOptions mOptions;
+    protected MogoImageView ivUserHead;
+    protected ImageView ivIcon;
+    protected ImageView ivCar;
+    protected IMogoMarker mMarker;
+
+    public MapMarkerBaseView(Context context) {
+        super(context);
+        mContext = context;
+        initView(context);
+    }
+
+    public MapMarkerBaseView(Context context, @Nullable AttributeSet attrs) {
+        super(context, attrs);
+        mContext = context;
+        initView(context);
+    }
+
+    public MapMarkerBaseView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+        mContext = context;
+        initView(context);
+    }
+
+    @Override
+    public void setMarker( IMogoMarker marker ) {
+        this.mMarker = marker;
+    }
+
+    protected abstract void initView( Context context);
+
+    public abstract void updateView(MarkerShowEntity markerShowEntity);
+
+    protected void loadImageWithMarker(final MarkerShowEntity markerShowEntity) {
+
+        if ( Looper.myLooper() != Looper.getMainLooper() ) {
+            UiThreadHandler.post( ()-> {
+                runOnUiThread( markerShowEntity );
+            });
+        } else {
+            runOnUiThread( markerShowEntity );
+        }
+    }
+
+    private void runOnUiThread(final MarkerShowEntity markerShowEntity){
+        if (!TextUtils.isEmpty(markerShowEntity.getIconUrl())) {
+            MogoApisHandler.getInstance().getApis().getImageLoaderApi().displayImage(markerShowEntity.getIconUrl(),
+                    ivUserHead,
+                    WindowUtils.dip2px(mContext, 50), WindowUtils.dip2px(mContext, 50),
+                    new IMogoImageLoaderListener() {
+                        @Override
+                        public void onStart() {
+
+                        }
+
+                        @Override
+                        public void onCompleted(Bitmap bitmap) {
+                            Logger.d(TAG, "loadImageWithMarker loaded.");
+                            // 使用view渲染地图marker，刷新纹理的时候，需要重新用view生成纹理，然后在设置
+                            if ( mMarker != null ) {
+                                mMarker.setIcon( fromView( MapMarkerBaseView.this ) );
+                            }
+                        }
+
+                        @Override
+                        public void onFailure(Exception e) {
+                            Logger.e(TAG, "loadImageWithMarker onFailure.");
+                        }
+                    });
+
+        } else {
+            ivUserHead.setBackgroundResource( R.drawable.icon_default_user_head);
+        }
+    }
+
+    private Bitmap fromView( View view ) {
+        view.setDrawingCacheEnabled( true );
+        processChildView( view );
+        view.destroyDrawingCache();
+        view.measure( MeasureSpec.makeMeasureSpec( 0, MeasureSpec.UNSPECIFIED ), MeasureSpec.makeMeasureSpec( 0, MeasureSpec.UNSPECIFIED ) );
+        view.layout( 0, 0, view.getMeasuredWidth(), view.getMeasuredHeight() );
+        Bitmap bitmap = null;
+        return ( bitmap = view.getDrawingCache() ) != null ? bitmap.copy( Bitmap.Config.ARGB_8888, false ) : null;
+    }
+
+    private void processChildView( View view ) {
+        if ( !( view instanceof ViewGroup ) ) {
+            if ( view instanceof TextView ) {
+                ( ( TextView ) view ).setHorizontallyScrolling( false );
+            }
+
+        } else {
+            for ( int var1 = 0; var1 < ( ( ViewGroup ) view ).getChildCount(); ++var1 ) {
+                processChildView( ( ( ViewGroup ) view ).getChildAt( var1 ) );
+            }
+
+        }
+    }
+
+    @Override
+    public View getView() {
+        return this;
+    }
+}

modules/mogo-module-common/src/main/java/com/mogo/module/common/drawer/marker/MapMarkerInfoView.java

@@ -0,0 +1,185 @@
+package com.mogo.module.common.drawer.marker;
+
+import android.content.Context;
+import android.text.TextUtils;
+import android.util.AttributeSet;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+import androidx.annotation.Nullable;
+import androidx.constraintlayout.widget.ConstraintLayout;
+
+import com.mogo.map.marker.MogoMarkerOptions;
+import com.mogo.module.common.ModuleNames;
+import com.mogo.module.common.R;
+import com.mogo.module.common.entity.MarkerExploreWay;
+import com.mogo.module.common.entity.MarkerPoiTypeEnum;
+import com.mogo.module.common.entity.MarkerShareMusic;
+import com.mogo.module.common.entity.MarkerShowEntity;
+
+/**
+ * author : donghongyu
+ * e-mail : 1358506549@qq.com
+ * date   : 2020-01-0619:55
+ * desc   : 地图Marker图标带文本信息
+ * version: 1.0
+ */
+public class MapMarkerInfoView extends MapMarkerBaseView {
+    private String TAG = "MapMarkerInfoView";
+
+    private TextView tvMarkerContent;
+    private ConstraintLayout clMarkerContent;
+    private ImageView ivReverseTriangle;
+
+    public MapMarkerInfoView( Context context ) {
+        super( context );
+    }
+
+    public MapMarkerInfoView( Context context, @Nullable AttributeSet attrs ) {
+        super( context, attrs );
+    }
+
+    public MapMarkerInfoView( Context context, @Nullable AttributeSet attrs, int defStyleAttr ) {
+        super( context, attrs, defStyleAttr );
+    }
+
+    public MapMarkerInfoView( Context context, MarkerShowEntity markerShowEntity, MogoMarkerOptions options ) {
+        super( context );
+        mOptions = options;
+        updateView( markerShowEntity );
+    }
+
+    protected void initView( Context context ) {
+        LayoutInflater.from( context ).inflate( R.layout.modudle_services_marker_layout_info, this );
+        ivUserHead = findViewById( R.id.ivUserHead );
+        ivIcon = findViewById( R.id.ivIcon );
+        clMarkerContent = findViewById( R.id.clMarkerContent );
+        ivReverseTriangle = findViewById( R.id.ivReverseTriangle );
+        ivCar = findViewById( R.id.ivCar );
+        tvMarkerContent = findViewById( R.id.tvMarkerContent );
+    }
+
+    public void updateView( MarkerShowEntity markerShowEntity ) {
+        try {
+
+            Object bindObj = markerShowEntity.getBindObj();
+
+            ivCar.setImageResource( R.drawable.icon_map_marker_location_yellow );
+            clMarkerContent.setBackgroundResource( R.drawable.bg_map_marker_yellow_info );
+            ivReverseTriangle.setImageResource( R.drawable.bg_shape_reverse_yellow );
+            switch ( markerShowEntity.getMarkerType() ) {
+                case ModuleNames.CARD_TYPE_CARS_CHATTING:
+                case ModuleNames.CARD_TYPE_USER_DATA:
+                    ivUserHead.setVisibility( View.VISIBLE );
+                    ivIcon.setVisibility( View.INVISIBLE );
+                    loadImageWithMarker( markerShowEntity );
+                    ivCar.setImageResource( R.drawable.icon_map_marker_car_gray );
+                    //ivCar.setRotation(new Random().nextInt(360));
+                    ivCar.setRotation( ( float ) markerShowEntity.getMarkerLocation().getAngle() );
+                    break;
+                case ModuleNames.CARD_TYPE_ROAD_CONDITION:
+                case ModuleNames.CARD_TYPE_NOVELTY:
+                    ivUserHead.setVisibility( View.INVISIBLE );
+                    ivIcon.setVisibility( View.VISIBLE );
+
+                    if ( bindObj instanceof MarkerExploreWay && ( ( MarkerExploreWay ) bindObj ).getPoiType() != null ) {
+                        switch ( ( ( MarkerExploreWay ) bindObj ).getPoiType() ) {
+                            case MarkerPoiTypeEnum.GAS_STATION:
+                                ivIcon.setImageResource( R.drawable.icon_map_marker_refuel );
+                                break;
+                            case MarkerPoiTypeEnum.TRAFFIC_CHECK:
+                                ivIcon.setImageResource( R.drawable.icon_map_marker_road_check2_white );
+                                break;
+                            case MarkerPoiTypeEnum.ROAD_CLOSED:
+                                ivIcon.setImageResource( R.drawable.icon_map_marker_road_block_off2_white );
+                                break;
+                            case MarkerPoiTypeEnum.SHOP_DISCOUNT:
+                                ivIcon.setImageResource( R.drawable.icon_map_marker_shop_discount );
+                                break;
+                            case MarkerPoiTypeEnum.FOURS_4S:
+                                ivIcon.setImageResource( R.drawable.icon_map_marker_4s );
+                                break;
+                            case MarkerPoiTypeEnum.FOURS_ROAD_WORK:
+                                ivIcon.setImageResource( R.drawable.icon_map_marker_road_work2_white );
+                                break;
+                            case MarkerPoiTypeEnum.FOURS_BLOCK_UP:
+                                ivIcon.setImageResource( R.drawable.icon_map_marker_road_block_up2_white );
+                                break;
+                            case MarkerPoiTypeEnum.FOURS_PONDING:
+                                ivIcon.setImageResource( R.drawable.icon_map_marker_pondingl2_white );
+                                break;
+                            case MarkerPoiTypeEnum.FOURS_SHOP_FREE:
+                                ivIcon.setImageResource( R.drawable.icon_map_marker_shop );
+                                break;
+                            case MarkerPoiTypeEnum.FOURS_FOG:
+                                ivIcon.setImageResource( R.drawable.module_service_ic_rc_dark_frog2_white );
+                                break;
+                            case MarkerPoiTypeEnum.FOURS_ICE:
+                                ivIcon.setImageResource( R.drawable.module_service_ic_rc_freeze2_white );
+                                break;
+                            case MarkerPoiTypeEnum.FOURS_PARKING:
+                                ivIcon.setImageResource( R.drawable.module_service_ic_rc_parking2 );
+                                break;
+                            case MarkerPoiTypeEnum.FOURS_ACCIDENT:
+                                ivIcon.setImageResource( R.drawable.module_service_ic_rc_accident3_white );
+                                break;
+                            case MarkerPoiTypeEnum.FOURS_NEALY:
+                                ivIcon.setImageResource( R.drawable.icon_map_marker_shear_news );
+                                break;
+                            case MarkerPoiTypeEnum.FOURS_LIVING:
+                                ivIcon.setImageResource( R.drawable.icon_map_marker_living_white );
+                                break;
+                            case MarkerPoiTypeEnum.ILLEGAL_PARK_LIVING:
+                                ivIcon.setImageResource( R.drawable.module_service_ic_rc_illegal_park_white );
+                                break;
+                            case MarkerPoiTypeEnum.ROAD_SLIPPERY:
+                                ivIcon.setImageResource( R.drawable.module_service_ic_rc_road_slippery_light );
+                                break;
+                            default:
+                                ivIcon.setImageResource( R.drawable.icon_map_marker_road_block_up2_white );
+                                break;
+                        }
+                    }
+                    break;
+                case ModuleNames.CARD_TYPE_SHARE_MUSIC:
+                    ivUserHead.setVisibility( View.INVISIBLE );
+                    ivIcon.setVisibility( View.VISIBLE );
+
+                    if ( bindObj instanceof MarkerShareMusic ) {
+                        // 2 为书籍听书，3 为新闻,1 为qq音乐,int
+                        switch ( ( ( MarkerShareMusic ) bindObj ).getShareType() ) {
+                            case 1:
+                                ivIcon.setImageResource( R.drawable.icon_map_marker_misic );
+                                break;
+                            case 2:
+                                ivIcon.setImageResource( R.drawable.icon_map_marker_book );
+                                break;
+                            case 3:
+                                ivIcon.setImageResource( R.drawable.icon_map_marker_news );
+                                break;
+                            default:
+                                ivIcon.setImageResource( R.drawable.icon_map_marker_misic );
+                                break;
+                        }
+                    }
+
+                    break;
+            }
+            if ( !TextUtils.isEmpty( markerShowEntity.getTextContent() ) ) {
+                String content;
+                if ( markerShowEntity.getTextContent().length() > 8 ) {
+                    content = markerShowEntity.getTextContent().substring( 0, 7 ) + "...";
+                } else {
+                    content = markerShowEntity.getTextContent();
+                }
+                tvMarkerContent.setText( content );
+            }
+
+        } catch ( Exception e ) {
+            e.printStackTrace();
+        }
+    }
+
+}

modules/mogo-module-common/src/main/java/com/mogo/module/common/drawer/marker/MapMarkerView.java

@@ -0,0 +1,127 @@
+package com.mogo.module.common.drawer.marker;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.view.LayoutInflater;
+
+import androidx.annotation.Nullable;
+
+import com.mogo.map.marker.MogoMarkerOptions;
+import com.mogo.module.common.ModuleNames;
+import com.mogo.module.common.MogoApisHandler;
+import com.mogo.module.common.R;
+import com.mogo.module.common.entity.MarkerExploreWay;
+import com.mogo.module.common.entity.MarkerPoiTypeEnum;
+import com.mogo.module.common.entity.MarkerShowEntity;
+
+/**
+ * author : donghongyu
+ * e-mail : 1358506549@qq.com
+ * date   : 2020-01-0619:55
+ * desc   : 地图Marker图标
+ * version: 1.0
+ */
+public class MapMarkerView extends MapMarkerBaseView {
+    private String TAG = "MapMarkerView";
+
+    public MapMarkerView( Context context ) {
+        super( context );
+    }
+
+    public MapMarkerView( Context context, @Nullable AttributeSet attrs ) {
+        super( context, attrs );
+    }
+
+    public MapMarkerView( Context context, @Nullable AttributeSet attrs, int defStyleAttr ) {
+        super( context, attrs, defStyleAttr );
+    }
+
+    public MapMarkerView( Context context, MarkerShowEntity markerShowEntity, MogoMarkerOptions options ) {
+        super( context );
+        mOptions = options;
+        updateView( markerShowEntity );
+    }
+
+    protected void initView( Context context ) {
+        LayoutInflater.from( context ).inflate( R.layout.modudle_services_marker_layout, this );
+        ivIcon = findViewById( R.id.ivIcon );
+        ivCar = findViewById( R.id.ivCar );
+    }
+
+    public void updateView( MarkerShowEntity markerShowEntity ) {
+        try {
+            Object bindObj = markerShowEntity.getBindObj();
+            if ( MogoApisHandler.getInstance().getApis().getMapFrameControllerApi().isVrMode() ) {
+                ivCar.setImageResource( R.drawable.icon_map_marker_location_yellow_vr );
+            } else {
+                ivCar.setImageResource( R.drawable.icon_map_marker_location_yellow );
+            }
+            switch ( markerShowEntity.getMarkerType() ) {
+                case ModuleNames.CARD_TYPE_ROAD_CONDITION:
+                case ModuleNames.CARD_TYPE_NOVELTY:
+                    if ( bindObj instanceof MarkerExploreWay && ( ( MarkerExploreWay ) bindObj ).getPoiType() != null ) {
+                        switch ( ( ( MarkerExploreWay ) bindObj ).getPoiType() ) {
+                            case MarkerPoiTypeEnum.GAS_STATION:
+                                ivIcon.setImageResource( R.drawable.icon_map_marker_refuel );
+                                break;
+                            case MarkerPoiTypeEnum.TRAFFIC_CHECK:
+                                ivIcon.setImageResource( R.drawable.icon_map_marker_road_check2 );
+                                break;
+                            case MarkerPoiTypeEnum.ROAD_CLOSED:
+                                ivIcon.setImageResource( R.drawable.icon_map_marker_road_block_off2 );
+                                break;
+                            case MarkerPoiTypeEnum.SHOP_DISCOUNT:
+                                ivIcon.setImageResource( R.drawable.icon_map_marker_shop_discount );
+                                break;
+                            case MarkerPoiTypeEnum.FOURS_4S:
+                                ivIcon.setImageResource( R.drawable.icon_map_marker_4s );
+                                break;
+                            case MarkerPoiTypeEnum.FOURS_ROAD_WORK:
+                                ivIcon.setImageResource( R.drawable.icon_map_marker_road_work2 );
+                                break;
+                            case MarkerPoiTypeEnum.FOURS_BLOCK_UP:
+                                ivIcon.setImageResource( R.drawable.icon_map_marker_road_block_up2 );
+                                break;
+                            case MarkerPoiTypeEnum.FOURS_PONDING:
+                                ivIcon.setImageResource( R.drawable.icon_map_marker_pondingl2 );
+                                break;
+                            case MarkerPoiTypeEnum.FOURS_SHOP_FREE:
+                                ivIcon.setImageResource( R.drawable.icon_map_marker_shop );
+                                break;
+                            case MarkerPoiTypeEnum.FOURS_FOG:
+                                ivIcon.setImageResource( R.drawable.module_service_ic_rc_dark_frog2 );
+                                break;
+                            case MarkerPoiTypeEnum.FOURS_ICE:
+                                ivIcon.setImageResource( R.drawable.module_service_ic_rc_freeze2 );
+                                break;
+                            case MarkerPoiTypeEnum.FOURS_ACCIDENT:
+                                ivIcon.setImageResource( R.drawable.module_service_ic_rc_accident3 );
+                                break;
+                            case MarkerPoiTypeEnum.FOURS_NEALY:
+                                ivIcon.setImageResource( R.drawable.icon_map_marker_shear_news );
+                                break;
+                            case MarkerPoiTypeEnum.FOURS_LIVING:
+                                ivIcon.setImageResource( R.drawable.icon_map_marker_living );
+                                break;
+                            case MarkerPoiTypeEnum.ILLEGAL_PARK_LIVING:
+                                ivIcon.setImageResource( R.drawable.module_service_ic_rc_illegal_park );
+                                break;
+                            case MarkerPoiTypeEnum.ROAD_SLIPPERY:
+                                ivIcon.setImageResource( R.drawable.module_service_ic_rc_road_slippery );
+                                break;
+                            case MarkerPoiTypeEnum.FOURS_PARKING:
+                            default:
+                                ivIcon.setImageResource( R.drawable.icon_map_marker_road_block_up2 );
+                                break;
+                        }
+                    }
+                    break;
+            }
+
+        } catch ( Exception e ) {
+            e.printStackTrace();
+        }
+    }
+
+
+}

modules/mogo-module-common/src/main/java/com/mogo/module/common/drawer/marker/OnlineCarMarkerView.java

@@ -0,0 +1,93 @@
+package com.mogo.module.common.drawer.marker;
+
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.view.View;
+
+import com.mogo.commons.AbsMogoApplication;
+import com.mogo.map.marker.IMogoMarker;
+import com.mogo.module.common.R;
+
+import java.lang.ref.SoftReference;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author congtaowang
+ * @since 2020-04-30
+ * <p>
+ * 描述
+ */
+public class OnlineCarMarkerView implements IMarkerView {
+
+    private static Map< Integer, SoftReference< Bitmap > > sRef = new HashMap<>();
+    private static Map< Integer, SoftReference< Bitmap > > sTypedRef = new HashMap<>();
+
+    private OnlineCarMarkerView() {
+        // private constructor
+    }
+
+    private static final class InstanceHolder {
+        private static final OnlineCarMarkerView INSTANCE = new OnlineCarMarkerView();
+    }
+
+    public static OnlineCarMarkerView getInstance() {
+        return InstanceHolder.INSTANCE;
+    }
+
+    private Object readResolve() {
+        // 阻止反序列化，必须实现 Serializable 接口
+        return InstanceHolder.INSTANCE;
+    }
+
+    @Override
+    public View getView() {
+        return null;
+    }
+
+    @Override
+    public Bitmap getBitmap( int vehicleType ) {
+        if ( sRef.get( vehicleType ) == null || sRef.get( vehicleType ).get() == null
+                || sRef.get( vehicleType ).get().isRecycled() ) {
+            switch ( vehicleType ) {
+                case 5:
+                    sRef.put( vehicleType, new SoftReference<>( BitmapFactory.decodeResource( AbsMogoApplication.getApp().getResources(), R.drawable.icon_map_marker_car_type_taxi ) ) );
+                    break;
+                case 6:
+                    sRef.put( vehicleType, new SoftReference<>( BitmapFactory.decodeResource( AbsMogoApplication.getApp().getResources(), R.drawable.icon_map_marker_car_type_bus ) ) );
+                    break;
+                case 1:
+                    sRef.put( vehicleType, new SoftReference<>( BitmapFactory.decodeResource( AbsMogoApplication.getApp().getResources(), R.drawable.icon_map_marker_car_type_110 ) ) );
+                    break;
+                case 2:
+                    sRef.put( vehicleType, new SoftReference<>( BitmapFactory.decodeResource( AbsMogoApplication.getApp().getResources(), R.drawable.icon_map_marker_car_type_120 ) ) );
+                    break;
+                case 7:
+                    sRef.put( vehicleType, new SoftReference<>( BitmapFactory.decodeResource( AbsMogoApplication.getApp().getResources(), R.drawable.icon_map_marker_car_type_119 ) ) );
+                    break;
+                default:
+                    sRef.put( vehicleType, new SoftReference<>( BitmapFactory.decodeResource( AbsMogoApplication.getApp().getResources(), R.drawable.icon_map_marker_car_gray ) ) );
+            }
+        }
+        return sRef.get( vehicleType ).get();
+    }
+
+    public Bitmap getSelectedBitmap( int vehicleType ) {
+        if ( sTypedRef.get( vehicleType ) == null || sTypedRef.get( vehicleType ).get() == null
+                || sTypedRef.get( vehicleType ).get().isRecycled() ) {
+            switch ( vehicleType ) {
+                case 2:
+                    sTypedRef.put( vehicleType, new SoftReference<>( BitmapFactory.decodeResource( AbsMogoApplication.getApp().getResources(), R.drawable.icon_map_marker_car_type2 ) ) );
+                    break;
+                default:
+                    sTypedRef.put( vehicleType, new SoftReference<>( BitmapFactory.decodeResource( AbsMogoApplication.getApp().getResources(), R.drawable.icon_map_marker_car_gray_selected ) ) );
+            }
+        }
+        return sTypedRef.get( vehicleType ).get();
+    }
+
+    @Override
+    public void setMarker( IMogoMarker marker ) {
+
+    }
+}