[2.13.0-opt]remove service module and module-common

libraries/mogo-map-api/src/main/java/com/mogo/map/listener/IMogoMapListenerRegister.java

@@ -13,10 +13,10 @@ public interface IMogoMapListenerRegister {
      *
      * @param listener 回调事件
      */
-    void registerHostMapListener( IMogoMapListener listener );
+    void registerHostMapListener(String tag, IMogoMapListener listener );
 
     /**
      * 反注册注册地图事件
      */
-    void unregisterHostMapListener();
+    void unregisterHostMapListener(String tag);
 }

libraries/mogo-map-api/src/main/java/com/mogo/map/listener/MogoHosListenerRegister.java

@@ -33,23 +33,23 @@ public class MogoHosListenerRegister implements IMogoHosListenerRegister {
 
 
     @Override
-    public void registerHostMapListener( IMogoMapListener listener ) {
-        MogoMapListenerHandler.getInstance().registerHostMapListener( listener );
+    public void registerHostMapListener(String tag, IMogoMapListener listener ) {
+        MogoMapListenerHandler.Companion.getMogoMapListenerHandler().registerHostMapListener(tag, listener );
     }
 
     @Override
-    public void unregisterHostMapListener() {
-        MogoMapListenerHandler.getInstance().unregisterHostMapListener();
+    public void unregisterHostMapListener(String tag) {
+        MogoMapListenerHandler.Companion.getMogoMapListenerHandler().unregisterHostMapListener(tag);
     }
 
     @Override
-    public void registerMarkerClickListener( IMogoMarkerClickListener listener ) {
-        MogoMarkersHandler.getInstance().registerMarkerClickListener( listener );
+    public void registerMarkerClickListener( String tag,IMogoMarkerClickListener listener ) {
+        MogoMarkersHandler.Companion.getMogoMarkersHandler().registerMarkerClickListener(tag, listener );
     }
 
     @Override
-    public void unregisterMarkerClickListener() {
-        MogoMarkersHandler.getInstance().unregisterMarkerClickListener();
+    public void unregisterMarkerClickListener(String tag) {
+        MogoMarkersHandler.Companion.getMogoMarkersHandler().unregisterMarkerClickListener(tag);
     }
 
 }

libraries/mogo-map-api/src/main/java/com/mogo/map/listener/MogoMapListenerHandler.java

@@ -1,108 +0,0 @@
-package com.mogo.map.listener;
-
-import android.view.MotionEvent;
-
-import com.mogo.eagle.core.data.map.MogoLatLng;
-import com.mogo.map.model.MogoPoi;
-import com.mogo.map.uicontroller.EnumMapUI;
-import com.mogo.map.uicontroller.VisualAngleMode;
-
-/**
- * @author congtaowang
- * @since 2019-12-24
- * <p>
- * 地图监听注册管理
- */
-public class MogoMapListenerHandler implements IMogoMapListener, IMogoMapListenerRegister {
-
-    private static volatile MogoMapListenerHandler sInstance;
-
-    private MogoMapListenerHandler() {
-    }
-
-    public static MogoMapListenerHandler getInstance() {
-        if (sInstance == null) {
-            synchronized (MogoMapListenerHandler.class) {
-                if (sInstance == null) {
-                    sInstance = new MogoMapListenerHandler();
-                }
-            }
-        }
-        return sInstance;
-    }
-
-    public synchronized void release() {
-        sInstance = null;
-    }
-
-    /**
-     * 上层模块代理对象
-     */
-    private IMogoMapListener mDelegateListener = null;
-
-    @Override
-    public void registerHostMapListener(IMogoMapListener listener) {
-        mDelegateListener = listener;
-    }
-
-    @Override
-    public void unregisterHostMapListener() {
-        mDelegateListener = null;
-    }
-
-    @Override
-    public void onMapLoaded() {
-        if (mDelegateListener != null) {
-            mDelegateListener.onMapLoaded();
-        }
-    }
-
-    @Override
-    public void onTouch(MotionEvent motionEvent) {
-        if (mDelegateListener != null) {
-            mDelegateListener.onTouch(motionEvent);
-        }
-    }
-
-    @Override
-    public void onPOIClick(MogoPoi poi) {
-        if (mDelegateListener != null) {
-            mDelegateListener.onPOIClick(poi);
-        }
-    }
-
-    @Override
-    public void onMapClick(MogoLatLng latLng) {
-        if (mDelegateListener != null) {
-            mDelegateListener.onMapClick(latLng);
-        }
-    }
-
-    @Override
-    public void onLockMap(boolean isLock) {
-        if (mDelegateListener != null) {
-            mDelegateListener.onLockMap(isLock);
-        }
-    }
-
-    @Override
-    public void onMapModeChanged(EnumMapUI ui) {
-        if (mDelegateListener != null) {
-            mDelegateListener.onMapModeChanged(ui);
-        }
-    }
-
-    @Override
-    public void onMapVisualAngleChanged(VisualAngleMode visualAngleMode) {
-        if (mDelegateListener != null) {
-            mDelegateListener.onMapVisualAngleChanged(visualAngleMode);
-        }
-    }
-
-    @Override
-    public void onMapChanged(MogoLatLng location, float zoom, float tilt, float bearing) {
-        if (mDelegateListener != null) {
-            mDelegateListener.onMapChanged(location, zoom, tilt, bearing);
-        }
-    }
-}

libraries/mogo-map-api/src/main/java/com/mogo/map/listener/MogoMapListenerHandler.kt

@@ -0,0 +1,93 @@
+package com.mogo.map.listener
+
+import android.view.MotionEvent
+import com.mogo.eagle.core.data.map.MogoLatLng
+import com.mogo.map.model.MogoPoi
+import com.mogo.map.uicontroller.EnumMapUI
+import com.mogo.map.uicontroller.VisualAngleMode
+import java.util.concurrent.ConcurrentHashMap
+
+/**
+ * 地图监听注册管理
+ */
+class MogoMapListenerHandler private constructor() : IMogoMapListener, IMogoMapListenerRegister {
+
+    companion object {
+        val mogoMapListenerHandler by lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
+            MogoMapListenerHandler()
+        }
+    }
+
+    private val mMap: ConcurrentHashMap<String, IMogoMapListener> = ConcurrentHashMap()
+
+    override fun registerHostMapListener(tag: String, listener: IMogoMapListener) {
+        if (mMap.containsKey(tag)) {
+            return
+        }
+        mMap[tag] = listener
+    }
+
+    override fun unregisterHostMapListener(tag: String) {
+        if (!mMap.containsKey(tag)) {
+            return
+        }
+        mMap.remove(tag)
+    }
+
+    override fun onMapLoaded() {
+        mMap.forEach {
+            val listener = it.value
+            listener.onMapLoaded()
+        }
+    }
+
+    override fun onTouch(motionEvent: MotionEvent) {
+        mMap.forEach {
+            val listener = it.value
+            listener.onTouch(motionEvent)
+        }
+    }
+
+    override fun onPOIClick(poi: MogoPoi) {
+        mMap.forEach {
+            val listener = it.value
+            listener.onPOIClick(poi)
+        }
+    }
+
+    override fun onMapClick(latLng: MogoLatLng) {
+        mMap.forEach {
+            val listener = it.value
+            listener.onMapClick(latLng)
+        }
+    }
+
+    override fun onLockMap(isLock: Boolean) {
+        mMap.forEach {
+            val listener = it.value
+            listener.onLockMap(isLock)
+        }
+    }
+
+    override fun onMapModeChanged(ui: EnumMapUI) {
+        mMap.forEach {
+            val listener = it.value
+            listener.onMapModeChanged(ui)
+        }
+    }
+
+    override fun onMapVisualAngleChanged(visualAngleMode: VisualAngleMode) {
+        mMap.forEach {
+            val listener = it.value
+            listener.onMapVisualAngleChanged(visualAngleMode)
+        }
+    }
+
+    override fun onMapChanged(location: MogoLatLng, zoom: Float, tilt: Float, bearing: Float) {
+        mMap.forEach {
+            val listener = it.value
+            listener.onMapChanged(location, zoom, tilt, bearing)
+        }
+    }
+
+}

libraries/mogo-map-api/src/main/java/com/mogo/map/marker/IMogoMarkerClickListenerRegister.java

@@ -13,11 +13,11 @@ public interface IMogoMarkerClickListenerRegister {
      *
      * @param listener
      */
-    void registerMarkerClickListener( IMogoMarkerClickListener listener );
+    void registerMarkerClickListener(String tag, IMogoMarkerClickListener listener );
 
 
     /**
      * 注销marker回调，各业务模块不需要关注
      */
-    void unregisterMarkerClickListener();
+    void unregisterMarkerClickListener(String tag);
 }

libraries/mogo-map-api/src/main/java/com/mogo/map/marker/MogoMarkersHandler.java

@@ -1,183 +0,0 @@
-package com.mogo.map.marker;
-
-import android.annotation.SuppressLint;
-import android.os.Build;
-import android.text.TextUtils;
-
-import androidx.annotation.RequiresApi;
-
-import com.mogo.map.listener.IMogoMapListener;
-import com.mogo.map.listener.IMogoMapListenerRegister;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-
-/**
- * @author congtaowang
- * @since 2019-12-24
- * <p>
- * 管理地图上的所有marker
- */
-public class MogoMarkersHandler implements IMogoMarkerClickListener, IMogoMarkerClickListenerRegister {
-
-    private static volatile MogoMarkersHandler sInstance;
-    private IMogoMarkerClickListener mDelegate;
-
-    public static MogoMarkersHandler getInstance() {
-        if (sInstance == null) {
-            synchronized (MogoMarkersHandler.class) {
-                if (sInstance == null) {
-                    sInstance = new MogoMarkersHandler();
-                }
-            }
-        }
-        return sInstance;
-    }
-
-    private final Map<String, List<IMogoMarker>> mServicesMarkers = new ConcurrentHashMap<>();
-
-    private MogoMarkersHandler() {
-    }
-
-    public synchronized void release() {
-        sInstance = null;
-    }
-
-    @SuppressLint("NewApi")
-    public synchronized void visibleAll() {
-        mServicesMarkers.values().stream()
-                .filter(mogoMarkerList -> mogoMarkerList != null && !mogoMarkerList.isEmpty())
-                .forEach(mogoMarkerList -> mogoMarkerList.forEach(mogoMarker -> mogoMarker.setVisible(true)));
-    }
-
-    @SuppressLint("NewApi")
-    public synchronized void inVisibleAll() {
-        mServicesMarkers.values().stream()
-                .filter(mogoMarkerList -> mogoMarkerList != null && !mogoMarkerList.isEmpty())
-                .forEach(mogoMarkerList -> mogoMarkerList.forEach(mogoMarker -> mogoMarker.setVisible(false)));
-    }
-
-    @SuppressLint("NewApi")
-    public synchronized void inVisibleMarkers(String... owner) {
-        mServicesMarkers.values().stream()
-                .filter(mogoMarkerList -> mogoMarkerList != null && !mogoMarkerList.isEmpty())
-                .forEach(mogoMarkerList -> mogoMarkerList.forEach(mogoMarker -> {
-                    if (TextUtils.isEmpty(mogoMarker.getOwner())) {
-                        mogoMarker.setVisible(false);
-                    }
-                    if (!Arrays.asList(owner).contains(mogoMarker.getOwner())){
-                        mogoMarker.setVisible(false);
-                    }
-                }));
-    }
-
-    public synchronized void removeAll() {
-        final Collection<List<IMogoMarker>> mogoMarkers = mServicesMarkers.values();
-        for (List<IMogoMarker> mogoMarkerList : mogoMarkers) {
-            if (mogoMarkerList != null && !mogoMarkerList.isEmpty()) {
-                for (IMogoMarker mogoMarker : mogoMarkerList) {
-                    try {
-                        mogoMarker.destroy();
-                    } catch (Exception e) {
-                        e.printStackTrace();
-                    }
-                }
-            }
-        }
-        mServicesMarkers.clear();
-    }
-
-    public synchronized void remove(String tag) {
-        List<IMogoMarker> mogoMarkerList = mServicesMarkers.remove(tag);
-        if (mogoMarkerList != null && !mogoMarkerList.isEmpty()) {
-            for (IMogoMarker mogoMarker : mogoMarkerList) {
-                try {
-                    mogoMarker.destroy();
-                } catch (Exception e) {
-                    e.printStackTrace();
-                }
-            }
-            mogoMarkerList.clear();
-        }
-    }
-
-    public synchronized List<IMogoMarker> getMarkers(String tag) {
-        return mServicesMarkers.get(tag);
-    }
-
-
-    public synchronized Map<String, List<IMogoMarker>> getAllMarkers() {
-        return mServicesMarkers;
-    }
-
-
-    public synchronized void add(String tag, IMogoMarker marker) {
-        if (marker == null) {
-            return;
-        }
-        if (mServicesMarkers.get(tag) == null) {
-            mServicesMarkers.put(tag, new ArrayList<IMogoMarker>());
-        }
-        mServicesMarkers.get(tag).add(marker);
-    }
-
-    public synchronized void add(String tag, List<IMogoMarker> markers) {
-        if (markers == null || markers.isEmpty()) {
-            return;
-        }
-        if (mServicesMarkers.get(tag) == null) {
-            mServicesMarkers.put(tag, new ArrayList<IMogoMarker>());
-        }
-        mServicesMarkers.get(tag).addAll(markers);
-    }
-
-    @Override
-    public void registerMarkerClickListener(IMogoMarkerClickListener listener) {
-        mDelegate = listener;
-    }
-
-    @Override
-    public void unregisterMarkerClickListener() {
-        mDelegate = null;
-    }
-
-    @Override
-    public boolean onMarkerClicked(IMogoMarker marker) {
-        if (mDelegate != null) {
-            return mDelegate.onMarkerClicked(marker);
-        }
-        return false;
-    }
-
-    @Override
-    public boolean onStaticMarkerClicked(IMogoMarker marker) {
-        if (mDelegate != null) {
-            return mDelegate.onStaticMarkerClicked(marker);
-        }
-        return false;
-    }
-
-    /**
-     * @param tag 需要保留的类型
-     */
-    public void deleteAllExcept(String tag) {
-        if (TextUtils.isEmpty(tag)) {
-            return;
-        }
-        List<IMogoMarker> mogoMarkerList = mServicesMarkers.remove(tag);
-        for (List<IMogoMarker> value : mServicesMarkers.values()) {
-            if (value != null && !value.isEmpty()) {
-                for (IMogoMarker mogoMarker : value) {
-                    mogoMarker.destroy();
-                }
-                value.clear();
-            }
-        }
-        mServicesMarkers.put(tag, mogoMarkerList);
-    }
-}

libraries/mogo-map-api/src/main/java/com/mogo/map/marker/MogoMarkersHandler.kt

@@ -0,0 +1,176 @@
+package com.mogo.map.marker
+
+import android.annotation.SuppressLint
+import android.text.TextUtils
+import java.util.*
+import java.util.concurrent.ConcurrentHashMap
+import java.util.function.Consumer
+
+/**
+ * @author congtaowang
+ * @since 2019-12-24
+ *
+ *
+ * 管理地图上的所有marker
+ */
+class MogoMarkersHandler private constructor() : IMogoMarkerClickListener,
+    IMogoMarkerClickListenerRegister {
+
+    companion object {
+        val mogoMarkersHandler by lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
+            MogoMarkersHandler()
+        }
+    }
+
+    private val mMap: ConcurrentHashMap<String, IMogoMarkerClickListener> = ConcurrentHashMap()
+    private val mServicesMarkers: MutableMap<String, MutableList<IMogoMarker>?> =
+        ConcurrentHashMap()
+
+    override fun registerMarkerClickListener(tag: String, listener: IMogoMarkerClickListener) {
+        if (mMap.containsKey(tag)) {
+            return
+        }
+        mMap[tag] = listener
+    }
+
+    override fun unregisterMarkerClickListener(tag: String) {
+        if (!mMap.containsKey(tag)) {
+            return
+        }
+        mMap.remove(tag)
+    }
+
+    @SuppressLint("NewApi")
+    @Synchronized
+    fun visibleAll() {
+        mServicesMarkers.values.stream()
+            .filter { mogoMarkerList: List<IMogoMarker>? -> mogoMarkerList != null && !mogoMarkerList.isEmpty() }
+            .forEach { mogoMarkerList: List<IMogoMarker>? ->
+                mogoMarkerList!!.forEach(
+                    Consumer { mogoMarker: IMogoMarker -> mogoMarker.setVisible(true) })
+            }
+    }
+
+    @SuppressLint("NewApi")
+    @Synchronized
+    fun inVisibleAll() {
+        mServicesMarkers.values.stream()
+            .filter { mogoMarkerList: List<IMogoMarker>? -> mogoMarkerList != null && !mogoMarkerList.isEmpty() }
+            .forEach { mogoMarkerList: List<IMogoMarker>? ->
+                mogoMarkerList!!.forEach(
+                    Consumer { mogoMarker: IMogoMarker -> mogoMarker.setVisible(false) })
+            }
+    }
+
+    @SuppressLint("NewApi")
+    @Synchronized
+    fun inVisibleMarkers(vararg owner: String?) {
+        mServicesMarkers.values.stream()
+            .filter { mogoMarkerList: List<IMogoMarker>? -> mogoMarkerList != null && !mogoMarkerList.isEmpty() }
+            .forEach { mogoMarkerList: List<IMogoMarker>? ->
+                mogoMarkerList!!.forEach(
+                    Consumer { mogoMarker: IMogoMarker ->
+                        if (TextUtils.isEmpty(mogoMarker.owner)) {
+                            mogoMarker.setVisible(false)
+                        }
+                        if (!Arrays.asList(*owner).contains(mogoMarker.owner)) {
+                            mogoMarker.setVisible(false)
+                        }
+                    })
+            }
+    }
+
+    @Synchronized
+    fun removeAll() {
+        val mogoMarkers: Collection<List<IMogoMarker>?> = mServicesMarkers.values
+        for (mogoMarkerList in mogoMarkers) {
+            if (mogoMarkerList != null && !mogoMarkerList.isEmpty()) {
+                for (mogoMarker in mogoMarkerList) {
+                    try {
+                        mogoMarker.destroy()
+                    } catch (e: Exception) {
+                        e.printStackTrace()
+                    }
+                }
+            }
+        }
+        mServicesMarkers.clear()
+    }
+
+    @Synchronized
+    fun remove(tag: String) {
+        val mogoMarkerList = mServicesMarkers.remove(tag)
+        if (mogoMarkerList != null && !mogoMarkerList.isEmpty()) {
+            for (mogoMarker in mogoMarkerList) {
+                try {
+                    mogoMarker.destroy()
+                } catch (e: Exception) {
+                    e.printStackTrace()
+                }
+            }
+            mogoMarkerList.clear()
+        }
+    }
+
+    @Synchronized
+    fun getMarkers(tag: String): List<IMogoMarker>? {
+        return mServicesMarkers[tag]
+    }
+
+    @get:Synchronized
+    val allMarkers: Map<String, MutableList<IMogoMarker>?>
+        get() = mServicesMarkers
+
+    @Synchronized
+    fun add(tag: String, marker: IMogoMarker?) {
+        if (marker == null) {
+            return
+        }
+        if (mServicesMarkers[tag] == null) {
+            mServicesMarkers[tag] = ArrayList()
+        }
+        mServicesMarkers[tag]!!.add(marker)
+    }
+
+    @Synchronized
+    fun add(tag: String, markers: List<IMogoMarker>?) {
+        if (markers == null || markers.isEmpty()) {
+            return
+        }
+        if (mServicesMarkers[tag] == null) {
+            mServicesMarkers[tag] = ArrayList()
+        }
+        mServicesMarkers[tag]!!.addAll(markers)
+    }
+
+    override fun onMarkerClicked(marker: IMogoMarker): Boolean {
+        val iMogoMarker = mMap[marker.owner]
+        return iMogoMarker?.onMarkerClicked(marker) ?: false
+    }
+
+    override fun onStaticMarkerClicked(marker: IMogoMarker): Boolean {
+        val iMogoMarker = mMap[marker.owner]
+        return iMogoMarker?.onStaticMarkerClicked(marker) ?: false
+    }
+
+    /**
+     * @param tag 需要保留的类型
+     */
+    fun deleteAllExcept(tag: String) {
+        if (TextUtils.isEmpty(tag)) {
+            return
+        }
+        val mogoMarkerList = mServicesMarkers.remove(tag)
+        for (value in mServicesMarkers.values) {
+            if (value != null && value.isNotEmpty()) {
+                for (mogoMarker in value) {
+                    mogoMarker.destroy()
+                }
+                value.clear()
+            }
+        }
+        mServicesMarkers[tag] = mogoMarkerList
+    }
+
+
+}