Android Cordova 调取GPS原生方法，获取经纬度

打耳洞的图图

于 2022-08-31 14:38:23 发布

阅读量1k

点赞数

文章标签： android java android studio

本文链接：https://blog.csdn.net/breaktt/article/details/126622734

版权

Android Cordova 调取GPS原生方法，获取经纬度

背景：cordova 插件中需要调取原生方法调取经纬度。
代码参考： https://www.cnblogs.com/yw1530/archive/2012/12/08/2808934.html
这里是应用是参考了上述大佬的代码，只作为学习记录使用，侵权立即删除

实现方法：

方法：直接新建一个GPSService类，原作者中默认设置了定时设置，本人将此处的设置成可初始化了，并且将接口内置；

package com.example.myapplication;

import android.annotation.SuppressLint;
import android.content.Context;
import android.location.Criteria;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;

import java.util.Timer;
import java.util.TimerTask;

public class GPSService {

    private IGPSCallback gpsCallback;//GPS回调接口
    private LocationManager loctionManager;
    private String provider;
    private boolean isRun;//GPSService是否运行
    public boolean getIsRun() {
        return isRun;
    }//@return GPS状态，true为正在运行，false已停止。
    private boolean isAutoStop = false; //超时停止
    private Timer timer; // 定时器
    private int outTime = 180;//超时时间（秒）
    private final float accuracy = 500.0f;//精度
    private Criteria criteria;//GPS配置参数
    public Criteria getCriteria() {
        initCriteria();
        return criteria;
    }// @return 获取criteria

    /**
     * 初始化GPS参数
     */
    private void initCriteria() {
        if (criteria == null) {
            criteria = new Criteria();
            criteria.setAccuracy(Criteria.ACCURACY_FINE); // 高精度
            criteria.setAltitudeRequired(false); // 不要求海拔
            criteria.setBearingRequired(false); // 不要求方位
            criteria.setCostAllowed(true); // 允许有花费
            criteria.setPowerRequirement(Criteria.POWER_LOW);// 设置低功耗模式
        }
    }

    private String lastErrorDescription = "";//最后一次错误描述
    public String getError() {
        return lastErrorDescription;
    }//@return 获取GPSSerivce最后一次出错的描述

    /**
     * 设置最后一次错误描述，该描述可以通过getError()方法获取。
     * @see GPSService#getError()
     * @param error 错误说明
     */
    private void setError(String error) {
        if (error == null)
            return;
        this.lastErrorDescription = error;
    }

    /**
     * GPSService构造函数
     * @param gpsCallback 回调函数接口
     * @param context   Context
     */
    public GPSService( IGPSCallback gpsCallback, Context context) {
        super();
        this.gpsCallback = gpsCallback;
        loctionManager = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
        initCriteria();
        /* 从可用的位置提供器中，匹配以上标准的最佳提供器 */
        provider = loctionManager.getBestProvider(criteria, true);
    }

    /**
     * GPSService构造函数
     * @param gpsCallback 回调函数接口
     * @param context     Context
     * @param isAutoStop  定位成功后是否自动停止GPS
     * @param time 设置超时时间
     */
    public GPSService( IGPSCallback gpsCallback, Context context, boolean isAutoStop,int time) {
        super();
        this.gpsCallback = gpsCallback;
        this.isAutoStop = isAutoStop;
        setOutTime(time);
        loctionManager = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
        initCriteria();
        // 从可用的位置提供器中，匹配以上标准的最佳提供器
        provider = loctionManager.getBestProvider(criteria, true);
    }

    /**
     * 返回超时时间（单位：秒）
     * @return
     */
    public int getOutTime() {
        return outTime;
    }

    /**
     * 设置超时时间
     * @param outTime 超时时间（单位：秒，范围：10—600），只可在Start()方法调用前使用，默认180秒，如果小于0秒则超时无效，只能手动调用Stop() 方法停止GPS。
     */
    public void setOutTime(int outTime) {
        if (outTime >= 0 && outTime <= 600) {
            this.outTime = outTime;
        }
    }

