react-native-gizwits-baidu-map 1.0.72

package/android/src/main/java/org/lovebing/reactnative/baidumap/module/MapAppModule.java

@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 2016-present, lovebing.net.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package org.lovebing.reactnative.baidumap.module;
+
+import android.content.Context;
+import com.baidu.mapapi.utils.route.BaiduMapRoutePlan;
+import com.baidu.mapapi.utils.route.RouteParaOption;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import org.lovebing.reactnative.baidumap.util.LatLngUtil;
+import com.baidu.mapapi.navi.BaiduMapAppNotSupportNaviException;
+import com.baidu.mapapi.navi.BaiduMapNavigation;
+import com.baidu.mapapi.navi.NaviParaOption;
+import com.baidu.mapapi.utils.poi.BaiduMapPoiSearch;
+import com.baidu.mapapi.utils.poi.PoiParaOption;
+
+/**
+ * @author lovebing Created on Dec 09, 2018
+ */
+public class MapAppModule extends BaseModule {
+
+    private static final String KEY_NAME = "name";
+
+    private Context context;
+
+    public MapAppModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        context = reactContext;
+    }
+
+    @Override
+    public String getName() {
+        return "BaiduMapAppModule";
+    }
+
+    @ReactMethod
+    public void openDrivingRoute(ReadableMap startPoint, ReadableMap endPoint) {
+        RouteParaOption paraOption = createRouteParaOption(startPoint, endPoint);
+        try {
+            BaiduMapRoutePlan.openBaiduMapDrivingRoute(paraOption, context);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        BaiduMapRoutePlan.finish(context);
+    }
+
+    @ReactMethod
+    public void openTransitRoute(ReadableMap startPoint, ReadableMap endPoint) {
+        RouteParaOption paraOption = createRouteParaOption(startPoint, endPoint);
+        try {
+            BaiduMapRoutePlan.openBaiduMapTransitRoute(paraOption, context);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        BaiduMapRoutePlan.finish(context);
+    }
+
+    @ReactMethod
+    public void openWalkNavi(ReadableMap startPoint, ReadableMap endPoint) {
+        NaviParaOption para = new NaviParaOption()
+                .startPoint(LatLngUtil.fromReadableMap(startPoint))
+                .endPoint(LatLngUtil.fromReadableMap(endPoint))
+                .startName(startPoint.getString("name"))
+                .endName(endPoint.getString("name"));
+        try {
+            BaiduMapNavigation.openBaiduMapWalkNavi(para, context);
+        } catch (BaiduMapAppNotSupportNaviException e) {
+            e.printStackTrace();
+        }
+        BaiduMapNavigation.finish(context);
+    }
+
+    @ReactMethod
+    public void openPoiNearbySearch(ReadableMap options) {
+        PoiParaOption para = new PoiParaOption()
+                .key(options.getString("key"))
+                .center(LatLngUtil.fromReadableMap(options))
+                .radius(options.getInt("radius"));
+        try {
+            BaiduMapPoiSearch.openBaiduMapPoiNearbySearch(para, context);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        BaiduMapPoiSearch.finish(context);
+    }
+
+    @ReactMethod
+    public void openPoiDetialsPage(String uid) {
+        PoiParaOption para = new PoiParaOption().uid(uid);
+        try {
+            BaiduMapPoiSearch.openBaiduMapPoiDetialsPage(para, context);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        BaiduMapPoiSearch.finish(context);
+    }
+
+    @ReactMethod
+    public void openPanoShow(String uid) {
+        try {
+            BaiduMapPoiSearch.openBaiduMapPanoShow(uid, context);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        BaiduMapPoiSearch.finish(context);
+    }
+
+    private RouteParaOption createRouteParaOption(ReadableMap startPoint, ReadableMap endPoint) {
+        RouteParaOption paraOption = new RouteParaOption()
+                .startPoint(LatLngUtil.fromReadableMap(startPoint))
+                .endPoint(LatLngUtil.fromReadableMap(endPoint))
+                .busStrategyType(RouteParaOption.EBusStrategyType.bus_recommend_way);
+        if (startPoint.hasKey(KEY_NAME)) {
+            paraOption.startName(startPoint.getString(KEY_NAME));
+        }
+        if (endPoint.hasKey(KEY_NAME)) {
+            paraOption.endName(endPoint.getString(KEY_NAME));
+        }
+        return paraOption;
+    }
+}

package/android/src/main/java/org/lovebing/reactnative/baidumap/module/PoiSearchModule.java

@@ -0,0 +1,147 @@
+package org.lovebing.reactnative.baidumap.module;
+
+import android.widget.Toast;
+
+import androidx.annotation.NonNull;
+
+import com.baidu.mapapi.model.LatLng;
+import com.baidu.mapapi.search.core.PoiInfo;
+import com.baidu.mapapi.search.core.SearchResult;
+import com.baidu.mapapi.search.poi.OnGetPoiSearchResultListener;
+import com.baidu.mapapi.search.poi.PoiCitySearchOption;
+import com.baidu.mapapi.search.poi.PoiDetailResult;
+import com.baidu.mapapi.search.poi.PoiDetailSearchResult;
+import com.baidu.mapapi.search.poi.PoiIndoorResult;
+import com.baidu.mapapi.search.poi.PoiNearbySearchOption;
+import com.baidu.mapapi.search.poi.PoiResult;
+import com.baidu.mapapi.search.poi.PoiSearch;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+
+import org.lovebing.reactnative.baidumap.util.LatLngUtil;
+
+import java.util.List;
+
+/**
+ * 提示POI搜索
+ */
+public class PoiSearchModule extends BaseModule implements OnGetPoiSearchResultListener {
+    private PoiSearch mPoiSearch = null;
+
+    public PoiSearchModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        context = reactContext;
+
+    }
+
+    public void initPoiSearch() {
+        // 初始化建议搜索模块，注册建议搜索事件监听
+        mPoiSearch = PoiSearch.newInstance();
+        mPoiSearch.setOnGetPoiSearchResultListener(this);
+    }
+
+    @NonNull
+    @Override
+    public String getName() {
+        return "PoiSearchModule";
+    }
+
+    @ReactMethod
+    public void searchInCity(String cityStr, String keyWordStr, int pageIndex,int pageSize, boolean cityLimit, int scope) {
+        if (mPoiSearch == null) {
+            initPoiSearch();
+        }
+        // 发起请求
+        mPoiSearch.searchInCity((new PoiCitySearchOption())
+                .city(cityStr)
+                .keyword(keyWordStr)
+                .pageNum(pageIndex) // 分页编号
+                .pageCapacity(pageSize)
+                .cityLimit(cityLimit)
+                .scope(scope));
+    }
+
+    @ReactMethod
+    public void searchNearby(String keyWordStr, ReadableMap location, int radius, int pageIndex,int pageSize, boolean cityLimit, int scope) {
+        if (mPoiSearch == null) {
+            initPoiSearch();
+        }
+        LatLng latLng = LatLngUtil.fromReadableMap(location);
+        // 配置请求参数
+        PoiNearbySearchOption nearbySearchOption = new PoiNearbySearchOption()
+                .keyword(keyWordStr) // 检索关键字
+                .location(latLng) // 经纬度
+                .radius(radius) // 检索半径 单位： m
+                .pageNum(pageIndex) // 分页编号
+                .pageCapacity(pageSize)
+                .radiusLimit(cityLimit)
+                .scope(scope);
+        // 发起检索
+        mPoiSearch.searchNearby(nearbySearchOption);
+    }
+
+
+    @Override
+    public void onCatalystInstanceDestroy() {
+        super.onCatalystInstanceDestroy();
+        if (mPoiSearch != null) {
+            mPoiSearch.destroy();
+            mPoiSearch = null;
+        }
+    }
+
+    @Override
+    public void onGetPoiResult(PoiResult poiResult) {
+        if (poiResult == null || poiResult.error == SearchResult.ERRORNO.RESULT_NOT_FOUND) {
+            Toast.makeText(context, "未找到结果", Toast.LENGTH_LONG).show();
+            return;
+        }
+        WritableMap params = Arguments.createMap();
+        params.putString("error", String.valueOf(poiResult.error));
+        params.putInt("status", poiResult.status);
+
+        if (poiResult.error == SearchResult.ERRORNO.NO_ERROR) {
+            WritableArray writableArray = Arguments.createArray();
+            List<PoiInfo> allPoi = poiResult.getAllPoi();
+            if (allPoi != null)
+                for (PoiInfo poiInfo : allPoi) {
+                    WritableMap item = Arguments.createMap();
+                    item.putString("name",poiInfo.name);
+                    item.putString("uid",poiInfo.uid);
+                    item.putString("address",poiInfo.address);
+                    item.putString("province",poiInfo.province);
+                    item.putString("city",poiInfo.city);
+                    item.putString("area",poiInfo.area);
+                    item.putString("street_id",poiInfo.street_id);
+                    item.putString("phoneNum",poiInfo.phoneNum);
+                    item.putString("postCode",poiInfo.postCode);
+                    if (poiInfo.location != null) {
+                        item.putDouble("latitude", poiInfo.location.latitude);
+                        item.putDouble("longitude", poiInfo.location.longitude);
+                    }
+                    item.putString("tag",poiInfo.tag);
+                    writableArray.pushMap(item);
+                }
+            params.putArray("allPoi", writableArray);
+        }
+        sendEvent("onGetPoiResult", params);
+    }
+
+    @Override
+    public void onGetPoiDetailResult(PoiDetailResult poiDetailResult) {
+    }
+
+    @Override
+    public void onGetPoiDetailResult(PoiDetailSearchResult poiDetailSearchResult) {
+
+    }
+
+    @Override
+    public void onGetPoiIndoorResult(PoiIndoorResult poiIndoorResult) {
+
+    }
+}

package/android/src/main/java/org/lovebing/reactnative/baidumap/module/PoiSugSearchModule.java

@@ -0,0 +1,111 @@
+package org.lovebing.reactnative.baidumap.module;
+
+import androidx.annotation.NonNull;
+
+import com.baidu.mapapi.model.LatLng;
+import com.baidu.mapapi.search.core.PoiChildrenInfo;
+import com.baidu.mapapi.search.sug.OnGetSuggestionResultListener;
+import com.baidu.mapapi.search.sug.SuggestionResult;
+import com.baidu.mapapi.search.sug.SuggestionSearch;
+import com.baidu.mapapi.search.sug.SuggestionSearchOption;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeArray;
+
+import java.util.List;
+
+/**
+ * 提示POI搜索
+ */
+public class PoiSugSearchModule extends BaseModule implements OnGetSuggestionResultListener {
+    private SuggestionSearch mSuggestionSearch = null;
+
+    public PoiSugSearchModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        context = reactContext;
+
+    }
+
+    public void initSuggestionSearch() {
+        // 初始化建议搜索模块，注册建议搜索事件监听
+        mSuggestionSearch = SuggestionSearch.newInstance();
+        mSuggestionSearch.setOnGetSuggestionResultListener(this);
+    }
+
+    @NonNull
+    @Override
+    public String getName() {
+        return "PoiSugSearchModule";
+    }
+
+    @ReactMethod
+    public void requestSuggestion(String keyword, String city, boolean cityLimit) {
+        if (mSuggestionSearch == null) {
+            initSuggestionSearch();
+        }
+        // 使用建议搜索服务获取建议列表，结果在onSuggestionResult()中更新
+        mSuggestionSearch.requestSuggestion((new SuggestionSearchOption())
+                .keyword(keyword) // 关键字
+                .city(city) //城市
+                .citylimit(cityLimit)); //是否限制Sug检索区域在city内
+    }
+
+    @Override
+    public void onGetSuggestionResult(SuggestionResult suggestionResult) {
+        if (suggestionResult == null || suggestionResult.getAllSuggestions() == null) {
+            return;
+        }
+        List<SuggestionResult.SuggestionInfo> suggestionResults = suggestionResult.getAllSuggestions();
+        WritableMap params = Arguments.createMap();
+        params.putString("error", String.valueOf(suggestionResult.error));
+        params.putInt("status", suggestionResult.status);
+        WritableArray writableArray = Arguments.createArray();
+        for (SuggestionResult.SuggestionInfo result : suggestionResults) {
+            WritableMap item = Arguments.createMap();
+            item.putInt("adCode", result.getAdCode());
+            item.putString("address", result.address);
+            item.putString("city", result.city);
+            item.putString("district", result.district);
+            item.putString("key", result.key);
+            if (result.pt != null) {
+                item.putDouble("latitude", result.pt.latitude);
+                item.putDouble("longitude", result.pt.longitude);
+            }
+            item.putString("tag", result.tag);
+            item.putString("uid", result.uid);
+            WritableArray itemArray = Arguments.createArray();
+            List<PoiChildrenInfo> poiChildrenInfoList = result.poiChildrenInfoList;
+            if (poiChildrenInfoList != null)
+                for (PoiChildrenInfo poiChildrenInfo : poiChildrenInfoList) {
+                    WritableMap childrenMap = Arguments.createMap();
+                    childrenMap.putString("uid", poiChildrenInfo.getUid());
+                    childrenMap.putString("address", poiChildrenInfo.getAddress());
+                    childrenMap.putString("name", poiChildrenInfo.getName());
+                    childrenMap.putString("showName", poiChildrenInfo.getShowName());
+                    childrenMap.putString("tag", poiChildrenInfo.getTag());
+                    if (poiChildrenInfo.getLocation() != null) {
+                        childrenMap.putDouble("latitude", poiChildrenInfo.getLocation().latitude);
+                        childrenMap.putDouble("longitude", poiChildrenInfo.getLocation().longitude);
+                    }
+                    itemArray.pushMap(childrenMap);
+                }
+            item.putArray("poiChildrenInfoList", itemArray);
+            writableArray.pushMap(item);
+        }
+        params.putArray("data", writableArray);
+        sendEvent("onGetSuggestionResult", params);
+
+    }
+
+    @Override
+    public void onCatalystInstanceDestroy() {
+        super.onCatalystInstanceDestroy();
+        if (mSuggestionSearch != null) {
+            mSuggestionSearch.destroy();
+            mSuggestionSearch = null;
+        }
+    }
+}

package/android/src/main/java/org/lovebing/reactnative/baidumap/module/RoutePlanSearchModule.java

@@ -0,0 +1,175 @@
+package org.lovebing.reactnative.baidumap.module;
+
+import android.widget.Toast;
+
+import androidx.annotation.NonNull;
+
+import com.baidu.mapapi.model.LatLng;
+import com.baidu.mapapi.search.core.PoiInfo;
+import com.baidu.mapapi.search.core.SearchResult;
+import com.baidu.mapapi.search.poi.OnGetPoiSearchResultListener;
+import com.baidu.mapapi.search.poi.PoiCitySearchOption;
+import com.baidu.mapapi.search.poi.PoiDetailResult;
+import com.baidu.mapapi.search.poi.PoiDetailSearchResult;
+import com.baidu.mapapi.search.poi.PoiIndoorResult;
+import com.baidu.mapapi.search.poi.PoiNearbySearchOption;
+import com.baidu.mapapi.search.poi.PoiResult;
+import com.baidu.mapapi.search.poi.PoiSearch;
+import com.baidu.mapapi.search.route.BikingRouteResult;
+import com.baidu.mapapi.search.route.DrivingRouteLine;
+import com.baidu.mapapi.search.route.DrivingRoutePlanOption;
+import com.baidu.mapapi.search.route.DrivingRouteResult;
+import com.baidu.mapapi.search.route.IndoorRouteResult;
+import com.baidu.mapapi.search.route.MassTransitRouteResult;
+import com.baidu.mapapi.search.route.OnGetRoutePlanResultListener;
+import com.baidu.mapapi.search.route.PlanNode;
+import com.baidu.mapapi.search.route.RoutePlanSearch;
+import com.baidu.mapapi.search.route.TransitRouteResult;
+import com.baidu.mapapi.search.route.WalkingRouteResult;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+
+import org.lovebing.reactnative.baidumap.util.LatLngUtil;
+
+import java.util.List;
+
+/**
+ * 提示POI搜索
+ */
+public class RoutePlanSearchModule extends BaseModule implements OnGetRoutePlanResultListener {
+    private RoutePlanSearch mSearch = null;
+
+    public RoutePlanSearchModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        context = reactContext;
+
+    }
+
+    public void initRoutePlanSearch() {
+        // 初始化建议搜索模块，注册建议搜索事件监听
+        mSearch = RoutePlanSearch.newInstance();
+        mSearch.setOnGetRoutePlanResultListener(this);
+    }
+
+    @NonNull
+    @Override
+    public String getName() {
+        return "RoutePlanSearchModule";
+    }
+
+    @ReactMethod
+    public void drivingSearch(ReadableMap from, ReadableMap to) {
+        if (mSearch == null) {
+            initRoutePlanSearch();
+        }
+        PlanNode fromNode = PlanNode.withLocation(LatLngUtil.fromReadableMap(from));
+        PlanNode toNode = PlanNode.withLocation(LatLngUtil.fromReadableMap(to));
+        mSearch.drivingSearch(new DrivingRoutePlanOption()
+                .from(fromNode)
+                .to(toNode));
+    }
+
+
+    @Override
+    public void onCatalystInstanceDestroy() {
+        super.onCatalystInstanceDestroy();
+        if (mSearch != null) {
+            mSearch.destroy();
+            mSearch = null;
+        }
+    }
+
+//    @Override
+//    public void onGetPoiResult(PoiResult poiResult) {
+//        if (poiResult == null || poiResult.error == SearchResult.ERRORNO.RESULT_NOT_FOUND) {
+//            Toast.makeText(context, "未找到结果", Toast.LENGTH_LONG).show();
+//            return;
+//        }
+//        WritableMap params = Arguments.createMap();
+//        params.putString("error", String.valueOf(poiResult.error));
+//        params.putInt("status", poiResult.status);
+//
+//        if (poiResult.error == SearchResult.ERRORNO.NO_ERROR) {
+//            WritableArray writableArray = Arguments.createArray();
+//            List<PoiInfo> allPoi = poiResult.getAllPoi();
+//            if (allPoi != null)
+//                for (PoiInfo poiInfo : allPoi) {
+//                    WritableMap item = Arguments.createMap();
+//                    item.putString("name",poiInfo.name);
+//                    item.putString("uid",poiInfo.uid);
+//                    item.putString("address",poiInfo.address);
+//                    item.putString("province",poiInfo.province);
+//                    item.putString("city",poiInfo.city);
+//                    item.putString("area",poiInfo.area);
+//                    item.putString("street_id",poiInfo.street_id);
+//                    item.putString("phoneNum",poiInfo.phoneNum);
+//                    item.putString("postCode",poiInfo.postCode);
+//                    if (poiInfo.location != null) {
+//                        item.putDouble("latitude", poiInfo.location.latitude);
+//                        item.putDouble("longitude", poiInfo.location.longitude);
+//                    }
+//                    item.putString("tag",poiInfo.tag);
+//                    writableArray.pushMap(item);
+//                }
+//            params.putArray("allPoi", writableArray);
+//        }
+//        sendEvent("onGetPoiResult", params);
+//    }
+
+    @Override
+    public void onGetWalkingRouteResult(WalkingRouteResult walkingRouteResult) {
+
+    }
+
+    @Override
+    public void onGetTransitRouteResult(TransitRouteResult transitRouteResult) {
+
+    }
+
+    @Override
+    public void onGetMassTransitRouteResult(MassTransitRouteResult massTransitRouteResult) {
+
+    }
+
+    @Override
+    public void onGetDrivingRouteResult(DrivingRouteResult drivingRouteResult) {
+        if (drivingRouteResult == null) {
+            Toast.makeText(context, "未找到结果", Toast.LENGTH_LONG).show();
+            return;
+        }
+        WritableMap params = Arguments.createMap();
+        params.putString("error", String.valueOf(drivingRouteResult.error));
+        params.putInt("status", drivingRouteResult.status);
+        if (drivingRouteResult.error == SearchResult.ERRORNO.NO_ERROR) {
+            WritableArray writableArray = Arguments.createArray();
+            List<DrivingRouteLine> routeLines = drivingRouteResult.getRouteLines();
+            if (routeLines != null)
+                for (DrivingRouteLine routeLine : routeLines) {
+                    WritableMap item = Arguments.createMap();
+                    item.putInt("congestionDistance",routeLine.getCongestionDistance());
+                    item.putInt("distance",routeLine.getDistance());
+                    item.putInt("lightNum",routeLine.getLightNum());
+                    item.putInt("toll",routeLine.getToll());
+                    item.putInt("duration",routeLine.getDuration());
+                    writableArray.pushMap(item);
+                }
+            params.putArray("routeLines", writableArray);
+        }
+        sendEvent("onGetDrivingRouteResult", params);
+
+    }
+
+    @Override
+    public void onGetIndoorRouteResult(IndoorRouteResult indoorRouteResult) {
+
+    }
+
+    @Override
+    public void onGetBikingRouteResult(BikingRouteResult bikingRouteResult) {
+
+    }
+}

package/android/src/main/java/org/lovebing/reactnative/baidumap/support/AppUtils.java

@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2016-present, lovebing.org.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package org.lovebing.reactnative.baidumap.support;
+
+import android.app.Activity;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import androidx.core.app.ActivityCompat;
+import androidx.core.content.ContextCompat;
+import org.lovebing.reactnative.baidumap.constant.RequestCode;
+
+/**
+ * @author lovebing
+ * @date 2019/10/31
+ */
+public class AppUtils {
+
+    public static void checkPermission(Activity activity, String permission) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            if (activity.getApplicationInfo().targetSdkVersion >= Build.VERSION_CODES.M) {
+                if (!hasPermission(activity, permission)) {
+                    ActivityCompat.requestPermissions(activity, new String[]{permission}, RequestCode.CODE_ASK_PERMISSIONS);
+                }
+            }
+        }
+    }
+
+    public static boolean hasPermission(Activity activity, String permission) {
+        return ContextCompat.checkSelfPermission(activity, permission) == PackageManager.PERMISSION_GRANTED;
+    }
+}

