ฉันจะรับตำแหน่ง GPS ปัจจุบันโดยทางโปรแกรมใน Android ได้อย่างไร


716

ฉันต้องได้รับตำแหน่งปัจจุบันของฉันโดยใช้ GPS โดยทางโปรแกรม ฉันจะประสบความสำเร็จได้อย่างไร

คำตอบ:


432

ฉันสร้างแอปพลิเคชั่นขนาดเล็กพร้อมคำอธิบายทีละขั้นตอนเพื่อรับพิกัด GPS ของตำแหน่งปัจจุบัน

โค้ดตัวอย่างที่สมบูรณ์อยู่ในดูพิกัดที่ตั้งปัจจุบันชื่อเมือง - ใน Android


ดูว่ามันทำงานอย่างไร:

  • สิ่งที่เราต้องทำคือเพิ่มการอนุญาตนี้ในไฟล์ Manifest:

    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
  • และสร้างตัวอย่าง LocationManager เช่นนี้:

    LocationManager locationManager = (LocationManager)
    getSystemService(Context.LOCATION_SERVICE);
    
  • ตรวจสอบว่ามีการเปิดใช้งาน GPS หรือไม่

  • จากนั้นใช้ LocationListener และรับพิกัด:

    LocationListener locationListener = new MyLocationListener();
    locationManager.requestLocationUpdates(
    LocationManager.GPS_PROVIDER, 5000, 10, locationListener);
    
  • นี่คือตัวอย่างโค้ดที่ต้องทำ


/*---------- Listener class to get coordinates ------------- */
private class MyLocationListener implements LocationListener {

    @Override
    public void onLocationChanged(Location loc) {
        editLocation.setText("");
        pb.setVisibility(View.INVISIBLE);
        Toast.makeText(
                getBaseContext(),
                "Location changed: Lat: " + loc.getLatitude() + " Lng: "
                    + loc.getLongitude(), Toast.LENGTH_SHORT).show();
        String longitude = "Longitude: " + loc.getLongitude();
        Log.v(TAG, longitude);
        String latitude = "Latitude: " + loc.getLatitude();
        Log.v(TAG, latitude);

        /*------- To get city name from coordinates -------- */
        String cityName = null;
        Geocoder gcd = new Geocoder(getBaseContext(), Locale.getDefault());
        List<Address> addresses;
        try {
            addresses = gcd.getFromLocation(loc.getLatitude(),
                    loc.getLongitude(), 1);
            if (addresses.size() > 0) {
                System.out.println(addresses.get(0).getLocality());
                cityName = addresses.get(0).getLocality();
            }
        }
        catch (IOException e) {
            e.printStackTrace();
        }
        String s = longitude + "\n" + latitude + "\n\nMy Current City is: "
            + cityName;
        editLocation.setText(s);
    }

    @Override
    public void onProviderDisabled(String provider) {}

    @Override
    public void onProviderEnabled(String provider) {}

    @Override
    public void onStatusChanged(String provider, int status, Bundle extras) {}
}


36
ซึ่งหมายความว่าคุณจะต้องย้ายก่อนที่จะมีการปรับปรุงสถานที่? ทำไมมันไม่แสดงตำแหน่งปัจจุบันของคุณในครั้งแรกหลังจากลองติดตั้ง?
Nii Laryea

15
@NiiLaryea เพราะฉันได้รับตำแหน่งโดยใช้วิธี " onLocationChanged () " ซึ่งให้ทุกครั้งที่ตำแหน่งใหม่ในขณะที่คุณย้าย แต่ถ้าคุณต้องการเพียงครั้งเดียวคุณต้องเรียกว่า " getLastKnownLocation () "
swiftBoy

หากมีเพียงหนึ่งที่อยู่ในadressesบรรทัดที่ขึ้นต้นด้วยcityName =จะล้มเหลวโดยมีข้อยกเว้น การใช้เครื่องมือจัดฟันจะแก้ไขได้
Carrotman42

2
ฉันเคยได้ยินคนพูดกันว่าgetLastKnownLocation()เป็นสถานที่ "เก่า" มากกว่านี้ทำไมล่ะ การโทรgetLastKnownLocation()ไม่ได้รับการอ่าน GPS ล่าสุดของ GPS ในโทรศัพท์หรือไม่
Don Cheadle

9
@mmcrae ไม่ไม่ GPS ไม่ได้ทำงานเสมอ getLastKnownLocation ไม่เปิดใช้งาน มันได้รับตำแหน่งสุดท้ายจากครั้งสุดท้ายที่มันเปิดอยู่ หมวกอาจมีความสดใหม่อายุหนึ่งชั่วโมงหรือเป็นโมฆะ
Gabe Sechan

139

นี่คือข้อมูลเพิ่มเติมสำหรับคำตอบอื่น ๆ

ตั้งแต่ Android มี

GPS_PROVIDER and NETWORK_PROVIDER

คุณสามารถลงทะเบียนทั้งคู่และเริ่มดึงกิจกรรมonLocationChanged(Location location)จากสองรายการในเวลาเดียวกัน จนถึงตอนนี้ดีมาก ตอนนี้คำถามที่เราต้องการสองผลลัพธ์หรือเราควรทำอย่างดีที่สุด ที่ผมรู้ว่าผลจะมีความถูกต้องดีกว่าGPS_PROVIDERNETWORK_PROVIDER

มานิยามLocationฟิลด์กัน

private Location currentBestLocation = null;

ก่อนที่เราจะเริ่มฟังการเปลี่ยนแปลงตำแหน่งเราจะใช้วิธีการต่อไปนี้ วิธีนี้จะส่งคืนตำแหน่งที่ทราบล่าสุดระหว่าง GPS และเครือข่าย สำหรับวิธีนี้ใหม่กว่าดีที่สุด

/**
 * @return the last know best location
 */
private Location getLastBestLocation() {
    Location locationGPS = mLocationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER);
    Location locationNet = mLocationManager.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);

    long GPSLocationTime = 0;
    if (null != locationGPS) { GPSLocationTime = locationGPS.getTime(); }

    long NetLocationTime = 0;

    if (null != locationNet) {
        NetLocationTime = locationNet.getTime();
    }

    if ( 0 < GPSLocationTime - NetLocationTime ) {
        return locationGPS;
    }
    else {
        return locationNet;
    }
}

ทุกครั้งที่เราดึงข้อมูลตำแหน่งใหม่เราจะทำการเปรียบเทียบกับผลลัพธ์ก่อนหน้าของเรา

...
static final int TWO_MINUTES = 1000 * 60 * 2;
...

ฉันเพิ่มวิธีการใหม่เพื่อonLocationChanged:

@Override
public void onLocationChanged(Location location) {

    makeUseOfNewLocation(location);

    if(currentBestLocation == null){
        currentBestLocation = location;
    }

    ....
}


/**
 * This method modify the last know good location according to the arguments.
 *
 * @param location The possible new location.
 */
void makeUseOfNewLocation(Location location) {
    if ( isBetterLocation(location, currentBestLocation) ) {
        currentBestLocation = location;
    }
}

....

/** Determines whether one location reading is better than the current location fix
 * @param location  The new location that you want to evaluate
 * @param currentBestLocation  The current location fix, to which you want to compare the new one.
 */
protected boolean isBetterLocation(Location location, Location currentBestLocation) {
    if (currentBestLocation == null) {
        // A new location is always better than no location
        return true;
    }

    // Check whether the new location fix is newer or older
    long timeDelta = location.getTime() - currentBestLocation.getTime();
    boolean isSignificantlyNewer = timeDelta > TWO_MINUTES;
    boolean isSignificantlyOlder = timeDelta < -TWO_MINUTES;
    boolean isNewer = timeDelta > 0;

    // If it's been more than two minutes since the current location, use the new location,
    // because the user has likely moved.
    if (isSignificantlyNewer) {
        return true;
        // If the new location is more than two minutes older, it must be worse.
    } else if (isSignificantlyOlder) {
        return false;
    }

    // Check whether the new location fix is more or less accurate
    int accuracyDelta = (int) (location.getAccuracy() - currentBestLocation.getAccuracy());
    boolean isLessAccurate = accuracyDelta > 0;
    boolean isMoreAccurate = accuracyDelta < 0;
    boolean isSignificantlyLessAccurate = accuracyDelta > 200;

    // Check if the old and new location are from the same provider
    boolean isFromSameProvider = isSameProvider(location.getProvider(),
                                                currentBestLocation.getProvider());

    // Determine location quality using a combination of timeliness and accuracy
    if (isMoreAccurate) {
        return true;
    } else if (isNewer && !isLessAccurate) {
        return true;
    } else if (isNewer && !isSignificantlyLessAccurate && isFromSameProvider) {
        return true;
    }
    return false;
}

// Checks whether two providers are the same
private boolean isSameProvider(String provider1, String provider2) {
    if (provider1 == null) {
        return provider2 == null;
    }
    return provider1.equals(provider2);
}

....

สวัสดีนั่นเป็นตัวอย่างที่ดี .. แต่คุณช่วยยกตัวอย่างที่สมบูรณ์กว่านี้ให้ฉันได้ไหม ฉันมีปัญหาในการรวมเข้ากับรหัสที่มีอยู่ของฉัน นอกจากนี้ฉันใช้ GPS เป็นผู้ให้บริการเท่านั้น
beerBear