    /**
     * 开始GPS定位
     * @return 返回false表示GPS打开失败，可能没有硬件打开（由手机用户控制硬件开关）。
     */
    @SuppressLint("MissingPermission")
    public boolean start() {
        try {
            if (!loctionManager.isProviderEnabled(LocationManager.GPS_PROVIDER)) {
                // GPS没有打开
                setError("GPS没有硬件打开");
                gpsCallback.failCallBack (IGPSCallback.ERROR_CLOSE);
                return false;
            }

            if (this.outTime >= 10) {
                // 设置超时参数，启动定时器
                timer = new Timer();
                timer.schedule(new TimerTask() {
                    @Override
                    public void run() {
                        // 停止GPS
                        timer.cancel();
                        stop();
                        handler.sendEmptyMessage(0);
                    }
                }, 1000 * outTime);
            }

            // 注册监听函数
            if (locationListener != null) {
                loctionManager.requestLocationUpdates(provider, 1000 * 10, accuracy, locationListener);
            }

            isRun = true;
            return true;
        } catch (Exception e) {
            setError(e.getMessage());
            e.printStackTrace();
            return false;
        }
    }

    private Handler handler = new Handler() {
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 0:
                    gpsCallback.failCallBack(IGPSCallback.ERROR_OUTTIME);
                    break;
            }
            super.handleMessage(msg);
        }
    };

    /**
     * 停止GPS定位
     * @return
     */
    public boolean stop() {
        try {
            if (locationListener != null) {
                loctionManager.removeUpdates(locationListener);
            }
            isRun = false;
            return true;
        } catch (Exception e) {
            setError(e.getMessage());
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 位置监听器
     */
    private final LocationListener locationListener = new LocationListener() {
        @Override
        public void onStatusChanged(String provider, int status, Bundle extras) {
        }

        @Override
        public void onProviderEnabled(String provider) {
        }

        @Override
        public void onProviderDisabled(String provider) {
        }

        // 当位置变化时触发
        @Override
        public void onLocationChanged(Location location) {
            if (location != null) {
                if (location.hasAccuracy() && location.getAccuracy() <= accuracy) {
                    // 是否自动停止
                    if (isAutoStop) {
                        stop();
                    }
                    gpsCallback.gpsCallback(location);
                }
            }
        }
    };
     interface IGPSCallback {
        //GPS无信号
        public final static String ERROR_NO_SIGNAL = "GPS无信号";
        // GPS超时退出
        public final static String ERROR_OUTTIME = "GPS超时退出";
        //GPS硬件没有打开
        public final static String ERROR_CLOSE = "GPS硬件关闭";

        //GPS执行成功，返回Location时的回调函数
        void gpsCallback(Location location);
        // GPS错误时的回调函数 包括GPS无信号、GPS超时退出、GPS硬件没有打开
        void failCallBack(String error);
    }
}

cordova插件方法

这里的权限是引用了一个依赖，感兴趣的直接搜AndPermission就可以找到了，用法也比较简单

if ("getCurrentGPS".equals(action)) {
            RETURNGPS_TYPE=0;
            context = cordova.getActivity();
            GpsCallBack = callbackContext;
            JSONObject obj = args.getJSONObject(0);
            String time = obj.getString("timer");
            AndPermission.with(context)
                    .permission(Permission.ACCESS_FINE_LOCATION, Permission.ACCESS_COARSE_LOCATION)
                    .onGranted(new Action() {
                        @SuppressLint("MissingPermission")
                        @Override
                        public void onAction(List<String> permissions) {
                            cordova.getActivity().runOnUiThread(new Runnable() {
                                public void run() {
                                    GPSService gpsService = new GPSService(new IGPSCallback() {
                                        @Override
                                        public void gpsCallback(Location location) {
                                            JSONObject jsonObject = new JSONObject();
                                            try {
                                                jsonObject.put("latitude", location.getLongitude());
                                                jsonObject.put("longitude", location.getLatitude());
                                                jsonObject.put("code", "200");
                                                jsonObject.put("msg", "定位成功");
                                            } catch (JSONException e) {
                                                e.printStackTrace();
                                            }
                                            GpsCallBack.success(jsonObject);
                                            Log.e("break", String.valueOf(jsonObject));
                                        }

                                        @Override
                                        public void failCallBack(String error) {
                                            JSONObject jsonObject = new JSONObject();
                                            try {
                                                jsonObject.put("code", "202");
                                                jsonObject.put("msg", error);
                                            } catch (JSONException e) {
                                                e.printStackTrace();
                                            }
                                            GpsCallBack.error(jsonObject);
                                        }
                                    }, context, true,Integer.parseInt(time));
                                    gpsService.start();
                                }
                            });
                        }
                    })
                    .onDenied(new Action() {
                        @Override
                        public void onAction(List<String> permissions) {
                            callbackContext.error("没有权限");
                        }
                    }).start();


            return true;

js中的用法：这是前端的代码，具体的插件就不详细说了

var config={
timer:5
}
EappApi.getCurrentGPS(config,function (success) {
    alert(JSON.stringify(success));
  }, function (error) {
    alert(JSON.stringify(error));
  });};