package/android/src/main/java/org/lovebing/reactnative/baidumap/support/ConvertUtils.java

@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2016-present, lovebing.net.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package org.lovebing.reactnative.baidumap.support;
+
+import android.util.Log;
+import com.baidu.mapapi.model.LatLng;
+import com.facebook.react.bridge.ReadableMap;
+import org.lovebing.reactnative.baidumap.model.LocationData;
+
+import java.lang.reflect.Field;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author lovebing
+ * @date 2019/11/02
+ */
+public class ConvertUtils {
+
+    private static final String TAG = ConvertUtils.class.getName();
+    private static final Map<Class, Field[]> FILED_MAP = new HashMap<>();
+
+    public static LatLng convert(LocationData locationData) {
+        if (locationData == null || !locationData.isValid()) {
+            return null;
+        }
+        return new LatLng(locationData.getLatitude(), locationData.getLongitude());
+    }
+
+    public static <T> T convert(ReadableMap readableMap, Class<T> targetClass) {
+        if (readableMap == null) {
+            return null;
+        }
+        if (!FILED_MAP.containsKey(targetClass)) {
+            FILED_MAP.put(targetClass, targetClass.getDeclaredFields());
+        }
+        try {
+            T target = targetClass.newInstance();
+            Field[] fields = FILED_MAP.get(targetClass);
+            for (Field field : fields) {
+                if (readableMap.hasKey(field.getName())) {
+                    field.setAccessible(true);
+                    field.set(target, getValue(readableMap, field));
+                }
+            }
+            return target;
+        } catch (Exception e) {
+            Log.e(TAG, e.getMessage());
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    private static Object getValue(ReadableMap readableMa, Field field) {
+        if (field.getType().equals(Integer.class)) {
+            return readableMa.getInt(field.getName());
+        }
+        if (field.getType().equals(Double.class)) {
+            return readableMa.getDouble(field.getName());
+        }
+        if (field.getType().equals(String.class)) {
+            return readableMa.getString(field.getName());
+        }
+        if (field.getType().equals(Boolean.class)) {
+            return readableMa.getBoolean(field.getName());
+        }
+        return null;
+    }
+}