1
@quantumstates ฉันคิดว่ามันค่อนข้างสมบูรณ์ เพียงสร้างฟิลด์private Location currentBestLocation = null;และเพิ่ม `makeUseOfNewLocation (สถานที่); 'to onLocationChanged (.. ) วิธีการ
Maxim Shoustin

ขอบคุณ Maxim ฉันมีคำถาม. คุณใช้วิธี 'getLastBestLocation' ที่ไหน
SeyedPooya Soofbaf

@SeyyedPuyaSoofbaf โดยทั่วไปสถานที่ใหม่ที่เราได้รับหลังจากประมาณ 30 วินาที หากเราลงทะเบียนกับผู้จัดการทั้งสองเราสามารถรับตำแหน่งล่าสุด 2 แห่งได้ทันทีและตัดสินใจว่าแม่มดแห่งนี้ใหม่กว่า
Maxim Shoustin

ฉันไม่ทราบว่า getLastBestLocation และ isBetterLocation แตกต่างกันอย่างไร ทั้งสองวิธีนี้ถูกใช้เพื่อเปรียบเทียบสองตำแหน่ง
SeyedPooya Soofbaf

84

GPS_PROVIDER or NETWORK_PROVIDERคุณสามารถค้นหาสถานที่ทั้งโดย

ภาพรวมของบริการระบุตำแหน่งใน Android

นี่คือตัวอย่างหนึ่งที่พยายามค้นหาตำแหน่งโดยใช้ GPS หาก GPS ของคุณไม่พร้อมใช้งานให้ลองใช้เครือข่ายเพื่อค้นหาตำแหน่ง

GPSTracker.java

 public class GPSTracker extends Service implements LocationListener {

    private final Context mContext;

    // Flag for GPS status
    boolean isGPSEnabled = false;

    // Flag for network status
    boolean isNetworkEnabled = false;

    // Flag for GPS status
    boolean canGetLocation = false;

    Location location; // Location
    double latitude; // Latitude
    double longitude; // Longitude

    // The minimum distance to change Updates in meters
    private static final long MIN_DISTANCE_CHANGE_FOR_UPDATES = 10; // 10 meters

    // The minimum time between updates in milliseconds
    private static final long MIN_TIME_BW_UPDATES = 1000 * 60 * 1; // 1 minute

    // Declaring a Location Manager
    protected LocationManager locationManager;

    public GPSTracker(Context context) {
        this.mContext = context;
        getLocation();
    }

    public Location getLocation() {
        try {
            locationManager = (LocationManager) mContext
                    .getSystemService(LOCATION_SERVICE);

            // Getting GPS status
            isGPSEnabled = locationManager
                    .isProviderEnabled(LocationManager.GPS_PROVIDER);

            // Getting network status
            isNetworkEnabled = locationManager
                    .isProviderEnabled(LocationManager.NETWORK_PROVIDER);

            if (!isGPSEnabled && !isNetworkEnabled) {
                // No network provider is enabled
            } else {
                this.canGetLocation = true;
                if (isNetworkEnabled) {
                    locationManager.requestLocationUpdates(
                            LocationManager.NETWORK_PROVIDER,
                            MIN_TIME_BW_UPDATES,
                            MIN_DISTANCE_CHANGE_FOR_UPDATES, this);
                    Log.d("Network", "Network");
                    if (locationManager != null) {
                        location = locationManager
                                .getLastKnownLocation(LocationManager.NETWORK_PROVIDER);
                        if (location != null) {
                            latitude = location.getLatitude();
                            longitude = location.getLongitude();
                        }
                    }
                }
                // If GPS enabled, get latitude/longitude using GPS Services
                if (isGPSEnabled) {
                    if (location == null) {
                        locationManager.requestLocationUpdates(
                                LocationManager.GPS_PROVIDER,
                                MIN_TIME_BW_UPDATES,
                                MIN_DISTANCE_CHANGE_FOR_UPDATES, this);
                        Log.d("GPS Enabled", "GPS Enabled");
                        if (locationManager != null) {
                            location = locationManager
                                    .getLastKnownLocation(LocationManager.GPS_PROVIDER);
                            if (location != null) {
                                latitude = location.getLatitude();
                                longitude = location.getLongitude();
                            }
                        }
                    }
                }
            }
        }
        catch (Exception e) {
            e.printStackTrace();
        }

        return location;
    }


    /**
     * Stop using GPS listener
     * Calling this function will stop using GPS in your app.
     * */
    public void stopUsingGPS(){
        if(locationManager != null){
            locationManager.removeUpdates(GPSTracker.this);
        }
    }


    /**
     * Function to get latitude
     * */
    public double getLatitude(){
        if(location != null){
            latitude = location.getLatitude();
        }

        // return latitude
        return latitude;
    }


    /**
     * Function to get longitude
     * */
    public double getLongitude(){
        if(location != null){
            longitude = location.getLongitude();
        }

        // return longitude
        return longitude;
    }

    /**
     * Function to check GPS/Wi-Fi enabled
     * @return boolean
     * */
    public boolean canGetLocation() {
        return this.canGetLocation;
    }


    /**
     * Function to show settings alert dialog.
     * On pressing the Settings button it will launch Settings Options.
     * */
    public void showSettingsAlert(){
        AlertDialog.Builder alertDialog = new AlertDialog.Builder(mContext);

        // Setting Dialog Title
        alertDialog.setTitle("GPS is settings");

        // Setting Dialog Message
        alertDialog.setMessage("GPS is not enabled. Do you want to go to settings menu?");

        // On pressing the Settings button.
        alertDialog.setPositiveButton("Settings", new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog,int which) {
                Intent intent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
                mContext.startActivity(intent);
            }
        });

        // On pressing the cancel button
        alertDialog.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int which) {
            dialog.cancel();
            }
        });

        // Showing Alert Message
        alertDialog.show();
    }


    @Override
    public void onLocationChanged(Location location) {
    }


    @Override
    public void onProviderDisabled(String provider) {
    }


    @Override
    public void onProviderEnabled(String provider) {
    }


    @Override
    public void onStatusChanged(String provider, int status, Bundle extras) {
    }


    @Override
    public IBinder onBind(Intent arg0) {
        return null;
    }
}

กิจกรรม -AndroidGPSTrackingActivity.java

    public class AndroidGPSTrackingActivity extends Activity {

    Button btnShowLocation;

    // GPSTracker class
    GPSTracker gps;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        btnShowLocation = (Button) findViewById(R.id.btnShowLocation);

        // Show location button click event
        btnShowLocation.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View arg0) {
                // Create class object
                gps = new GPSTracker(AndroidGPSTrackingActivity.this);

                // Check if GPS enabled
                if(gps.canGetLocation()) {

                    double latitude = gps.getLatitude();
                    double longitude = gps.getLongitude();

                    // \n is for new line
                    Toast.makeText(getApplicationContext(), "Your Location is - \nLat: " + latitude + "\nLong: " + longitude, Toast.LENGTH_LONG).show();
                } else {
                    // Can't get location.
                    // GPS or network is not enabled.
                    // Ask user to enable GPS/network in settings.
                    gps.showSettingsAlert();
                }
            }
        });
    }
}

เค้าโครง - main.xml

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >

    <Button android:id="@+id/btnShowLocation"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Show Location"
        android:layout_centerVertical="true"
        android:layout_centerHorizontal="true"/>
</RelativeLayout>

AndroidManifest.xml

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.INTERNET" />

4
ฉันคิดว่ามีปัญหากับตัวอย่างนี้ดูเหมือนคุณจะไม่เคยใช้ฟังสถานที่ มันมักจะใช้ GetLastKnownLocation () ซึ่งอาจไม่ล่าสุด
Madhur Ahuja

16
ต้อง downvote สำหรับ overrated โค้ดที่นี่เหมาะสม แต่ถูกใช้โดยผู้คนจำนวนมากที่ไม่เข้าใจและมีข้อบกพร่องบางประการในการใช้ getLastKnownLocation - เราได้รับคำถามมากมายจากผู้ใช้และได้รับสถานที่เก่า ๆ พวกเขากำลังอับ ด้วยค่า canGetLocation ไม่ถูกต้องคุณตั้งค่าตามว่าผู้ให้บริการเปิดใช้งานหรือไม่ แต่ตรวจสอบว่า getLastKnownLocation คืนค่าจริงหรือไม่ ฉันคิดว่านี่สามารถทำได้ดี แต่ฉันจะไม่แนะนำให้ใครใช้ตามที่เป็นอยู่
Gabe Sechan

1
การอนุญาต ACCESS_FINE_LOCATION นั้นเพียงพอสำหรับ android docs: หากคุณใช้ทั้ง NETWORK_PROVIDER และ GPS_PROVIDER คุณจะต้องขออนุญาตจาก ACCESS_FINE_LOCATION เท่านั้นเนื่องจากได้รับอนุญาตจากผู้ให้บริการทั้งสองราย (การอนุญาตสำหรับ ACCESS_COARSE_LOCATION จะรวมเฉพาะสิทธิ์สำหรับ NETWORK_PROVIDER เท่านั้น)
อังกฤษ Samer T

ฉันลองใช้รหัสนี้และให้ตำแหน่งไม่ถูกต้อง
misha312

ไม่ใช่รหัสที่ถูกต้องซึ่งไม่ได้ให้ตำแหน่งที่ถูกต้อง
Moeez

45

มีคำตอบมากมายอยู่แล้ว แต่ฉันต้องการแสดงวิธีล่าสุดในการรับตำแหน่งโดยใช้ Google API ดังนั้นโปรแกรมเมอร์ใหม่จึงสามารถใช้วิธีการใหม่ได้:

ฉันได้เขียนรายละเอียดการสอนเกี่ยวกับตำแหน่งปัจจุบันใน Androidที่บล็อกของฉันdemonuts.comนอกจากนี้คุณยังสามารถค้นหารหัสที่มาเต็มรูปแบบที่พัฒนาด้วยสตูดิโอ Android

ก่อนอื่นให้วางสิ่งนี้ลงในไฟล์ gradle

 compile 'com.google.android.gms:play-services:9.0.2'

จากนั้นใช้อินเทอร์เฟซที่จำเป็น

public class MainActivity  extends BaseActivitiy implements GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener, com.google.android.gms.location.LocationListener

ประกาศอินสแตนซ์

  private GoogleApiClient mGoogleApiClient;
  private Location mLocation;
  private LocationManager locationManager;
  private LocationRequest mLocationRequest;

ใส่สิ่งนี้ใน onCreate()

 mGoogleApiClient = new GoogleApiClient.Builder(this)
                .addConnectionCallbacks(this)
                .addOnConnectionFailedListener(this)
                .addApi(LocationServices.API)
                .build();
        locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);

ในที่สุดก็แทนที่วิธีที่จำเป็น

 @Override
    public void onConnected(Bundle bundle) {
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            // TODO: Consider calling
            //    ActivityCompat#requestPermissions
            // here to request the missing permissions, and then overriding
            //   public void onRequestPermissionsResult(int requestCode, String[] permissions,
            //                                          int[] grantResults)
            // to handle the case where the user grants the permission. See the documentation
            // for ActivityCompat#requestPermissions for more details.
            return;
        } startLocationUpdates();
        mLocation = LocationServices.FusedLocationApi.getLastLocation(mGoogleApiClient);
        if(mLocation == null){
            startLocationUpdates();
        }
        if (mLocation != null) {
            double latitude = mLocation.getLatitude();
            double longitude = mLocation.getLongitude();
        } else {
            // Toast.makeText(this, "Location not Detected", Toast.LENGTH_SHORT).show();
        }
    }

    protected void startLocationUpdates() {
        // Create the location request
        mLocationRequest = LocationRequest.create()
                .setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY)
                .setInterval(UPDATE_INTERVAL)
                .setFastestInterval(FASTEST_INTERVAL);
        // Request location updates
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            // TODO: Consider calling
            //    ActivityCompat#requestPermissions
            // here to request the missing permissions, and then overriding
            //   public void onRequestPermissionsResult(int requestCode, String[] permissions,
            //                                          int[] grantResults)
            // to handle the case where the user grants the permission. See the documentation
            // for ActivityCompat#requestPermissions for more details.
            return;
        }
        LocationServices.FusedLocationApi.requestLocationUpdates(mGoogleApiClient,
                mLocationRequest, this);
        Log.d("reque", "--->>>>");
    }

    @Override
    public void onConnectionSuspended(int i) {
        Log.i(TAG, "Connection Suspended");
        mGoogleApiClient.connect();
    }

    @Override
    public void onConnectionFailed(ConnectionResult connectionResult) {
        Log.i(TAG, "Connection failed. Error: " + connectionResult.getErrorCode());
    }

    @Override
    public void onStart() {
        super.onStart();
        mGoogleApiClient.connect();
    }

    @Override
    public void onStop() {
        super.onStop();
        if (mGoogleApiClient.isConnected()) {
            mGoogleApiClient.disconnect();
        }
    }
    @Override
    public void onLocationChanged(Location location) {

    }

อย่าลืมเริ่ม GPS ในอุปกรณ์ของคุณก่อนเปิดแอพ


ฉันใช้วิธีการของคุณในการแสดงพิกัด แต่ฉันไม่เห็นพิกัดคุณช่วยกรุณาดูคำถามของฉันได้ไหม?
Moeez

1
mLocationให้ null เสมอ ฉันลองเช่นเดียวกับที่กล่าวถึง
dharanbro

ไปที่ลิงค์นี้: demonuts.com/2016/12/30/get-current-gps-location-android-studio และดาวน์โหลดซอร์สโค้ดจากที่นั่นและตรวจสอบว่าซอร์สโค้ดทำงานในพีซีของคุณหรือไม่
Parsania Hardik

5
นี่ควรเป็นคำตอบที่ยอมรับได้ และเพื่อความกะทัดรัดคุณสามารถใช้compile 'com.google.android.gms:play-services-location:11.0.4'แทนการเพิ่มบริการ Google Play ทั้งหมดลงในแอปของคุณ
Morris Franken

37

เนื่องจากฉันไม่ชอบรหัสบางส่วนในคำตอบอื่น ๆ นี่เป็นคำตอบง่ายๆของฉัน โซลูชันนี้มีไว้เพื่อให้สามารถใช้งานได้ในกิจกรรมหรือบริการเพื่อติดตามตำแหน่ง ทำให้แน่ใจว่าจะไม่ส่งคืนข้อมูลที่ค้างเกินไปเว้นแต่คุณจะขอข้อมูลเก่าอย่างชัดเจน มันสามารถทำงานได้ทั้งในโหมดโทรกลับเพื่อรับการปรับปรุงเมื่อเราได้รับพวกเขาหรือในโหมดการสำรวจความคิดเห็นเพื่อสำรวจความคิดเห็นสำหรับข้อมูลล่าสุด

อินเตอร์เฟส LocationTracker ทั่วไป ช่วยให้เรามีเครื่องมือติดตามตำแหน่งหลายประเภทและเสียบอุปกรณ์ติดตามที่เหมาะสมได้อย่างง่ายดาย:

package com.gabesechan.android.reusable.location;

import android.location.Location;

public interface LocationTracker {
    public interface LocationUpdateListener{
        public void onUpdate(Location oldLoc, long oldTime, Location newLoc, long newTime);
    }

    public void start();
    public void start(LocationUpdateListener update);

    public void stop();

    public boolean hasLocation();

    public boolean hasPossiblyStaleLocation();

    public Location getLocation();

    public Location getPossiblyStaleLocation();

}

ProviderLocationTracker- คลาสนี้จะติดตามตำแหน่งสำหรับ GPS หรือ NETWORK

package com.gabesechan.android.reusable.location;

import android.content.Context;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.Bundle;

public class ProviderLocationTracker implements LocationListener, LocationTracker {

    // The minimum distance to change Updates in meters
    private static final long MIN_UPDATE_DISTANCE = 10; 

    // The minimum time between updates in milliseconds
    private static final long MIN_UPDATE_TIME = 1000 * 60; 

    private LocationManager lm;

    public enum ProviderType{
        NETWORK,
        GPS
    };    
    private String provider;

    private Location lastLocation;
    private long lastTime;

    private boolean isRunning;

    private LocationUpdateListener listener;

    public ProviderLocationTracker(Context context, ProviderType type) {
        lm = (LocationManager)context.getSystemService(Context.LOCATION_SERVICE);
        if(type == ProviderType.NETWORK){
            provider = LocationManager.NETWORK_PROVIDER;
        }
        else{
            provider = LocationManager.GPS_PROVIDER;
        }
    }

    public void start(){
        if(isRunning){
            //Already running, do nothing
            return;
        }

        //The provider is on, so start getting updates.  Update current location
        isRunning = true;
        lm.requestLocationUpdates(provider, MIN_UPDATE_TIME, MIN_UPDATE_DISTANCE, this);
        lastLocation = null;
        lastTime = 0;
        return;
    }

    public void start(LocationUpdateListener update) {
        start();
        listener = update;

    }


    public void stop(){
        if(isRunning){
            lm.removeUpdates(this);
            isRunning = false;
            listener = null;
        }
    }

    public boolean hasLocation(){
        if(lastLocation == null){
            return false;
        }
        if(System.currentTimeMillis() - lastTime > 5 * MIN_UPDATE_TIME){
            return false; //stale
        }
        return true;
    }

    public boolean hasPossiblyStaleLocation(){
        if(lastLocation != null){
            return true;
        }
        return lm.getLastKnownLocation(provider)!= null;
    }

    public Location getLocation(){
        if(lastLocation == null){
            return null;
        }
        if(System.currentTimeMillis() - lastTime > 5 * MIN_UPDATE_TIME){
            return null; //stale
        }
        return lastLocation;
    }

    public Location getPossiblyStaleLocation(){
        if(lastLocation != null){
            return lastLocation;
        }
        return lm.getLastKnownLocation(provider);
    }

    public void onLocationChanged(Location newLoc) {
        long now = System.currentTimeMillis();
        if(listener != null){
            listener.onUpdate(lastLocation, lastTime, newLoc, now);
        }
        lastLocation = newLoc;
        lastTime = now;
    }

    public void onProviderDisabled(String arg0) {

    }

    public void onProviderEnabled(String arg0) {

    }

    public void onStatusChanged(String arg0, int arg1, Bundle arg2) {
    }
}

The คือ FallbackLocationTracker ซึ่งจะติดตามทั้ง GPS และ NETWORK และใช้ตำแหน่งที่แม่นยำยิ่งขึ้น

package com.gabesechan.android.reusable.location;

import android.content.Context;
import android.location.Location;
import android.location.LocationManager;

public class FallbackLocationTracker  implements LocationTracker, LocationTracker.LocationUpdateListener {


    private boolean isRunning;

    private ProviderLocationTracker gps;
    private ProviderLocationTracker net;

    private LocationUpdateListener listener;

    Location lastLoc;
    long lastTime;

    public FallbackLocationTracker(Context context) {
        gps = new ProviderLocationTracker(context, ProviderLocationTracker.ProviderType.GPS);
        net = new ProviderLocationTracker(context, ProviderLocationTracker.ProviderType.NETWORK);
    }

    public void start(){
        if(isRunning){
            //Already running, do nothing
            return;
        }

        //Start both
        gps.start(this);
        net.start(this);
        isRunning = true;
    }

    public void start(LocationUpdateListener update) {
        start();
        listener = update;
    }


    public void stop(){
        if(isRunning){
            gps.stop();
            net.stop();
            isRunning = false;
            listener = null;
        }
    }

    public boolean hasLocation(){
        //If either has a location, use it
        return gps.hasLocation() || net.hasLocation();
    }

    public boolean hasPossiblyStaleLocation(){
        //If either has a location, use it
        return gps.hasPossiblyStaleLocation() || net.hasPossiblyStaleLocation();
    }

    public Location getLocation(){
        Location ret = gps.getLocation();
        if(ret == null){
            ret = net.getLocation();
        }
        return ret;
    }

    public Location getPossiblyStaleLocation(){
        Location ret = gps.getPossiblyStaleLocation();
        if(ret == null){
            ret = net.getPossiblyStaleLocation();
        }
        return ret;
    }

    public void onUpdate(Location oldLoc, long oldTime, Location newLoc, long newTime) {
        boolean update = false;

        //We should update only if there is no last location, the provider is the same, or the provider is more accurate, or the old location is stale
        if(lastLoc == null){
            update = true;
        }
        else if(lastLoc != null && lastLoc.getProvider().equals(newLoc.getProvider())){
            update = true;
        }
        else if(newLoc.getProvider().equals(LocationManager.GPS_PROVIDER)){
            update = true;
        }
        else if (newTime - lastTime > 5 * 60 * 1000){
            update = true;
        }

        if(update){
            if(listener != null){
                listener.onUpdate(lastLoc, lastTime, newLoc, newTime);                  
            }
            lastLoc = newLoc;
            lastTime = newTime;
        }

    }
}

เนื่องจากทั้งสองใช้อินเตอร์เฟส LocationTracker คุณสามารถเปลี่ยนใจได้ว่าจะใช้อันไหน หากต้องการเรียกใช้คลาสในโหมดการสำรวจความคิดเห็นเพียงแค่เรียก start () หากต้องการเรียกใช้ในโหมดอัพเดตให้เริ่มการโทร (ฟัง)

ลองดูที่โพสต์บล็อกของฉันบนรหัส


สำหรับทุกคนที่อยากรู้อยากเห็น - เหตุผลที่ฉันไม่ได้ใช้เวลาที่สร้างไว้ในวัตถุที่ตั้งเป็นเพราะ API ไม่มีอยู่จนกระทั่ง API 17 เนื่องจากฉันต้องการที่จะรักษาความเข้ากันได้กับ 14 ฉันแค่ใช้เวลาปัจจุบัน นั่นเป็นสาเหตุที่ฉันไม่โทรหา getLastKnownLocation ก่อน - เพราะเราไม่สามารถหาเวลาและดูว่ามันค้างหรือไม่
Gabe Sechan

รหัสของคุณเป็นทางออกที่ดีที่สุดและสมบูรณ์ที่สุดที่ฉันพบในการค้นหาสองวันล่าสุดในหัวข้อนี้ มันทำงานได้โดยไม่มีข้อผิดพลาดและชอบเสน่ห์มันน่าประทับใจ สิ่งเดียวที่ฉันเปลี่ยน FallbackLocationTracker (บริบทบริบทประเภท ProviderType) เป็นสาธารณะ FallbackLocationTracker (บริบทบริบท) เนื่องจากเราไม่จำเป็นต้องส่งผู้ให้บริการไปยังชั้นนี้มันคำนึงถึงทั้ง GPS และเครือข่ายใช่ไหม?
zeeshan

@zeeshan คุณถูกต้องและฉันอัปเดตรหัสที่นี่ ฉันจะทำมันในบล็อกของฉันในครั้งต่อไปที่ฉันหาเวลา (ยากที่จะได้รับทรัพยากรสำหรับฉันในวันนี้) อย่างที่คุณคิดว่าฉันสร้างทางเลือกโดยการคัดลอกวางจากชั้นเรียนอื่นและไม่เคยทำความสะอาดนั้น
Gabe Sechan

12
ที่ดีที่สุด solution..but ขาดเพียงสิ่งเดียว ... มือใหม่ไม่สามารถดำเนินการ it..there ควรจะเป็นตัวอย่างการใช้งานอยู่ในนั้นมากเกินไป ..
Zaffar Saffee

1
สวัสดี @GabeSechan ฉันได้ใช้วิธีการของคุณแล้ว แต่ทุกครั้งที่ฉันเปิด GPS ในการตั้งค่าบนอุปกรณ์ Android ของฉันและเปิดใช้งานเครือข่ายมันจะคืนค่า null เป็นวิธีการ getLocation เสมอ FallbackLocationTracker fallbackLocationTracker = new FallbackLocationTracker(mContext); fallbackLocationTracker.start(); if (fallbackLocationTracker.hasLocation()) { return fallbackLocationTracker.getLocation(); }
neteot

18

รับตำแหน่งของ gps โดย -

LocationManager locationManager = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);

LocationListener locationListener = new LocationListener() 
{

            @Override
            public void onStatusChanged(String provider, int status, Bundle extras) {
                // TODO Auto-generated method stub

            }

            @Override
            public void onProviderEnabled(String provider) {
                // TODO Auto-generated method stub

            }

            @Override
            public void onProviderDisabled(String provider) {
                // TODO Auto-generated method stub

            }

            @Override
            public void onLocationChanged(Location location) {
                // TODO Auto-generated method stub
                double latitude = location.getLatitude();
                double longitude = location.getLongitude();
                double speed = location.getSpeed(); //spedd in meter/minute
                speed = (speed*3600)/1000;      // speed in km/minute               Toast.makeText(GraphViews.this, "Current speed:" + location.getSpeed(),Toast.LENGTH_SHORT).show();
            }
        };

        locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, locationListener);

}

2
เป้าหมายคือรหัสที่แม่นยำน้อยกว่าเสมอและไม่หักโหมการตรวจสอบตำแหน่งอย่างง่ายเหมือนคำตอบอื่น ๆ มากมาย ขอบคุณที่ตอบคำถามที่ถูกถามจริง
SmulianJulian

วิธีรับตำแหน่งทุก 1 วินาที
Ruchir Baronia

ขอบคุณสำหรับวิธีง่ายๆในการรับ GPS มันใช้งานได้! A microbug: location.getSpeed()ส่งคืนความเร็วเป็นเมตร / วินาที (ไม่ใช่เมตร / นาที)
Spectorsky

16

คุณต้องใช้ล่าสุด / ใหม่ล่าสุด

GoogleApiClient Api

โดยทั่วไปสิ่งที่คุณต้องทำคือ:

private GoogleApiClient mGoogleApiClient;
mGoogleApiClient = new GoogleApiClient.Builder(this)
                .addApi(LocationServices.API)
                .addConnectionCallbacks(this)
                .addOnConnectionFailedListener(this)
                .build();

แล้วก็

@Override
    public void onConnected(Bundle connectionHint) {
        mLastLocation = LocationServices.FusedLocationApi.getLastLocation(
                mGoogleApiClient);
        if (mLastLocation != null) {
            mLatitudeText.setText(String.valueOf(mLastLocation.getLatitude()));
            mLongitudeText.setText(String.valueOf(mLastLocation.getLongitude()));
        }
    }

สำหรับตำแหน่งที่แม่นยำและเชื่อถือได้มากที่สุด ดูโพสต์ของฉันที่นี่:

https://stackoverflow.com/a/33599228/2644905

อย่าใช้ LocationListener ซึ่งไม่ถูกต้องและตอบสนองล่าช้า พูดตามตรงนี่เป็นวิธีที่ง่ายกว่า อ่านเอกสารประกอบ: https://developers.google.com/android/reference/com/google/android/gms/common/api/GoogleApiClient


1
นี่คือคำตอบที่ดีที่สุดสำหรับ API ล่าสุด
dramzy

1
ใช่. นี่เป็นวิธีที่ถูกต้องที่จะทำวันนี้ @nickfox ได้ให้ลิงก์ที่ดีในคำตอบที่สองของเขากับคำถามนี้จากผู้สร้างดั้งเดิมของ Location Services API ซึ่งคุ้มค่าที่จะเช็คเอาท์
gMale

11
class MyLocation {
    Timer timer1;
    LocationManager lm;
    LocationResult locationResult;
    boolean gps_enabled = false;
    boolean network_enabled = false;

    public boolean getLocation(Context context, LocationResult result) {
        // I use LocationResult callback class to pass location value from
        // MyLocation to user code.
        locationResult = result;
        if (lm == null)
            lm = (LocationManager) context
                    .getSystemService(Context.LOCATION_SERVICE);

        // Exceptions will be thrown if the provider is not permitted.
        try {
            gps_enabled = lm.isProviderEnabled(LocationManager.GPS_PROVIDER);
        }
        catch (Exception ex) {
        }
        try {
            network_enabled = lm
                    .isProviderEnabled(LocationManager.NETWORK_PROVIDER);
        }
        catch (Exception ex) {
        }

        // Don't start listeners if no provider is enabled.
        if (!gps_enabled && !network_enabled)
            return false;

        if (gps_enabled)
            lm.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0,
                    locationListenerGps);
        if (network_enabled)
            lm.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 0, 0,
                    locationListenerNetwork);
        timer1 = new Timer();
        timer1.schedule(new GetLastLocation(), 5000);
        return true;
    }

    LocationListener locationListenerGps = new LocationListener() {
        public void onLocationChanged(Location location) {
            timer1.cancel();
            locationResult.gotLocation(location);
            lm.removeUpdates(this);
            lm.removeUpdates(locationListenerNetwork);
        }

        public void onProviderDisabled(String provider) {
        }

        public void onProviderEnabled(String provider) {
        }

        public void onStatusChanged(String provider, int status, Bundle extras) {
        }
    };

    LocationListener locationListenerNetwork = new LocationListener() {
        public void onLocationChanged(Location location) {
            timer1.cancel();
            locationResult.gotLocation(location);
            lm.removeUpdates(this);
            lm.removeUpdates(locationListenerGps);
        }

        public void onProviderDisabled(String provider) {
        }

        public void onProviderEnabled(String provider) {
        }

        public void onStatusChanged(String provider, int status, Bundle extras) {
        }
    };

    class GetLastLocation extends TimerTask {
        @Override
        public void run() {
            lm.removeUpdates(locationListenerGps);
            lm.removeUpdates(locationListenerNetwork);

            Location net_loc = null, gps_loc = null;
            if (gps_enabled)
                gps_loc = lm.getLastKnownLocation(LocationManager.GPS_PROVIDER);
            if (network_enabled)
                net_loc = lm
                        .getLastKnownLocation(LocationManager.NETWORK_PROVIDER);

            // If there are both values, use the latest one.
            if (gps_loc != null && net_loc != null) {
                if (gps_loc.getTime() > net_loc.getTime())
                    locationResult.gotLocation(gps_loc);
                else
                    locationResult.gotLocation(net_loc);
                return;
            }

            if (gps_loc != null) {
                locationResult.gotLocation(gps_loc);
                return;
            }
            if (net_loc != null) {
                locationResult.gotLocation(net_loc);
                return;
            }
            locationResult.gotLocation(null);
        }
    }

    public static abstract class LocationResult {
        public abstract void gotLocation(Location location);
    }
}

ฉันหวังว่านี่จะช่วยคุณ ...


1
อย่าลืมเพิ่มบรรทัดต่อไปนี้ในไฟล์ AndroidManifest ของคุณ:<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
Dr. Failov

7

ขณะนี้บริการตำแหน่งของ Google Playอยู่ที่นี่แล้วฉันขอแนะนำให้นักพัฒนาซอฟต์แวร์เริ่มใช้ผู้ให้บริการตำแหน่งแบบหลอมรวมใหม่ คุณจะพบว่าใช้งานง่ายและแม่นยำยิ่งขึ้น โปรดดูGoogle I / Oวิดีโอนอกเหนือจากจุดสีน้ำเงิน: คุณสมบัติใหม่ใน Android ที่ตั้งโดยสองคนที่สร้างการบริการสถานที่เล่นใหม่ API ของ Google

ฉันได้ทำงานกับตำแหน่ง API บนแพลตฟอร์มมือถือจำนวนหนึ่งและฉันคิดว่าสิ่งที่ชายสองคนนี้ทำคือการปฏิวัติจริง ๆ มันกำจัดความซับซ้อนของการใช้ผู้ให้บริการที่หลากหลาย กองซ้อนล้นเกลื่อนไปด้วยคำถามเกี่ยวกับผู้ให้บริการที่จะใช้ไม่ว่าจะใช้สถานที่ที่รู้จักล่าสุดวิธีการตั้งค่าคุณสมบัติอื่น ๆ ใน LocationManager ฯลฯ API ใหม่นี้ที่พวกเขาได้สร้างลบความไม่แน่นอนเหล่านั้นมากที่สุดและทำให้บริการสถานที่ ใช้.

ผมเคยเขียน app Android ที่ได้รับเป็นระยะ ๆ สถานที่โดยใช้ Google บริการสถานที่เล่นและสถานที่ส่งไปยังเว็บเซิร์ฟเวอร์ที่มันจะถูกเก็บไว้ในฐานข้อมูลและสามารถดูได้บนGoogle Maps ฉันเขียนทั้งซอฟต์แวร์ไคลเอ็นต์ (สำหรับ Android, iOS, Windows Phone และJava ME ) และซอฟต์แวร์เซิร์ฟเวอร์ (สำหรับ ASP.NET และSQL ServerหรือPHPและMySQL ) ซอฟต์แวร์เขียนเป็นภาษาท้องถิ่นในแต่ละแพลตฟอร์มและทำงานอย่างเหมาะสมในพื้นหลังของแต่ละแพลตฟอร์ม สุดท้ายซอฟต์แวร์ที่มีใบอนุญาตเอ็มไอที คุณสามารถค้นหาไคลเอนต์ Android ได้ที่นี่:

https://github.com/nickfox/GpsTracker/tree/master/phoneClients/android


7

ง่ายที่สุดที่คุณสามารถหาได้

   package com.javapapers.android.geolocationfinder;

    import android.os.Bundle;
    import android.app.Activity;
    import android.content.Context;
    import android.location.Location;
    import android.location.LocationListener;
    import android.location.LocationManager;
    import android.widget.TextView;

    import android.util.Log;

    public class MainActivity extends Activity implements LocationListener{
    protected LocationManager locationManager;
    protected LocationListener locationListener;
    protected Context context;
    TextView txtLat;
    String lat;
    String provider;
    protected String latitude,longitude; 
    protected boolean gps_enabled,network_enabled;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    txtLat = (TextView) findViewById(R.id.textview1);

    locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
    locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, this);
    }
    @Override
    public void onLocationChanged(Location location) {
    txtLat = (TextView) findViewById(R.id.textview1);
    txtLat.setText("Latitude:" + location.getLatitude() + ", Longitude:" + location.getLongitude());
    }

    @Override
    public void onProviderDisabled(String provider) {
    Log.d("Latitude","disable");
    }

    @Override
    public void onProviderEnabled(String provider) {
    Log.d("Latitude","enable");
    }

    @Override
    public void onStatusChanged(String provider, int status, Bundle extras) {
    Log.d("Latitude","status");
    }
    }

6

LocationManager เป็นคลาสที่ให้วิธีการในการสร้างเพื่อรับทราบตำแหน่งล่าสุด

ขั้นตอนที่ 1: สร้างวัตถุ LocationManager ดังต่อไปนี้

LocationManager locationManager = (LocationManager) context.getSystemService (Context.LOCATION_SERVICE);

ขั้นตอนที่ 2: เพิ่มเกณฑ์

*Criteria is use for setting accuracy*

Criteria criteria = new Criteria();
int currentapiVersion = android.os.Build.VERSION.SDK_INT;

if (currentapiVersion >= android.os.Build.VERSION_CODES.HONEYCOMB) {

    criteria.setSpeedAccuracy(Criteria.ACCURACY_HIGH);
    criteria.setAccuracy(Criteria.ACCURACY_FINE);
    criteria.setAltitudeRequired(true);
    criteria.setBearingRequired(true);
    criteria.setSpeedRequired(true);

}

ขั้นตอนที่ 3: รับผู้ให้บริการที่มีอยู่

Threre เป็นผู้ให้บริการ GPS และเครือข่ายสองประเภท

 String provider = locationManager.getBestProvider(criteria, true);

ขั้นตอนที่ 4: รับทราบตำแหน่งล่าสุด

Location location = locationManager.getLastKnownLocation(provider);

ขั้นตอนที่ 5: รับละติจูดและลองจิจูด

ถ้าวัตถุสถานที่ตั้งเป็นโมฆะแล้วอย่าพยายามที่จะโทรด้านล่างวิธี s

getLatitude and getLongitude is methods which returns double values


6

การรับการอัปเดตตำแหน่งต้องใช้รหัส bolierplate จำนวนมากใน Android คุณต้องดูแล

  • บริการตรวจสอบความพร้อมใช้งานของ Google Play
  • อัปเดตบริการ Google play หากเป็นรุ่นเก่าหรือใช้งานไม่ได้
  • กล่องโต้ตอบการสร้าง GoogleApiClient และการโทรกลับที่เชื่อมต่อถูกตัดการเชื่อมต่อ ฯลฯ
  • การหยุดและปล่อยทรัพยากรสำหรับการอัปเดตตำแหน่ง
  • การจัดการสถานการณ์การอนุญาตสถานที่
  • การตรวจสอบบริการระบุตำแหน่งเป็นเปิดหรือปิด
  • การหาที่ตั้งล่าสุดไม่ใช่เรื่องง่าย
  • ย้อนกลับไปยังตำแหน่งที่รู้จักล่าสุดหากไม่ได้รับตำแหน่งหลังจากระยะเวลาหนึ่ง

เพื่อให้ง่ายต่อทุกขั้นตอนเหล่านี้ฉันได้สร้างAndroid-EasyLocation (ห้องสมุด Android ขนาดเล็ก)ซึ่งจะดูแลทุกสิ่งนี้และคุณสามารถมุ่งเน้นไปที่ตรรกะทางธุรกิจ

สิ่งที่คุณต้องการคือขยายEasyLocationActivityและสิ่งนี้

requestSingleLocationFix(easyLocationRequest);

หรือ

requestLocationUpdates(easyLocationRequest);

ชำระเงินแอปตัวอย่างและขั้นตอนที่จำเป็นที่นี่ที่https://github.com/akhgupta/Android-EasyLocation


5

ฉันได้ทำโครงการที่เราสามารถรับตำแหน่งที่ถูกต้องโดยใช้บริการ Google Play, GPS และผู้ให้บริการเครือข่าย โครงการนี้สามารถพบได้ที่นี่

กลยุทธ์ในการค้นหาตำแหน่งที่ดีที่สุดคืออันดับแรกรับบริการจาก google play หากพบตำแหน่งแล้วตรวจสอบสภาพอากาศว่าดีกว่าหรือไม่หากตำแหน่งพบเป็น null ให้เริ่มบริการ Google play แล้วลองดึงตำแหน่งจาก API ตำแหน่ง Android ลงทะเบียนตำแหน่งบนผู้ฟังการเปลี่ยนแปลงและเมื่อพบตำแหน่งที่ดีกว่าการโทรกลับจะส่งกลับไปยังกิจกรรมหลัก

มันเป็นเรื่องง่ายมากที่จะใช้และดำเนินการในรหัสเพียงสองชั้นเรียนเราต้องฝังเช่นLocationManagerInterfaceและSmartLocationManager, LocationActivityคือการใช้อินเตอร์เฟซและการใช้ SmartLocationManager สามารถดึงข้อมูลสถานที่ตั้ง

/**
 * Created by Syed Raza Mehdi Naqvi on 8/10/2016.
 */
public interface LocationManagerInterface {
    String TAG = LocationManagerInterface.class.getSimpleName();

    void locationFetched(Location mLocation, Location oldLocation, String time, String locationProvider);

}

นี่คือคลาสตัวจัดการตำแหน่ง

import android.Manifest;
import android.app.Activity;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.IntentSender;
import android.content.pm.PackageManager;
import android.location.Location;
import android.location.LocationManager;
import android.os.Build;
import android.os.Bundle;
import android.support.v4.app.ActivityCompat;
import android.support.v4.content.ContextCompat;
import android.support.v7.app.AlertDialog;
import android.util.Log;
import android.widget.Toast;

import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.GooglePlayServicesUtil;
import com.google.android.gms.common.api.GoogleApiClient;
import com.google.android.gms.location.LocationListener;
import com.google.android.gms.location.LocationRequest;
import com.google.android.gms.location.LocationServices;

import java.text.DateFormat;
import java.util.Date;

/**
 * Created by Syed Raza Mehdi Naqvi on 8/9/2016.
 */
public class SmartLocationManager implements
        GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener, LocationListener {

    private static final String TAG = SmartLocationManager.class.getSimpleName();

    private static final int TWO_MINUTES = 1000 * 60 * 2;
    private static final int PERMISSION_REQUEST_CODE = 1000;
    private static final int CONNECTION_FAILURE_RESOLUTION_REQUEST = 9000;

    // default value is false but user can change it
    private String mLastLocationUpdateTime;                                                         // fetched location time
    private String locationProvider;                                                                // source of fetched location

    private Location mLastLocationFetched;                                                          // location fetched
    private Location mLocationFetched;                                                              // location fetched
    private Location networkLocation;
    private Location gpsLocation;

    private int mLocationPiority;
    private long mLocationFetchInterval;
    private long mFastestLocationFetchInterval;

    private Context mContext;                                                                       // application context
    private Activity mActivity;                                                                     // activity context
    private LocationRequest mLocationRequest;
    private GoogleApiClient mGoogleApiClient;
    private LocationManagerInterface mLocationManagerInterface;

    private android.location.LocationManager locationManager;
    private android.location.LocationListener locationListener;

    boolean isGPSEnabled;
    boolean isNetworkEnabled;

    private int mProviderType;
    public static final int NETWORK_PROVIDER = 1;
    public static final int ALL_PROVIDERS = 0;
    public static final int GPS_PROVIDER = 2;

//    private final double STANDARD_LOCATION_ACCURACY = 100.0;
//    private final double STANDARD_LOCATION_SEED_LIMIT = 6.95;

    public static final int LOCATION_PROVIDER_ALL_RESTICTION = 1;
    public static final int LOCATION_PROVIDER_RESTRICTION_NONE = 0;
    public static final int LOCATION_PROVIDER_GPS_ONLY_RESTICTION = 2;
    public static final int LOCATION_PROVIDER_NETWORK_ONLY_RESTICTION = 3;
    private int mForceNetworkProviders = 0;

    public SmartLocationManager(Context context, Activity activity, LocationManagerInterface locationInterface, int providerType, int locationPiority, long locationFetchInterval, long fastestLocationFetchInterval, int forceNetworkProviders) {
        mContext = context;
        mActivity = activity;
        mProviderType = providerType;

        mLocationPiority = locationPiority;
        mForceNetworkProviders = forceNetworkProviders;
        mLocationFetchInterval = locationFetchInterval;
        mFastestLocationFetchInterval = fastestLocationFetchInterval;

        mLocationManagerInterface = locationInterface;

        initSmartLocationManager();
    }


    public void initSmartLocationManager() {

        // 1) ask for permission for Android 6 above to avoid crash
        // 2) check if gps is available
        // 3) get location using awesome strategy

        askLocationPermission();                            // for android version 6 above
        checkNetworkProviderEnable(mForceNetworkProviders);                       //

        if (isGooglePlayServicesAvailable())                // if googleplay services available
            initLocationObjts();                            // init obj for google play service and start fetching location
        else
            getLocationUsingAndroidAPI();                   // otherwise get location using Android API
    }

    private void initLocationObjts() {
        // Create the LocationRequest object
        mLocationRequest = LocationRequest.create()
                .setPriority(mLocationPiority)
                .setInterval(mLocationFetchInterval)                    // 10 seconds, in milliseconds
                .setFastestInterval(mFastestLocationFetchInterval);     // 1 second, in milliseconds

        if (mGoogleApiClient == null) {
            mGoogleApiClient = new GoogleApiClient.Builder(mActivity)
                    .addConnectionCallbacks(this)
                    .addOnConnectionFailedListener(this)
                    .addApi(LocationServices.API)
                    .build();
        }

        startLocationFetching();                                        // connect google play services to fetch location
    }

    @Override
    public void onConnected(Bundle connectionHint) {
        Location location = LocationServices.FusedLocationApi.getLastLocation(mGoogleApiClient);
        startLocationUpdates();
        if (location == null) {
            LocationServices.FusedLocationApi.requestLocationUpdates(mGoogleApiClient, mLocationRequest, this);
            getLocationUsingAndroidAPI();
        } else {
            setNewLocation(getBetterLocation(location, mLocationFetched), mLocationFetched);
        }
    }

    @Override
    public void onLocationChanged(Location location) {
        if (location == null) {
            getLastKnownLocation();
        } else {
            setNewLocation(getBetterLocation(location, mLocationFetched), mLocationFetched);
        }
    }

    @Override
    public void onConnectionSuspended(int i) {
        Log.i(TAG, "Connection suspended");
    }

    @Override
    public void onConnectionFailed(ConnectionResult connectionResult) {
        if (connectionResult.hasResolution()) {
            try {
                connectionResult.startResolutionForResult(mActivity, CONNECTION_FAILURE_RESOLUTION_REQUEST); // Start an Activity that tries to resolve the error
                getLocationUsingAndroidAPI();                                                                // try to get location using Android API locationManager
            } catch (IntentSender.SendIntentException e) {
                e.printStackTrace();
            }
        } else {
            Log.i(TAG, "Location services connection failed with code " + connectionResult.getErrorCode());
        }
    }

    private void setNewLocation(Location location, Location oldLocation) {
        if (location != null) {
            mLastLocationFetched = oldLocation;
            mLocationFetched = location;
            mLastLocationUpdateTime = DateFormat.getTimeInstance().format(new Date());
            locationProvider = location.getProvider();
            mLocationManagerInterface.locationFetched(location, mLastLocationFetched, mLastLocationUpdateTime, location.getProvider());
        }
    }

    private void getLocationUsingAndroidAPI() {
        // Acquire a reference to the system Location Manager
        locationManager = (LocationManager) mContext.getSystemService(Context.LOCATION_SERVICE);

        setLocationListner();
        captureLocation();
    }

    public void captureLocation() {
        if (Build.VERSION.SDK_INT >= 23 &&
                ContextCompat.checkSelfPermission(mContext, android.Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED &&
                ContextCompat.checkSelfPermission(mContext, android.Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            return;
        }
        try {
            if (mProviderType == SmartLocationManager.GPS_PROVIDER) {
                locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, locationListener);
            } else if (mProviderType == SmartLocationManager.NETWORK_PROVIDER) {
                locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 0, 0, locationListener);
            } else {
                locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 0, 0, locationListener);
                locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, locationListener);
            }
        } catch (Exception e) {
            Log.e(TAG, e.getMessage());
        }
    }

    private void setLocationListner() {
        // Define a listener that responds to location updates
        locationListener = new android.location.LocationListener() {
            public void onLocationChanged(Location location) {
                // Called when a new location is found by the network location provider.
                if (location == null) {
                    getLastKnownLocation();
                } else {
                    setNewLocation(getBetterLocation(location, mLocationFetched), mLocationFetched);
//                    if (isLocationAccurate(location) && location.getAccuracy() < STANDARD_LOCATION_ACCURACY && location.getSpeed() < STANDARD_LOCATION_SEED_LIMIT) {// no use of this if
//                        setNewLocation(getBetterLocation(location, mLocationFetched), mLocationFetched);
//                    } else {
//                        setNewLocation(getBetterLocation(location, mLocationFetched), mLocationFetched);
//                    }
                }
            }

            public void onStatusChanged(String provider, int status, Bundle extras) {
            }

            public void onProviderEnabled(String provider) {
            }

            public void onProviderDisabled(String provider) {
            }
        };
    }

    public Location getAccurateLocation() {
        if (Build.VERSION.SDK_INT >= 23 &&
                ContextCompat.checkSelfPermission(mContext, android.Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED &&
                ContextCompat.checkSelfPermission(mContext, android.Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            return null;
        }
        try {
            gpsLocation = locationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER);
            networkLocation = locationManager.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);
            Location newLocalGPS, newLocalNetwork;
            if (gpsLocation != null || networkLocation != null) {
                newLocalGPS = getBetterLocation(mLocationFetched, gpsLocation);
                newLocalNetwork = getBetterLocation(mLocationFetched, networkLocation);
                setNewLocation(getBetterLocation(newLocalGPS, newLocalNetwork), mLocationFetched);
            }
        } catch (Exception ex) {
            Log.e(TAG, ex.getMessage());
        }
        return mLocationFetched;
    }

    protected void startLocationUpdates() {
        LocationServices.FusedLocationApi.requestLocationUpdates(mGoogleApiClient, mLocationRequest, this);
    }

    public void startLocationFetching() {
        mGoogleApiClient.connect();
        if (mGoogleApiClient.isConnected()) {
            startLocationUpdates();
        }
    }

    public void pauseLocationFetching() {
        if (mGoogleApiClient.isConnected()) {
            LocationServices.FusedLocationApi.removeLocationUpdates(mGoogleApiClient, this);
            mGoogleApiClient.disconnect();
        }

    }

    public void abortLocationFetching() {
        mGoogleApiClient.disconnect();

        // Remove the listener you previously added
        if (locationManager != null && locationListener != null) {
            if (Build.VERSION.SDK_INT >= 23 &&
                    ContextCompat.checkSelfPermission(mContext, android.Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED &&
                    ContextCompat.checkSelfPermission(mContext, android.Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
                return;
            }
            try {
                locationManager.removeUpdates(locationListener);
                locationManager = null;
            } catch (Exception ex) {
                Log.e(TAG, ex.getMessage());

            }
        }
    }

    public void resetLocation() {
        mLocationFetched = null;
        mLastLocationFetched = null;
        networkLocation = null;
        gpsLocation = null;
    }

    //  Android M Permission check
    public void askLocationPermission() {

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {


            if (ContextCompat.checkSelfPermission(mActivity, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED
                    || ContextCompat.checkSelfPermission(mActivity, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED
                    ) {
                if (ActivityCompat.shouldShowRequestPermissionRationale(mActivity, Manifest.permission.ACCESS_COARSE_LOCATION)
                        || ActivityCompat.shouldShowRequestPermissionRationale(mActivity, Manifest.permission.ACCESS_FINE_LOCATION)) {

                    final AlertDialog.Builder builder = new AlertDialog.Builder(mActivity);
                    builder.setMessage("Please allow all permissions in App Settings for additional functionality.")
                            .setCancelable(false)
                            .setPositiveButton("Allow", new DialogInterface.OnClickListener() {
                                public void onClick(@SuppressWarnings("unused") final DialogInterface dialog, @SuppressWarnings("unused") final int id) {
                                    Toast.makeText(mContext, "Welcome", Toast.LENGTH_SHORT).show();
                                }
                            })
                            .setNegativeButton("Deny", new DialogInterface.OnClickListener() {
                                public void onClick(final DialogInterface dialog, @SuppressWarnings("unused") final int id) {
                                    mActivity.finish();
                                }
                            });
                    final AlertDialog alert = builder.create();
                    alert.show();

                } else
                    ActivityCompat.requestPermissions(mActivity, new String[]{Manifest.permission.ACCESS_COARSE_LOCATION
                            , Manifest.permission.ACCESS_FINE_LOCATION
                    }, PERMISSION_REQUEST_CODE);

            }
        }
    }

    public void checkNetworkProviderEnable(int enforceActive) {
        locationManager = (LocationManager) mContext.getSystemService(Context.LOCATION_SERVICE);

        isGPSEnabled = locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
        isNetworkEnabled = locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);

        if (!isGPSEnabled && !isNetworkEnabled) {
            buildAlertMessageTurnOnLocationProviders("Your location providers seems to be disabled, please enable it", "OK", "Cancel");
        } else if (!isGPSEnabled && mForceNetworkProviders == LOCATION_PROVIDER_GPS_ONLY_RESTICTION) {
            buildAlertMessageTurnOnLocationProviders("Your GPS seems to be disabled, please enable it", "OK", "Cancel");
        } else if (!isNetworkEnabled && mForceNetworkProviders == LOCATION_PROVIDER_NETWORK_ONLY_RESTICTION) {
            buildAlertMessageTurnOnLocationProviders("Your Network location provider seems to be disabled, please enable it", "OK", "Cancel");
        }
        // getting network status

        if (!isGPSEnabled && !isNetworkEnabled) {
            Toast.makeText(mContext, "Location can't be fetched!", Toast.LENGTH_SHORT).show(); // show alert
            mActivity.finish();
        }
    }

    private void buildAlertMessageTurnOnLocationProviders(String message, String positiveButtonText, String negativeButtonText) {
        final AlertDialog.Builder builder = new AlertDialog.Builder(mActivity);
        builder.setMessage(message)
                .setCancelable(false)
                .setPositiveButton(positiveButtonText, new DialogInterface.OnClickListener() {
                    public void onClick(@SuppressWarnings("unused") final DialogInterface dialog, @SuppressWarnings("unused") final int id) {
                        Intent mIntent = new Intent(android.provider.Settings.ACTION_LOCATION_SOURCE_SETTINGS);
                        mIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                        mContext.startActivity(mIntent);
                    }
                })
                .setNegativeButton(negativeButtonText, new DialogInterface.OnClickListener() {
                    public void onClick(final DialogInterface dialog, @SuppressWarnings("unused") final int id) {
                        mActivity.finish();
                    }
                });
        final AlertDialog alert = builder.create();
        alert.show();
    }


    public Location getLastKnownLocation() {
        locationProvider = LocationManager.NETWORK_PROVIDER;
        Location lastKnownLocation = null;
        // Or use LocationManager.GPS_PROVIDER
        if (Build.VERSION.SDK_INT >= 23 &&
                ContextCompat.checkSelfPermission(mContext, android.Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED &&
                ContextCompat.checkSelfPermission(mContext, android.Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            return lastKnownLocation;
        }
        try {
            lastKnownLocation = locationManager.getLastKnownLocation(locationProvider);
            return lastKnownLocation;
        } catch (Exception e) {
            Log.e(TAG, e.getMessage());
        }
        return lastKnownLocation;
    }

    public boolean isGooglePlayServicesAvailable() {
        int status = GooglePlayServicesUtil.isGooglePlayServicesAvailable(mContext);

        if (status == ConnectionResult.SUCCESS) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Determines whether one Location reading is better than the current Location fix
     *
     * @param location            The new Location that you want to evaluate
     * @param currentBestLocation The current Location fix, to which you want to compare the new one
     */
    protected Location getBetterLocation(Location location, Location currentBestLocation) {
        if (currentBestLocation == null) {
            // A new location is always better than no location
            return location;
        }

        // Check whether the new location fix is newer or older
        long timeDelta = location.getTime() - currentBestLocation.getTime();
        boolean isSignificantlyNewer = timeDelta > TWO_MINUTES;
        boolean isSignificantlyOlder = timeDelta < -TWO_MINUTES;
        boolean isNewer = timeDelta > 0;

        // If it's been more than two minutes since the current location, use the new location
        // because the user has likely moved
        if (isSignificantlyNewer) {
            return location;
            // If the new location is more than two minutes older, it must be worse
        } else if (isSignificantlyOlder) {
            return currentBestLocation;
        }

        // Check whether the new location fix is more or less accurate
        int accuracyDelta = (int) (location.getAccuracy() - currentBestLocation.getAccuracy());
        boolean isLessAccurate = accuracyDelta > 0;
        boolean isMoreAccurate = accuracyDelta < 0;
        boolean isSignificantlyLessAccurate = accuracyDelta > 200;

        // Check if the old and new location are from the same provider
        boolean isFromSameProvider = isSameProvider(location.getProvider(),
                currentBestLocation.getProvider());

        // Determine location quality using a combination of timeliness and accuracy
        if (isMoreAccurate) {
            return location;
        } else if (isNewer && !isLessAccurate) {
            return location;
        } else if (isNewer && !isSignificantlyLessAccurate && isFromSameProvider) {
            return location;
        }
        return currentBestLocation;
    }

    /**
     * Checks whether two providers are the same
     */

    private boolean isSameProvider(String provider1, String provider2) {
        if (provider1 == null) {
            return provider2 == null;
        }
        return provider1.equals(provider2);
    }

    public boolean isLocationAccurate(Location location) {
        if (location.hasAccuracy()) {
            return true;
        } else {
            return false;
        }
    }

    public Location getStaleLocation() {
        if (mLastLocationFetched != null) {
            return mLastLocationFetched;
        }
        if (Build.VERSION.SDK_INT >= 23 &&
                ContextCompat.checkSelfPermission(mContext, android.Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED &&
                ContextCompat.checkSelfPermission(mContext, android.Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            return null;
        }
        if (mProviderType == SmartLocationManager.GPS_PROVIDER) {
            return locationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER);
        } else if (mProviderType == SmartLocationManager.NETWORK_PROVIDER) {
            return locationManager.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);
        } else {
            return getBetterLocation(locationManager.getLastKnownLocation(LocationManager.NETWORK_PROVIDER), locationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER));
        }
    }
}

เราสามารถใช้มันกับกิจกรรมหรือส่วนที่นี่ฉันใช้กับกิจกรรม

import android.location.Location;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.widget.TextView;
import android.widget.Toast;

import com.example.raza.locationaware.location.LocationManagerInterface;
import com.example.raza.locationaware.location.SmartLocationManager;
import com.google.android.gms.location.LocationRequest;

public class LocationActivity extends AppCompatActivity implements LocationManagerInterface {

    public static final String TAG = LocationActivity.class.getSimpleName();

    SmartLocationManager mLocationManager;
    TextView mLocalTV, mLocationProviderTV, mlocationTimeTV;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_location);
        mLocationManager = new SmartLocationManager(getApplicationContext(), this, this, SmartLocationManager.ALL_PROVIDERS, LocationRequest.PRIORITY_HIGH_ACCURACY, 10 * 1000, 1 * 1000, SmartLocationManager.LOCATION_PROVIDER_RESTRICTION_NONE); // init location manager
        mLocalTV = (TextView) findViewById(R.id.locationDisplayTV);
        mLocationProviderTV = (TextView) findViewById(R.id.locationProviderTV);
        mlocationTimeTV = (TextView) findViewById(R.id.locationTimeFetchedTV);
    }

    protected void onStart() {
        super.onStart();
        mLocationManager.startLocationFetching();
    }

    protected void onStop() {
        super.onStop();
        mLocationManager.abortLocationFetching();
    }

    @Override
    protected void onPause() {
        super.onPause();
        mLocationManager.pauseLocationFetching();
    }

    @Override
    public void locationFetched(Location mLocal, Location oldLocation, String time, String locationProvider) {
        Toast.makeText(getApplication(), "Lat : " + mLocal.getLatitude() + " Lng : " + mLocal.getLongitude(), Toast.LENGTH_LONG).show();
        mLocalTV.setText("Lat : " + mLocal.getLatitude() + " Lng : " + mLocal.getLongitude());
        mLocationProviderTV.setText(locationProvider);
        mlocationTimeTV.setText(time);
    }
}

หวังว่ามันจะช่วยให้ถ้าคุณสามารถแนะนำการปรับปรุงใด ๆ กรุณาโพสต์บนคอมไพล์ ขอบคุณ


5

GoogleSamplesมีตัวอย่างแบบละเอียดโดยใช้ FusedLocationProviderApi ล่าสุด น่าเสียดายที่คำตอบที่ได้รับการโหวตมากที่สุดล้าสมัย

ทำตามตัวอย่างด้านล่างเพื่อใช้บริการระบุตำแหน่งโดยใช้ FusedLocationProviderApi

https://github.com/googlesamples/android-play-location/tree/master/LocationUpdates

https://github.com/googlesamples/android-play-location/blob/master/LocationUpdates/app/src/main/java/com/google/android/gms/location/sample/locationupdates/MainActivity.java


3

หากคุณกำลังสร้างโครงการสถานที่ใหม่สำหรับ Android คุณควรใช้บริการตำแหน่งGoogle Playใหม่ มีความแม่นยำและใช้งานง่ายกว่ามาก

ฉันทำงานกับGPS tracker project แบบโอเพ่นซอร์ส GpsTracker มาหลายปีแล้ว ฉันเพิ่งอัปเดตเพื่อจัดการอัปเดตเป็นระยะจาก Android, iOS, Windows Phone และJava MEโทรศัพท์มือถือ มันเป็นทำงานอย่างเต็มที่และไม่สิ่งที่คุณต้องการและมีใบอนุญาตเอ็มไอที

โครงการ Android ภายใน GpsTracker ใช้บริการ Google Play ใหม่และมีเซิร์ฟเวอร์สองชุด ( ASP.NETและPHP ) เพื่อให้คุณสามารถติดตามโทรศัพท์เหล่านั้นได้


3
ปัญหาคือว่าอุปกรณ์บางอย่างไม่มีบริการ Google Play รวมถึง ROM ที่กำหนดเองซึ่งไม่ได้ละเมิดลิขสิทธิ์ หากคุณกำลังจะใช้ให้มีตัวเลือกสำรองไปยัง LocationManager พร้อม
Gabe Sechan

3

สำหรับการตรวจสอบตำแหน่งเพียงแค่คุณสามารถใช้รหัสต่อไปนี้ คุณสามารถใส่ไว้ใน onStart () ของกิจกรรมหลักและกล่องโต้ตอบการแจ้งเตือนการแสดงผลถ้ากลับเป็นเท็จ

private boolean isLocationAccurate()
    {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT)
        {
            String provider = Settings.Secure
                    .getString(getContentResolver(), Settings.Secure.LOCATION_PROVIDERS_ALLOWED);
            if (provider != null && !provider.contains("gps"))
            {
                return false;
            }
        }
        else
        {
            try
            {
                int status = Settings.Secure
                        .getInt(this.getContentResolver(), Settings.Secure.LOCATION_MODE);
                if (status != Settings.Secure.LOCATION_MODE_HIGH_ACCURACY)
                {
                    return false;
                }
            }
            catch (Settings.SettingNotFoundException e)
            {
                Log.e(TAG, e.getMessage());
            }
        }

        return true;
    }

3

ฉันมีตำแหน่งที่ถูกต้องมากโดยใช้FusedLocationProviderClient
( จำเป็นต้องใช้บริการ Google Play )

สิทธิ์ที่จำเป็น

android.permission.ACCESS_FINE_LOCATION

android.permission.ACCESS_COARSE_LOCATION

เมืองขึ้น

'com.google.android.gms: เล่นบริการสถานที่: 15.0.0'

รหัส Kotlin

val client = FusedLocationProviderClient(this)
val location = client.lastLocation
location.addOnCompleteListener {
    // this is a lambda expression and we get an 'it' iterator to access the 'result'
    // it.result.latitude gives the latitude
    // it.result.longitude gives the longitude 
    val geocoder = Geocoder(applicationContext, Locale.getDefault())
    val address = geocoder.getFromLocation(it.result.latitude, it.result.longitude, 1)
    if (address != null && address.size > 0) {
        // Get the current city
        city = address[0].locality
    }
}
location.addOnFailureListener {
    // Some error in getting the location, let's log it
    Log.d("xtraces", it.message)
}

3

วิธีที่ดีที่สุดในการดึงข้อมูลตำแหน่งอยู่ด้านล่าง

// put dependancy
 implementation 'com.google.android.gms:play-services-location:11.0.4'

// PUT permissions in Menifest
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" /> 


// create a Java file as below

public class SingleShotLocationProvider {

  public static interface LocationCallback {
      public void onNewLocationAvailable(GPSCoordinates location);
  }

   // calls back to calling thread, note this is for low grain: if you want higher precision, swap the
   // contents of the else and if. Also be sure to check gps permission/settings are allowed.
   // call usually takes <10ms

  public static void requestSingleUpdate(final Context context, final LocationCallback callback) {
    final LocationManager locationManager = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
    boolean isNetworkEnabled = locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
    if (isNetworkEnabled) {
        Criteria criteria = new Criteria();
        criteria.setAccuracy(Criteria.ACCURACY_COARSE);
        if (ActivityCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED &&
                ActivityCompat.checkSelfPermission(context, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {

            return;
        }
        locationManager.requestSingleUpdate(criteria, new LocationListener() {
            @Override
            public void onLocationChanged(Location location) {
                callback.onNewLocationAvailable(new GPSCoordinates(location.getLatitude(), location.getLongitude()));
            }

            @Override
            public void onStatusChanged(String provider, int status, Bundle extras) {
            }

            @Override
            public void onProviderEnabled(String provider) {
            }

            @Override
            public void onProviderDisabled(String provider) {
            }
        }, null);
     } else {
        boolean isGPSEnabled = locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
        if (isGPSEnabled) {
            Criteria criteria = new Criteria();
            criteria.setAccuracy(Criteria.ACCURACY_FINE);
            locationManager.requestSingleUpdate(criteria, new LocationListener() {
                @Override
                public void onLocationChanged(Location location) {
                    callback.onNewLocationAvailable(new GPSCoordinates(location.getLatitude(), location.getLongitude()));
                }

                @Override public void onStatusChanged(String provider, int status, Bundle extras) { }
                @Override public void onProviderEnabled(String provider) { }
                @Override public void onProviderDisabled(String provider) { }
            }, null);
        }
     }
  }


  // consider returning Location instead of this dummy wrapper class
  public static class GPSCoordinates {
     public float longitude = -1;
     public float latitude = -1;

     public GPSCoordinates(float theLatitude, float theLongitude) {
        longitude = theLongitude;
        latitude = theLatitude;
     }

     public GPSCoordinates(double theLatitude, double theLongitude) {
        longitude = (float) theLongitude;
        latitude = (float) theLatitude;
     }
  }

}
// FILE FINISHED


// FETCH LOCATION FROM ACTIVITY AS BELOW
public void getLocation(Context context) {
    MyApplication.log(LOG_TAG, "getLocation() ");

    SingleShotLocationProvider.requestSingleUpdate(context,
            new SingleShotLocationProvider.LocationCallback() {
                @Override
                public void onNewLocationAvailable(SingleShotLocationProvider.GPSCoordinates loc) {
                    location = loc;
                    MyApplication.log(LOG_TAG, "getLocation() LAT: " + location.latitude + ", LON: " + location.longitude);               
                }
            });
}

2

ฉันได้เผยแพร่ไลบรารีขนาดเล็กที่สามารถทำให้ง่ายต่อการรับข้อมูลตำแหน่งที่ตั้งใน Android มันยังดูแลสิทธิ์รันไทม์ Android M

คุณสามารถตรวจสอบได้ที่นี่: https://github.com/julioromano/RxLocationและใช้มันหรือซอร์สโค้ดของมันเป็นตัวอย่างสำหรับการใช้งานของคุณ


มันเป็นทางออกที่ดี แต่ไม่ใช่สิ่งที่ดีที่สุดไม่ได้ใช้เวลาส่วนใหญ่ ฉันไม่ได้รับผลลัพธ์ทันทีหลังจากคลิกปุ่ม
Asif Ali

@AsifAli หากคุณพบข้อผิดพลาดกรุณาเปิดปัญหาหรือส่ง PR
Marco Romano

ไลบรารีนี้เนื่องจากไลบรารีนี้ไม่มีคลาส AbstractSafeParcelable
Vikash Parajuli

2

ง่าย ๆ เขียนรหัสในวิธีการในการตั้ง

public void onLocationChanged(Location location) {
    if (mCurrLocationMarker != null) {
        mCurrLocationMarker.remove();
    }


    //Place current location marker
    LatLng latLng = new LatLng(location.getLatitude(), location.getLongitude());
    MarkerOptions markerOptions = new MarkerOptions();
    markerOptions.position(latLng);
    markerOptions.title("Current Position");
    markerOptions.icon(BitmapDescriptorFactory.defaultMarker(BitmapDescriptorFactory.HUE_RED));
    mCurrLocationMarker = mMap.addMarker(markerOptions);

    //move map camera
    mMap.moveCamera(CameraUpdateFactory.newLatLng(latLng));
    mMap.animateCamera(CameraUpdateFactory.zoomTo(18));

    PolylineOptions pOptions = new PolylineOptions()
            .width(5)
            .color(Color.GREEN)
            .geodesic(true);
    for (int z = 0; z < routePoints.size(); z++) {
        LatLng point = routePoints.get(z);
        pOptions.add(point);
    }
    line = mMap.addPolyline(pOptions);
    routePoints.add(latLng);
}

2

ฉันจะแนะนำให้ใช้ห้องสมุดที่ตั้งสมาร์ทใช้งาน
ง่ายมากและมันครอบคลุมตรรกะของตำแหน่งอย่างชัดเจน

สำหรับการเริ่มบริการตำแหน่ง:

SmartLocation.with(context).location()
    .start(new OnLocationUpdatedListener() { ... });

หากคุณต้องการรับตำแหน่งเดียว (ไม่ใช่เป็นระยะ) คุณสามารถใช้ตัวแก้ไข oneFix ได้ ตัวอย่าง:

SmartLocation.with(context).location()
    .oneFix()
    .start(new OnLocationUpdatedListener() { ... });

0

วิธีที่ง่ายและสะดวก

ได้รับตำแหน่งโดยใช้https://github.com/sachinvarma/EasyLocation

ขั้นตอนที่ 1: เพียงโทร

new EasyLocationInit(MainActivity.this, timeInterval, fastestTimeInterval, runAsBackgroundService);

timeInterval -> setInterval (ยาว) (inMilliSeconds) หมายถึง - ตั้งช่วงเวลาที่คุณต้องการรับตำแหน่ง

soonTimeInterval -> setFastestInterval (ยาว) (inMilliSeconds) หมายถึง - หากมีตำแหน่งให้ใช้เร็วคุณจะได้รับ (เช่นแอปอื่นกำลังใช้บริการระบุตำแหน่ง)

runAsBackgroundService = True -> (บริการจะทำงานในพื้นหลังและอัปเดตบ่อยครั้ง (ตาม timeInterval และ fastTimeInterval)) runAsBackgroundService = False -> (บริการจะได้รับการทำลายหลังจากการอัปเดตตำแหน่งสำเร็จ)

ขั้นตอนที่ 2:จัดเตรียมสมาชิก EventBus: ประกาศและใส่คำอธิบายประกอบวิธีการสมัครของคุณเลือกระบุโหมดเธรด:

เช่น:

     @Override
     public void onStart() {
         super.onStart();
         EventBus.getDefault().register(this);
     }

     @Override
     public void onStop() {
         super.onStop();
         EventBus.getDefault().unregister(this);
     }

  @SuppressLint("SetTextI18n")
  @Subscribe
  public void getEvent(final Event event) {

    if (event instanceof LocationEvent) {
      if (((LocationEvent) event).location != null) {
        ((TextView) findViewById(R.id.tvLocation)).setText("The Latitude is "
          + ((LocationEvent) event).location.getLatitude()
          + " and the Longitude is "
          + ((LocationEvent) event).location.getLongitude());
      }
    }
  }

นั่นคือทั้งหมดที่

หวังว่ามันจะช่วยใครซักคนในอนาคต


0

เมษายน 2563

ขั้นตอนทั้งหมดในการรับตำแหน่งปัจจุบันและหลีกเลี่ยงความถูกต้องของตำแหน่งสุดท้ายที่ทราบ

ตามเอกสารที่เป็นทางการ , อยู่ที่อาจจะเป็นโมฆะในกรณีของ:

  • ตำแหน่งถูกปิดในการตั้งค่าอุปกรณ์ ในขณะที่มันล้างแคช
  • อุปกรณ์ไม่เคยบันทึกตำแหน่งของมัน (อุปกรณ์ใหม่)
  • บริการ Google Play บนอุปกรณ์เริ่มต้นใหม่

ในกรณีนี้คุณควรrequestLocationUpdatesและรับตำแหน่งใหม่ในLocationCallback

ตามขั้นตอนต่อไปนี้ตำแหน่งสุดท้ายที่คุณรู้จักไม่มีวันเป็นโมฆะ


สิ่งที่ต้องมีก่อน: ห้องสมุด EasyPermission


ขั้นตอนที่ 1: ในไฟล์รายการเพิ่มสิทธิ์นี้

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

ขั้นตอนที่ 2:

    override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    //Create location callback when it's ready.
    createLocationCallback()

    //createing location request, how mant request would be requested.
    createLocationRequest()

    //Build check request location setting request
    buildLocationSettingsRequest()

    //FusedLocationApiClient which includes location 
    mFusedLocationClient = LocationServices.getFusedLocationProviderClient(this)
    //Location setting client
    mSettingsClient = LocationServices.getSettingsClient(this)

    //Check if you have ACCESS_FINE_LOCATION permission
    if (!EasyPermissions.hasPermissions(
            this@MainActivity,
            Manifest.permission.ACCESS_FINE_LOCATION)) {
        requestPermissionsRequired()
    }
    else{
        //If you have the permission we should check location is opened or not
        checkLocationIsTurnedOn()
    }

}

ขั้นตอนที่ 3: สร้างฟังก์ชั่นที่ต้องการที่จะเรียกในonCreate ()

private fun requestPermissionsRequired() {
    EasyPermissions.requestPermissions(
        this,
        getString(R.string.location_is_required_msg),
        LOCATION_REQUEST,
        Manifest.permission.ACCESS_FINE_LOCATION
    )
}

private fun createLocationCallback() {
    //Here the location will be updated, when we could access the location we got result on this callback.
    mLocationCallback = object : LocationCallback() {
        override fun onLocationResult(locationResult: LocationResult) {
            super.onLocationResult(locationResult)
            mCurrentLocation = locationResult.lastLocation
        }
    }
}

private fun buildLocationSettingsRequest() {
    val builder = LocationSettingsRequest.Builder()
    builder.addLocationRequest(mLocationRequest!!)
    mLocationSettingsRequest = builder.build()
    builder.setAlwaysShow(true)
}

private fun createLocationRequest() {
    mLocationRequest = LocationRequest.create()
    mLocationRequest!!.interval = 0
    mLocationRequest!!.fastestInterval = 0
    mLocationRequest!!.numUpdates = 1
    mLocationRequest!!.priority = LocationRequest.PRIORITY_HIGH_ACCURACY
}

public fun checkLocationIsTurnedOn() { // Begin by checking if the device has the necessary location settings.
    mSettingsClient!!.checkLocationSettings(mLocationSettingsRequest)
        .addOnSuccessListener(this) {
            Log.i(TAG, "All location settings are satisfied.")
            startLocationUpdates()
        }
        .addOnFailureListener(this) { e ->
            val statusCode = (e as ApiException).statusCode
            when (statusCode) {
                LocationSettingsStatusCodes.RESOLUTION_REQUIRED -> {
                    try {
                        val rae = e as ResolvableApiException
                        rae.startResolutionForResult(this@MainActivity, LOCATION_IS_OPENED_CODE)
                    } catch (sie: IntentSender.SendIntentException) {
                    }
                }
                LocationSettingsStatusCodes.SETTINGS_CHANGE_UNAVAILABLE -> {
                    mRequestingLocationUpdates = false
                }
            }
        }
}

private fun startLocationUpdates() {
    mFusedLocationClient!!.requestLocationUpdates(
        mLocationRequest,
        mLocationCallback, null
    )
}

ขั้นตอนที่ 4:

จัดการการเรียกกลับในonActivityResult ()หลังจากตรวจสอบตำแหน่งที่เปิดหรือผู้ใช้ยอมรับเพื่อเปิด

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
    when (requestCode) {
        LOCATION_IS_OPENED_CODE -> {
            if (resultCode == AppCompatActivity.RESULT_OK) {
                Log.d(TAG, "Location result is OK")
            } else {
                activity?.finish()
            }
        }
}

ขั้นตอนที่ 5: รับตำแหน่งที่ทราบล่าสุดจาก FusedClientApi

override fun onMapReady(map: GoogleMap) {
    mMap = map
    mFusedLocationClient.lastLocation.addOnSuccessListener {
        if(it!=null){
            locateUserInMap(it)
        }
    }

}
   private fun locateUserInMap(location: Location) {
    showLocationSafetyInformation()
    if(mMap!=null){
        val currentLocation = LatLng(location.latitude,location.longitude )
        addMarker(currentLocation)
    }
}


private fun addMarker(currentLocation: LatLng) {
    val cameraUpdate = CameraUpdateFactory.newLatLng(currentLocation)
    mMap?.clear()
    mMap?.addMarker(
        MarkerOptions().position(currentLocation)
            .title("Current Location")
    )
    mMap?.moveCamera(cameraUpdate)
    mMap?.animateCamera(cameraUpdate)
    mMap?.setMinZoomPreference(14.0f);
}

ฉันหวังว่านี่จะช่วยได้

Happy Coding 🤓

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.