অ্যান্ড্রয়েডে ব্যবহারকারীর বর্তমান অবস্থান পাওয়ার সহজতম এবং শক্তিশালী উপায় কী?


811

LocationManagerAndroid এর উপর এপিআই বলে মনে হয় এটা একটা ব্যথা একটি অ্যাপ্লিকেশন যে শুধুমাত্র ব্যবহারকারীর অবস্থানের একটি অনিয়মিত ও রুক্ষ পড়তা দরকার জন্য ব্যবহার করতে একটি বিট মত।

আমি যে অ্যাপটিতে কাজ করছি সেটি আসলে প্রতি সেচের কোনও অবস্থানের অ্যাপ্লিকেশন নয়, তবে আশেপাশের ব্যবসায়ের তালিকা প্রদর্শনের জন্য এটির ব্যবহারকারীর অবস্থান পাওয়া দরকার। ব্যবহারকারী ঘুরে বেড়াচ্ছে বা এর মতো কিছু আছে কিনা তা নিয়ে চিন্তা করার দরকার নেই।

আমি যা করতে চাই তা এখানে:

  1. ব্যবহারকারীকে কাছের অবস্থানের একটি তালিকা দেখান।
  2. ব্যবহারকারীর অবস্থানটি প্রাক লোড করুন যাতে Activityএক্স এর মধ্যে আমার এটির প্রয়োজনের সময় এটি উপলব্ধ হয়ে যায়।
  3. আমি বিশেষত সঠিকতার বা আপডেটের ফ্রিকোয়েন্সি সম্পর্কে যত্ন নিই না। যতক্ষণ না এটি বন্ধ না হয় কেবল একটি অবস্থান দখল করা যথেষ্ট sufficient হতে পারে যদি আমি অভিনব হতে চাই তবে আমি প্রতি কয়েক মিনিট পরে একবারে অবস্থানটি আপডেট করব তবে এটি কোনও বিশাল অগ্রাধিকার নয়।
  4. যেকোন ডিভাইসের জন্য কাজ করুন যতক্ষণ না এটিতে জিপিএস বা কোনও নেটওয়ার্ক অবস্থান প্রদানকারী রয়েছে।

দেখে মনে হচ্ছে এটির মতো শক্ত হওয়া উচিত নয়, তবে আমার কাছে মনে হয়েছে যে আমাকে দুটি পৃথক অবস্থান সরবরাহকারী (জিপিএস এবং নেটওয়র্ক) স্পিন করতে হবে এবং প্রত্যেকের জীবনচক্র পরিচালনা করতে হবে। শুধু তাই নয়, # 2 সন্তুষ্ট করতে আমাকে একাধিক ক্রিয়াকলাপে একই কোডটির নকল করতে হবে। আমি getBestProvider()অতীতে সমাধানটি কেবলমাত্র একটি অবস্থান সরবরাহকারীর সাহায্যে কাটতে চেষ্টা করেছি , তবে এটি কেবল আপনাকে সেরা ফলাফল দেবে বলে সরবরাহকারীর চেয়ে কেবল আপনাকে সেরা "তাত্ত্বিক" সরবরাহকারী বলে মনে হয়।

এটি সম্পাদন করার সহজ উপায় কি আছে?


5
এখানে আপনি জিপিএস, চিয়ার্সের জন্য নমুনা কোড সহ ধাপে ধাপে টিউটোরিয়ালটি পেতে পারেন!
সুইফটবয়

1
আপনি একটি সহজ লাইব্রেরি ব্যবহার করতে পারে যে দূরে বিমূর্ত সবকিছুর যে "ফণা অধীনে" ঘটতে হবে: github.com/delight-im/Android-SimpleLocation
কাকের ডাক

2018 এ এটি ফিউজড লোকেশনপ্রোভাডার ক্লায়েন্ট উদাহরণ পটভূমি অবস্থান আপডেটের জন্য freakyjolly.com/…
কোড স্পাই

: এখানে Kotlin মধ্যে উত্তর পেতে stackoverflow.com/a/53800632/2201814
MHSFisher

আপনি অ্যান্ড্রয়েডে ফিউজড লোকেশন ক্যাপচারিং কৌশলগুলি ব্যবহার করতে পারেন।
SIVAKUMAR.J

উত্তর:


946

আমি যা করি তা এখানে:

  1. সবার আগে আমি যা যা সরবরাহকারী সক্ষম হয় তা যাচাই করে নিই। কিছু ডিভাইসে অক্ষম হতে পারে, কিছু অ্যাপ্লিকেশন ম্যানিফেস্টে অক্ষম হতে পারে।
  2. যদি কোনও সরবরাহকারীর উপলভ্য থাকে তবে আমি অবস্থান শ্রোতা এবং টাইমআউট টাইমার শুরু করি। এটি আমার উদাহরণের 20 সেকেন্ড, জিপিএসের পক্ষে যথেষ্ট নাও হতে পারে তাই আপনি এটিকে বড় করতে পারেন।
  3. যদি আমি অবস্থান শ্রোতার কাছ থেকে আপডেট পাই তবে আমি সরবরাহিত মানটি ব্যবহার করি। আমি শ্রোতা এবং টাইমার বন্ধ।
  4. যদি আমি কোনও আপডেট এবং টাইমার ব্যয় না পাই তবে আমাকে সর্বশেষ জ্ঞাত মানগুলি ব্যবহার করতে হবে।
  5. আমি উপলভ্য সরবরাহকারীদের কাছ থেকে সর্বশেষ জ্ঞাত মানগুলি ধরে নিয়েছি এবং সেগুলির মধ্যে সবচেয়ে সাম্প্রতিকটি চয়ন করি।

আমি এখানে আমার ক্লাসটি কীভাবে ব্যবহার করব তা এখানে:

LocationResult locationResult = new LocationResult(){
    @Override
    public void gotLocation(Location location){
        //Got the location!
    }
};
MyLocation myLocation = new MyLocation();
myLocation.getLocation(this, locationResult);

এবং এখানে MyLocation ক্লাস:

import java.util.Timer;
import java.util.TimerTask;
import android.content.Context;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.Bundle;

public 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 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(), 20000);
        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);
    }
}

কেউ কেউ আমার যুক্তি সংশোধন করতে চাইবে। উদাহরণস্বরূপ, যদি আপনি নেটওয়ার্ক সরবরাহকারীর কাছ থেকে আপডেট পান শ্রোতাদের থামান না তবে অপেক্ষা করা চালিয়ে যান। জিপিএস আরও নির্ভুল ডেটা দেয় তাই এটির জন্য অপেক্ষা করার মতো। যদি টাইমার বিস্তৃত হয় এবং আপনি নেটওয়ার্ক থেকে আপডেট পেয়েছেন তবে জিপিএস থেকে নয় তবে আপনি নেটওয়ার্ক থেকে সরবরাহিত মানটি ব্যবহার করতে পারেন।

আর একটি পদ্ধতির অবস্থান হ'ল লোকেশনক্লায়েন্ট http://developer.android.com/training/location/retrieve-current.html ব্যবহার করুন । তবে এর জন্য গুগল প্লে পরিষেবাদি এপিপি ব্যবহারকারীর ডিভাইসে ইনস্টল করা দরকার।


7
রেকর্ডের জন্য, আমার বোধগম্যতা হ'ল গুগল সাধারণত অ্যান্ড্রয়েড: কনফিগার চেঞ্জ ব্যবহার করার বিরুদ্ধে সুপারিশ করে। পরিবর্তে আমি এমন একটি সমাধান নিয়ে গিয়েছি যা টাইমারটাস্কগুলি নিবন্ধভুক্ত করে এবং অনডাস্ট্রয়ে তাদের বাতিল করে।
emmby

5
এই সাধারণ ক্লাসটি আমার সাধারণ অ্যাপ্লিকেশনটিতে ব্যবহার করুন এবং এটি চ্যাম্পের মতো কাজ করে। এটি পোস্ট করার জন্য ধন্যবাদ!
অ্যালেক্স প্রিচার্ড

46
এটি আমার জন্য কাজ করে মহান! যাইহোক, আমি যে ক্রিয়াকলাপটি আমার জন্য এটি ব্যবহার করেছি তা পুনরারম্ভের স্থানটি পরীক্ষা করে। যদি অবস্থানটি ফিরে আসার আগে ব্যবহারকারী ক্রিয়াকলাপটি থেকে সরে দাঁড়ায় তবে অ্যাপ্লিকেশন ক্রাশ হবে। আমি আপনার MyLocation শ্রেণিতে এই পদ্ধতিটি যুক্ত করে এটি সংশোধন করেছি ublic গণতান্ত্রিক শূন্য বাতিল বাতিলকরণের () r টাইমার 1.cancel (); lm.removeUpdates (locationListenerGps); lm.removeUpdates (locationListenerNetwork); } আমি এটি অনপস () বলি এবং এটি ক্রাশ স্থির করে।
dbaugh

14
আরে আমি বাণিজ্যিক উদ্দেশ্যে আমার আবেদনে আপনার কোডটি ব্যবহার করতে পারি। সে সম্পর্কে আপনার কোনও অভিযোগ থাকলে দয়া করে আমাকে জানান।
TRONZ

87
@ টিআরনজেড কোনও সমস্যা নেই, দয়া করে এটি কোনও উদ্দেশ্যে ব্যবহার করুন।
ফেডার

43

সর্বোত্তম প্রয়োগের সন্ধানের পরে কীভাবে সর্বোত্তম সুনির্দিষ্ট ব্যবহারকারীর অবস্থান পেতে পারি আমি সর্বোত্তম পদ্ধতিগুলি একত্রিত করতে এবং নিম্নলিখিত ক্লাসটির সাথে আসতে সক্ষম হয়েছি:

/**
 * Retrieve accurate location from GPS or network services. 
 * 
 *
 * Class usage example:
 * 
 * public void onCreate(Bundle savedInstanceState) {
 *      ...
 *      my_location = new MyLocation();
 *      my_location.init(main.this, locationResult);
 * }
 * 
 * 
 * public LocationResult locationResult = new LocationResult(){
 *      @Override
 *      public void gotLocation(final Location location){
 *          // do something
 *          location.getLongitude();
 *          location.getLatitude();
 *      }
 *  };
 */
class MyLocation{

    /**
     * If GPS is enabled. 
     * Use minimal connected satellites count.
     */
    private static final int min_gps_sat_count = 5;

    /**
     * Iteration step time.
     */
    private static final int iteration_timeout_step = 500;

    LocationResult locationResult;
    private Location bestLocation = null;
    private Handler handler = new Handler();
    private LocationManager myLocationManager; 
    public Context context;

    private boolean gps_enabled = false;

    private int counts    = 0;
    private int sat_count = 0;

    private Runnable showTime = new Runnable() {

         public void run() {
            boolean stop = false;
            counts++;
            System.println("counts=" + counts);

            //if timeout (1 min) exceeded, stop tying
            if(counts > 120){
                stop = true;
            }

            //update last best location
            bestLocation = getLocation(context);

            //if location is not ready or don`t exists, try again
            if(bestLocation == null && gps_enabled){
                System.println("BestLocation not ready, continue to wait");
                handler.postDelayed(this, iteration_timeout_step);
            }else{
                //if best location is known, calculate if we need to continue to look for better location
                //if gps is enabled and min satellites count has not been connected or min check count is smaller then 4 (2 sec)  
                if(stop == false && !needToStop()){
                    System.println("Connected " + sat_count + " sattelites. continue waiting..");
                    handler.postDelayed(this, iteration_timeout_step);
                }else{
                    System.println("#########################################");
                    System.println("BestLocation finded return result to main. sat_count=" + sat_count);
                    System.println("#########################################");

                    // removing all updates and listeners
                    myLocationManager.removeUpdates(gpsLocationListener);
                    myLocationManager.removeUpdates(networkLocationListener);    
                    myLocationManager.removeGpsStatusListener(gpsStatusListener);
                    sat_count = 0;

                    // send best location to locationResult
                    locationResult.gotLocation(bestLocation);
                }
            }
         }
    };

    /**
     * Determine if continue to try to find best location
     */
    private Boolean needToStop(){

        if(!gps_enabled){
                          return true;
                     }
          else if(counts <= 4){
                return false;
            }
            if(sat_count < min_gps_sat_count){
                //if 20-25 sec and 3 satellites found then stop
                if(counts >= 40 && sat_count >= 3){
                    return true;
                }
                return false;
            }
        }
        return true;
    }

    /**
     * Best location abstract result class
     */
    public static abstract class LocationResult{
         public abstract void gotLocation(Location location);
     }

    /**
     * Initialize starting values and starting best location listeners
     * 
     * @param Context ctx
     * @param LocationResult result
     */
    public void init(Context ctx, LocationResult result){
        context = ctx;
        locationResult = result;

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

        gps_enabled = (Boolean) myLocationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);

        bestLocation = null;
        counts = 0;

        // turning on location updates
        myLocationManager.requestLocationUpdates("network", 0, 0, networkLocationListener);
        myLocationManager.requestLocationUpdates("gps", 0, 0, gpsLocationListener);
        myLocationManager.addGpsStatusListener(gpsStatusListener);

        // starting best location finder loop
        handler.postDelayed(showTime, iteration_timeout_step);
    }

    /**
     * GpsStatus listener. OnChainged counts connected satellites count.
     */
    public final GpsStatus.Listener gpsStatusListener = new GpsStatus.Listener() {
        public void onGpsStatusChanged(int event) {

             if(event == GpsStatus.GPS_EVENT_SATELLITE_STATUS){
                try {
                    // Check number of satellites in list to determine fix state
                     GpsStatus status = myLocationManager.getGpsStatus(null);
                     Iterable<GpsSatellite>satellites = status.getSatellites();

                     sat_count = 0;

                     Iterator<GpsSatellite>satI = satellites.iterator();
                     while(satI.hasNext()) {
                         GpsSatellite satellite = satI.next();
                         System.println("Satellite: snr=" + satellite.getSnr() + ", elevation=" + satellite.getElevation());                         
                         sat_count++;
                     }
                } catch (Exception e) {
                    e.printStackTrace();
                    sat_count = min_gps_sat_count + 1;
                }

                 System.println("#### sat_count = " + sat_count);
             }
         }
    };

    /**
     * Gps location listener.
     */
    public final LocationListener gpsLocationListener = new LocationListener(){
        @Override
         public void onLocationChanged(Location location){

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

    /**
     * Network location listener.
     */
    public final LocationListener networkLocationListener = new LocationListener(){
        @Override
         public void onLocationChanged(Location location){

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


    /**
     * Returns best location using LocationManager.getBestProvider()
     * 
     * @param context
     * @return Location|null
     */
    public static Location getLocation(Context context){
        System.println("getLocation()");

        // fetch last known location and update it
        try {
            LocationManager lm = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);

            Criteria criteria = new Criteria();
            criteria.setAccuracy(Criteria.ACCURACY_FINE);
             criteria.setAltitudeRequired(false);
             criteria.setBearingRequired(false);
             criteria.setCostAllowed(true);
             String strLocationProvider = lm.getBestProvider(criteria, true);

             System.println("strLocationProvider=" + strLocationProvider);
             Location location = lm.getLastKnownLocation(strLocationProvider);
             if(location != null){
                return location;
             }
             return null;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

এই শ্রেণিটি min_gps_sat_countজিপিএস সক্ষম থাকলে উপগ্রহের সাথে সংযোগ স্থাপনের চেষ্টা করে । অন্য LocationManager.getBestProvider()লোকেশন ফিরে । কোডটি চেক করুন!


2
এটি 1 মিনিটের পরে বা কখন অবস্থানটি সন্ধান করবে।
ওয়ার্মহিট

@ ওয়ার্মহিট আমার ক্ষেত্রে, এটি 120 গণনার পরে থামছে না। আমি জিপিএস সক্ষম করেছি এবং নেটওয়ার্ক সরবরাহকারীও উপলভ্য রয়েছে এবং আমি মেনিফেস্ট ফাইলে উপযুক্ত পারমিওসিও যুক্ত করেছি।
নরেন্দ্র পাল

এগুলি কেবল আমদানি হিসাবে রাখুন:import java.util.Iterator; import android.content.Context; import android.location.Criteria; import android.location.GpsSatellite; import android.location.GpsStatus; import android.location.Location; import android.location.LocationListener; import android.location.LocationManager; import android.os.Bundle; import android.os.Handler;
জ্যাকি চ্যান

31

ফেডরের সমাধানের সাথে আমি কলব্যাকের একাধিক প্রয়োগের অভিজ্ঞতা পেয়েছি gotLocation। এটি ওভাররাইড পদ্ধতিতে একটি রেসের শর্তের কারণে বলে মনে হচ্ছে LocationListener.onLocationChanged, যখন গেটলোকেশন পদ্ধতিটি 'যথেষ্ট দীর্ঘ' । আমি নিশ্চিত নই, তবে আমার ধারণা removeUpdatesলুপার কাতারে নতুন বার্তাগুলির উত্সাহ রোধ করে, তবে এটি ইতিমধ্যে সজ্জিত কিন্তু এখনও গ্রাস না করে এমনগুলি সরিয়ে দেয় না। সুতরাং রেসের অবস্থা condition

এই ভুল আচরণের সম্ভাবনা হ্রাস করার জন্য onLocationChanged ইভেন্টটি চালানোর আগে অপসারণগুলি কল করা সম্ভব, তবে তারপরেও আমাদের রেসের অবস্থা রয়েছে।

আমি খুঁজে পেলাম সেরা সমাধানটি প্রতিস্থাপন requestLocationUpdatesকরা requestSingleUpdate

লুডার থ্রেডে কোনও বার্তা প্রেরণের জন্য হ্যান্ডলার ব্যবহার করে ফেডারের সমাধানের ভিত্তিতে এটি আমার সংস্করণ:

public class LocationResolver {
    private Timer timer;
    private LocationManager locationManager;
    private LocationResult locationResult;
    private boolean gpsEnabled = false;
    private boolean networkEnabled = false;
    private Handler locationTimeoutHandler;

    private final Callback locationTimeoutCallback = new Callback() {
        public boolean handleMessage(Message msg) {
            locationTimeoutFunc();
            return true;
        }

        private void locationTimeoutFunc() {   
            locationManager.removeUpdates(locationListenerGps);
            locationManager.removeUpdates(locationListenerNetwork);

            Location networkLocation = null, gpsLocation = null;
            if (gpsEnabled)
                gpsLocation = locationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER);
            if (networkEnabled)
                networkLocation = locationManager.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);

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

            if (gpsLocation != null) {
                locationResult.gotLocation(gpsLocation);
                return;
            }
            if (networkLocation != null) {
                locationResult.gotLocation(networkLocation);
                return;
            }
            locationResult.gotLocation(null);           
        }
    };
    private final LocationListener locationListenerGps = new LocationListener() {
        public void onLocationChanged(Location location) {              
            timer.cancel();
            locationResult.gotLocation(location);
            locationManager.removeUpdates(this);
            locationManager.removeUpdates(locationListenerNetwork);
        }

        public void onProviderDisabled(String provider) {
        }

        public void onProviderEnabled(String provider) {
        }

        public void onStatusChanged(String provider, int status, Bundle extras) {
        }
    };
    private final LocationListener locationListenerNetwork = new LocationListener() {
        public void onLocationChanged(Location location) {    
            timer.cancel(); 
            locationResult.gotLocation(location);
            locationManager.removeUpdates(this);
            locationManager.removeUpdates(locationListenerGps);
        }

        public void onProviderDisabled(String provider) {
        }

        public void onProviderEnabled(String provider) {
        }

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

    public void prepare() {
        locationTimeoutHandler = new Handler(locationTimeoutCallback);
    }

    public synchronized boolean getLocation(Context context, LocationResult result, int maxMillisToWait) {
        locationResult = result;
        if (locationManager == null)
            locationManager = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);

        // exceptions will be thrown if provider is not permitted.
        try {
            gpsEnabled = locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
        } catch (Exception ex) {
        }
        try {
            networkEnabled = locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
        } catch (Exception ex) {
        }

        // don't start listeners if no provider is enabled
        if (!gpsEnabled && !networkEnabled)
            return false;

        if (gpsEnabled)
            locationManager.requestSingleUpdate(LocationManager.GPS_PROVIDER, locationListenerGps, Looper.myLooper());
            //locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, locationListenerGps);
        if (networkEnabled)
            locationManager.requestSingleUpdate(LocationManager.NETWORK_PROVIDER, locationListenerNetwork, Looper.myLooper());
            //locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 0, 0, locationListenerNetwork);

        timer = new Timer();
        timer.schedule(new GetLastLocationTask(), maxMillisToWait);
        return true;
    }

    private class GetLastLocationTask extends TimerTask {
        @Override
        public void run() { 
            locationTimeoutHandler.sendEmptyMessage(0);
        }
    }

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

আমি নিম্নলিখিত শ্রেণীর মতো কাস্টমাইজড লুপার থ্রেড থেকে এই ক্লাসটি ব্যবহার করি:

public class LocationGetter {
    private final Context context;
    private Location location = null;
    private final Object gotLocationLock = new Object();
    private final LocationResult locationResult = new LocationResult() {            
        @Override
        public void gotLocation(Location location) {
            synchronized (gotLocationLock) {
                LocationGetter.this.location = location;
                gotLocationLock.notifyAll();
                Looper.myLooper().quit();
            }
        }
    };

    public LocationGetter(Context context) {
        if (context == null)
            throw new IllegalArgumentException("context == null");

        this.context = context;
    }

    public synchronized Coordinates getLocation(int maxWaitingTime, int updateTimeout) {
        try {
            final int updateTimeoutPar = updateTimeout;
            synchronized (gotLocationLock) {            
                new Thread() {
                    public void run() {
                        Looper.prepare();
                        LocationResolver locationResolver = new LocationResolver();
                        locationResolver.prepare();
                        locationResolver.getLocation(context, locationResult, updateTimeoutPar);
                        Looper.loop();
                    }
                }.start();

                gotLocationLock.wait(maxWaitingTime);
            }
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }

        if (location != null)
            coordinates = new Coordinates(location.getLatitude(), location.getLongitude());
        else
            coordinates = Coordinates.UNDEFINED;
        return coordinates; 
    }
}

যেখানে স্থানাঙ্ক দুটি সাধারণ বৈশিষ্ট্য সহ একটি সাধারণ শ্রেণি: অক্ষাংশ এবং দ্রাঘিমাংশ।


4
আকর্ষণীয় পয়েন্ট, যাইহোক, অনুরোধসিংলআপ্টেটের জন্য API স্তর 9 প্রয়োজন requires তবে এটি উল্লেখ করার জন্য +1।
এডুয়ার্ডো

@ এডুয়ার্ডো: আরেকটি সম্ভাবনা হ'ল লুফারের সাথে সম্পর্কিত হ্যান্ডলারের সাহায্যে টাস্কের কোডটি কার্যকর করা এবং হ্যান্ডলারের কাছে একটি খালি বার্তা প্রেরণ করে এটি কল করা। যেহেতু বার্তাগুলি লুপার কাতারে সিরিয়ালাইজড, আপনি নিজেই (যেমন একটি পতাকা ব্যবহার করে) রেস শর্তটি মুছে ফেলতে পারেন। এর জন্য এপিআই লাইভেল 9 এর প্রয়োজন নেই, তবে এটি স্পষ্টভাবে লুপ ব্যবহার করতে হবে।
ডিফারেন্সিয়াল

17

আমি বর্তমান অবস্থানগুলির জিপিএস কো-অর্ডিনেটস পেতে ধাপে ধাপে বর্ণনা সহ একটি ছোট অ্যাপ্লিকেশন তৈরি করেছি।

এখানে চিত্র বর্ণনা লিখুন

নীচের ইউআরএলে উদাহরণের উত্স কোডটি সম্পূর্ণ করুন:


অ্যান্ড্রয়েডে বর্তমান অবস্থানের স্থানাঙ্ক, শহরের নাম পান


দেখো এটা কিভাবে কাজ করে :

  • আমাদের কেবল খালিস্ট ফাইলটিতে এই অনুমতিটি যুক্ত করা দরকার

    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION">  
    </uses-permission>
  • এবং এর মত লোকেশন ম্যানেজার উদাহরণ তৈরি করুন

    LocationManager locationManager = (LocationManager) 
                                      getSystemService(Context.LOCATION_SERVICE);
  • জিপিএস সক্ষম হয়েছে কিনা তা পরীক্ষা করুন

  • তারপরে অবস্থানের তালিকা প্রয়োগ করুন এবং সমন্বয়গুলি পান Get

    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) {}
}

1
অবস্থান পরিবর্তন করা প্রয়োজন। দাঁড়িয়ে থাকার সময় নয়

15

আপনি সর্বদা স্রেফ লোকেশন ম্যানেজার.জেটলাস্টকনডলোকেশন () ব্যবহার করতে পারেন তবে এটির মতো এটিরও পুরানো হতে পারে।

এবং একটি সাধারণ অবস্থান পাওয়ার সহজ উপায়টি নেটওয়ার্কের জন্য নিবন্ধভুক্ত হতে পারে (সাধারণত বেশ দ্রুত)।

LocationManager locationManager = (LocationManager) this.getSystemService(Context.LOCATION_SERVICE);
locationManager.requestLocationUpdates(
     LocationManager.NETWORK_PROVIDER, 1000, 1000, this);

এবং তারপর করছেন

locationManager.removeUpdates(this);

মধ্যে onLocationChanged()শ্রোতা পদ্ধতি।


ধন্যবাদ ব্রেনা সাফ্ট। আমি খুঁজে পেয়েছি যে getLastKজ্ঞান লোকেশন () প্রায়শই বন্যভাবে বন্ধ হয়ে যেতে পারে, এবং তাই প্রকৃতপক্ষে একক সমাধান হিসাবে কাজ করে না। এছাড়াও, এটি আমার কাছে পরিষ্কার নয় যে কেবলমাত্র নেটওয়র্ককপ্রোভিডারের উপর নির্ভর করে কাজ করবে, যেহেতু দেশের অনেক অঞ্চলে ওয়াইফাই অ্যাক্সেস পয়েন্টগুলির জন্য খুব ভাল জিপিএস সমন্বয় নেই (এবং আমি সেল টাওয়ারগুলি সম্পর্কে জানি না)
এমএমবি

9

আমি এখানে রক্ষিত স্থানের বর্তমান অবস্থানটি সম্পর্কে বিস্তারিত টিউটোরিয়াল লিখেছি You আপনি এখানে আরও বিবরণ পেতে পারেন এবং আরও ভাল বোঝার জন্য আপনি পুরো ডেমো উত্স কোডটি ডাউনলোড করতে পারেন।

ইতিমধ্যে সেখানে অনেক উত্তর রয়েছে তবে আমি গুগল এপিআই ব্যবহার করে অবস্থানের সর্বশেষ উপায়টি দেখাতে চাই, যাতে নতুন প্রোগ্রামাররা নতুন পদ্ধতি ব্যবহার করতে পারেন:

প্রথমত, গ্রেড ফাইল এ রাখুন

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

তারপরে প্রয়োজনীয় ইন্টারফেস প্রয়োগ করুন

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;

এটি putোকান 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;
        }
        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) {

    }

অ্যাপ্লিকেশন চালানোর আগে আপনার ডিভাইসে জিপিএস শুরু করতে ভুলবেন না।


এপিআই ব্যবহার করছেন? সুতরাং এটি হ'ল পরিষেবাটি সীমিত অধিকার।
ব্যবহারকারী3304007

8

প্রকৃতপক্ষে আমরা দুটি সরবরাহকারী (জিপিএস এবং নেটওয়র্ক) ব্যবহার করতে পারি। এবং তারা কেবল সর্বজনীন শ্রোতাকে ভাগ করে:

locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 10 * 1000, (float) 10.0, listener);
locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 90 * 1000, (float) 10.0, listener);

এটি প্রয়োজনীয় কারণ OnLocationChanged()পদ্ধতিটি সর্বদা সময়মতো কল করা প্রয়োজন।


5

আমি নিশ্চিত না যে অবস্থান-ভিত্তিক পরিষেবাদিগুলি জিপিএস ব্যতীত অন্য অবকাঠামোগত স্থানগুলি পেতে পারে কিনা তবে সেই নিবন্ধ অনুসারে এটি সম্ভব বলে মনে হচ্ছে:

অ্যাপ্লিকেশনগুলি বিভিন্ন ধরণের অবস্থানের পদ্ধতিতে কল করতে পারে।

মোবাইল ফোন নেটওয়ার্ক ব্যবহার করে: ডিভাইসটি যে বিটিটিএসের সাথে যোগাযোগ করছে এবং বেসটি ট্রান্সসিভার স্টেশন (বিটিএস) সনাক্ত করতে বর্তমান সেল আইডি ব্যবহার করা যেতে পারে। স্পষ্টতই, এই পদ্ধতির যথার্থতাটি কোষের আকারের উপর নির্ভর করে এবং এটি বেশ ভুল হতে পারে। একটি জিএসএম সেল 2 থেকে 20 কিলোমিটার ব্যাসের যে কোনও জায়গায় হতে পারে। সেল আইডির সাথে ব্যবহৃত অন্যান্য কৌশলগুলি 150 মিটারের মধ্যে নির্ভুলতা অর্জন করতে পারে।

উপগ্রহ ব্যবহার: মার্কিন প্রতিরক্ষা বিভাগ দ্বারা নিয়ন্ত্রিত গ্লোবাল পজিশনিং সিস্টেম (জিপিএস) পৃথিবী প্রদক্ষিণ করে 24 উপগ্রহগুলির একটি নক্ষত্র ব্যবহার করে। জিপিএস রিসিভারে পৌঁছাতে বিভিন্ন উপগ্রহ থেকে প্রাপ্ত সংকেতগুলির মধ্যে পার্থক্য গণনা করে ডিভাইসের অবস্থান নির্ধারণ করে। জিপিএস সিগন্যালগুলি এনকোড করা আছে, তাই মোবাইল ডিভাইসটি অবশ্যই একটি জিপিএস রিসিভার দিয়ে সজ্জিত থাকতে হবে। জিপিএস সম্ভাব্যভাবে সর্বাধিক সঠিক পদ্ধতি (জিপিএস রিসিভারের আকাশের স্পষ্ট দৃষ্টিভঙ্গি থাকলে 4 থেকে 40 মিটারের মধ্যে), তবে এর কিছু ত্রুটি রয়েছে: অতিরিক্ত হার্ডওয়্যার ব্যয়বহুল হতে পারে, ব্যবহারের সময় ব্যাটারি গ্রহণ করে এবং কিছুটা গরম-গরম প্রয়োজন requires ঠান্ডা শুরু হওয়ার পরে দৃশ্যমান উপগ্রহগুলির প্রাথমিক ফিক্স পেতে। এটি শহরগুলিতে "উপত্যকা প্রভাব" থেকেও ভুগছে, যেখানে উপগ্রহের দৃশ্যমানতা বিরতিহীন।

স্বল্প-পরিসরের পজিশনিং বীকন ব্যবহার করে: তুলনামূলকভাবে ছোট অঞ্চলে যেমন একটি একক বিল্ডিং, একটি স্থানীয় অঞ্চল নেটওয়ার্ক অন্যান্য পরিষেবার পাশাপাশি অবস্থান সরবরাহ করতে পারে। উদাহরণস্বরূপ, উপযুক্তভাবে সজ্জিত ডিভাইসগুলি স্বল্প-পরিসরের অবস্থানের জন্য ব্লুটুথ ব্যবহার করতে পারে।


1
@ এলিজাহসাউনকাইন দৃশ্যত এনপিন্টি সহকারী জিপিএসের কথা শোনেনি। ভবিষ্যতে আপনি সম্ভবত সেগুলি সম্পর্কে আক্রমণাত্মক হওয়ার পরিবর্তে তারা যে সমস্ত বিষয় পর্যবেক্ষণ করেছেন সে সম্পর্কে কেবল তাদেরই অবহিত করতে পারেন।
সালটান্পেপ্পার

@ স্যামি 5 বছর আগে আমার মনে হয় এখনকার চেয়ে অনেক বেশি লাফিয়ে উঠেছে। আমার নোটের সাথে আপনি যে "ভবিষ্যত" উল্লেখ করেছেন, সম্ভবত ইতিমধ্যে এটি শুরু হয়েছে এবং শেষ হয়েছে;)
এলিয়াহা সাউনকাইন

5

নীচের কোডটি ব্যবহার করুন, এটি সেরা সরবরাহকারীকে উপলব্ধ করবে:

String locCtx = Context.LOCATION_SERVICE; 

LocationManager locationMgr = (LocationManager) ctx.getSystemService(locCtx);

Criteria criteria  = new Criteria();
criteria.setAccuracy(Criteria.ACCURACY_FINE);
criteria.setAltitudeRequired(false);
criteria.setBearingRequired(false);
criteria.setCostAllowed(true);
criteria.setPowerRequirement(Criteria.POWER_LOW);

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

System.out.println("Best Available provider::::"+provider);

সিটিএক্স কীভাবে প্রবর্তন করা যায়, প্রসঙ্গ সিটিএক্স = এটি; ? এটি ক্র্যাশ হয়েছে

4

এটি করার প্রস্তাবিত উপায়টি হ'ল LocationClient:

প্রথমত, অবস্থান আপডেটের বিরতি মানগুলি নির্ধারণ করুন। এটি আপনার প্রয়োজনের সাথে সামঞ্জস্য করুন।

private static final int MILLISECONDS_PER_SECOND = 1000;
private static final long UPDATE_INTERVAL = MILLISECONDS_PER_SECOND * UPDATE_INTERVAL_IN_SECONDS;
private static final int FASTEST_INTERVAL_IN_SECONDS = 1;
private static final long FASTEST_INTERVAL = MILLISECONDS_PER_SECOND * FASTEST_INTERVAL_IN_SECONDS;

আপনার Activityবাস্তবায়ন GooglePlayServicesClient.ConnectionCallbacks, GooglePlayServicesClient.OnConnectionFailedListenerএবং LocationListener

public class LocationActivity extends Activity implements 
GooglePlayServicesClient.ConnectionCallbacks, GooglePlayServicesClient.OnConnectionFailedListener, LocationListener {}

তারপরে, এক সেট আপ LocationClientমধ্যে onCreate()আপনার পদ্ধতি Activity:

public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    mLocationClient = new LocationClient(this, this, this);

    mLocationRequest = LocationRequest.create();
    mLocationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);
    mLocationRequest.setInterval(UPDATE_INTERVAL);
    mLocationRequest.setFastestInterval(FASTEST_INTERVAL);
}

আপনার প্রয়োজনীয় পদ্ধতি যুক্ত করুন Activity; সংযোগ স্থাপন করার onConnected()সময় বলা হয় এমন পদ্ধতি LocationClientonLocationChanged()আপনি যেখানে সর্বাধিক আপ টু ডেট অবস্থান পুনরুদ্ধার করবেন।

@Override
public void onConnectionFailed(ConnectionResult connectionResult) {
    Log.w(TAG, "Location client connection failed");
}

@Override
public void onConnected(Bundle dataBundle) {
    Log.d(TAG, "Location client connected");
    mLocationClient.requestLocationUpdates(mLocationRequest, this); 
}

@Override
public void onDisconnected() {
    Log.d(TAG, "Location client disconnected");
}

@Override
public void onLocationChanged(Location location) {
    if (location != null) {
        Log.d(TAG, "Updated Location: " + Double.toString(location.getLatitude()) + "," + Double.toString(location.getLongitude()));
    } else {
        Log.d(TAG, "Updated location NULL");
    } 
}     

সংযোগ / সংযোগ বিচ্ছিন্ন করার বিষয়ে নিশ্চিত হন LocationClientযাতে এটি একেবারে প্রয়োজনীয় হলে কেবল অতিরিক্ত ব্যাটারি ব্যবহার করে এবং যাতে জিপিএস অনির্দিষ্টকালের জন্য চলবে না। LocationClientযাতে এটা থেকে তথ্য পেতে সংযুক্ত থাকতে হবে।

public void onResume() {
    super.onResume();
    mLocationClient.connect();
}

public void onStop() {
    if (mLocationClient.isConnected()) {
        mLocationClient.removeLocationUpdates(this);
    }
    mLocationClient.disconnect();
    super.onStop();
}

ব্যবহারকারীর অবস্থান পান। প্রথমে ব্যবহার করার চেষ্টা করুন LocationClient; যদি এটি ব্যর্থ হয়, ফিরে যান LocationManager

public Location getLocation() {
    if (mLocationClient != null && mLocationClient.isConnected()) {
        return mLocationClient.getLastLocation();
    } else {
        LocationManager locationManager = (LocationManager) this.getSystemService(Context.LOCATION_SERVICE);
        if (locationManager != null) {
            Location lastKnownLocationGPS = locationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER);
            if (lastKnownLocationGPS != null) {
                return lastKnownLocationGPS;
            } else {
                return locationManager.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);
            }
        } else {
            return null;
        }
    }
}

3

যদিও উত্তরটি ইতিমধ্যে এখানে দেওয়া আছে। আমি কেবল বিশ্বের কাছে এটি ভাগ করে নিতে চেয়েছিলাম আসার মতো পরিস্থিতি জুড়ে।

আমার প্রয়োজনীয়তাটি ছিল যে আমি ব্যবহারকারীর বর্তমান অবস্থানটি সর্বোচ্চ 30 থেকে 35 সেকেন্ডের মধ্যে পাওয়ার প্রয়োজন তাই নিরভ রণপাড়ার উত্তর অনুসরণ করে আমি তৈরি করা সমাধানটি এখানে ।

1. আমি মাইলোকেশনমনেজ.আরভা ক্লাস তৈরি করেছি যা সমস্ত জিপিএস এবং নেটওয়ার্ক স্টাফ পরিচালনা করে

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

import com.app.callbacks.OnLocationDetectectionListener;

import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.Bundle;
import android.provider.Settings;
import android.util.Log;
import android.widget.Toast;

public class MyLocationManager {
    /** The minimum distance to GPS change Updates in meters **/
    private final long MIN_DISTANCE_CHANGE_FOR_UPDATES_FOR_GPS = 2; // 2
                                                                    // meters
    /** The minimum time between GPS updates in milliseconds **/
    private final long MIN_TIME_BW_UPDATES_OF_GPS = 1000 * 5 * 1; // 5
                                                                    // seconds

    /** The minimum distance to NETWORK change Updates in meters **/
    private final long MIN_DISTANCE_CHANGE_FOR_UPDATES_FOR_NETWORK = 5; // 5
                                                                        // meters
    /** The minimum time between NETWORK updates in milliseconds **/
    private final long MIN_TIME_BW_UPDATES_OF_NETWORK = 1000 * 10 * 1; // 10
                                                                        // seconds

    /**
     * Lets just say i don't trust the first location that the is found. This is
     * to avoid that
     **/

    private int NetworkLocationCount = 0, GPSLocationCount = 0;
    private boolean isGPSEnabled;
    private boolean isNetworkEnabled;
    /**
     * Don't do anything if location is being updated by Network or by GPS
     */
    private boolean isLocationManagerBusy;
    private LocationManager locationManager;
    private Location currentLocation;
    private Context mContext;
    private OnLocationDetectectionListener mListener;

    public MyLocationManager(Context mContext,
            OnLocationDetectectionListener mListener) {
        this.mContext = mContext;
        this.mListener = mListener;
    }

    /**
     * Start the location manager to find my location
     */
    public void startLocating() {
        try {
            locationManager = (LocationManager) mContext
                    .getSystemService(Context.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
                showSettingsAlertDialog();
            } else {
                // If GPS enabled, get latitude/longitude using GPS Services
                if (isGPSEnabled) {
                    locationManager.requestLocationUpdates(
                            LocationManager.GPS_PROVIDER,
                            MIN_TIME_BW_UPDATES_OF_GPS,
                            MIN_DISTANCE_CHANGE_FOR_UPDATES_FOR_GPS,
                            gpsLocationListener);

                }
                if (isNetworkEnabled) {
                    locationManager.requestLocationUpdates(
                            LocationManager.NETWORK_PROVIDER,
                            MIN_TIME_BW_UPDATES_OF_NETWORK,
                            MIN_DISTANCE_CHANGE_FOR_UPDATES_FOR_NETWORK,
                            networkLocationListener);

                }
            }
            /**
             * My 30 seconds plan to get myself a location
             */
            ScheduledExecutorService se = Executors
                    .newSingleThreadScheduledExecutor();
            se.schedule(new Runnable() {

                @Override
                public void run() {
                    if (currentLocation == null) {
                        if (isGPSEnabled) {
                            currentLocation = locationManager
                                    .getLastKnownLocation(LocationManager.GPS_PROVIDER);
                        } else if (isNetworkEnabled) {
                            currentLocation = locationManager
                                    .getLastKnownLocation(LocationManager.NETWORK_PROVIDER);

                        }
                        if (currentLocation != null && mListener != null) {
                            locationManager.removeUpdates(gpsLocationListener);
                            locationManager
                                    .removeUpdates(networkLocationListener);
                            mListener.onLocationDetected(currentLocation);
                        }
                    }
                }
            }, 30, TimeUnit.SECONDS);

        } catch (Exception e) {
            Log.e("Error Fetching Location", e.getMessage());
            Toast.makeText(mContext,
                    "Error Fetching Location" + e.getMessage(),
                    Toast.LENGTH_SHORT).show();
        }
    }

    /**
     * Handle GPS location listener callbacks
     */
    private LocationListener gpsLocationListener = 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) {

            if (GPSLocationCount != 0 && !isLocationManagerBusy) {
                Log.d("GPS Enabled", "GPS Enabled");
                isLocationManagerBusy = true;
                currentLocation = location;
                locationManager.removeUpdates(gpsLocationListener);
                locationManager.removeUpdates(networkLocationListener);
                isLocationManagerBusy = false;
                if (currentLocation != null && mListener != null) {
                    mListener.onLocationDetected(currentLocation);
                }
            }
            GPSLocationCount++;
        }
    };
    /**
     * Handle Network location listener callbacks
     */
    private LocationListener networkLocationListener = 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) {
            if (NetworkLocationCount != 0 && !isLocationManagerBusy) {
                Log.d("Network", "Network");
                isLocationManagerBusy = true;
                currentLocation = location;
                locationManager.removeUpdates(gpsLocationListener);
                locationManager.removeUpdates(networkLocationListener);
                isLocationManagerBusy = false;
                if (currentLocation != null && mListener != null) {
                    mListener.onLocationDetected(currentLocation);
                }
            }
            NetworkLocationCount++;
        }
    };

    /**
     * Function to show settings alert dialog. On pressing the Settings button
     * it will launch Settings Options.
     * */
    public void showSettingsAlertDialog() {
        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() {
                    @Override
                    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() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        dialog.cancel();
                    }
                });

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

২. ফলাফলগুলি কলিং ফাংশন বা ক্রিয়াকলাপে ফিরে যোগাযোগ করার জন্য আমি একটি ইন্টারফেস (কলব্যাক) অনলকেশনডেক্টিফিকেশনলাইস্টেনার.জভা করেছি

import android.location.Location;

public interface OnLocationDetectectionListener {
    public void onLocationDetected(Location mLocation);
}

৩. তারপরে আমি একটি মেইনএপ্যাক্টিটি.জভা ক্রিয়াকলাপ তৈরি করেছি যা OnLocationDetectectionListenerইন্টারফেস প্রয়োগ করে এবং এখানে আমি কীভাবে আমার অবস্থান গ্রহণ করি তা এখানে is

public class MainAppActivty extends Activity implements
        OnLocationDetectectionListener {

    private Location currentLocation;
    private MyLocationManager mLocationManager;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        setContentView(R.layout.activity_home);
        super.onCreate(savedInstanceState);
            mLocationManager = new MyLocationManager(this, this);
            mLocationManager.startLocating();
    }

    @Override
    public void onLocationDetected(Location mLocation) {
        //Your new Location is received here
        currentLocation = mLocation;
    }

৪. আপনার ম্যানিফেস্ট ফাইলে নিম্নলিখিত অনুমতিগুলি যুক্ত করুন

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

আশা করি এটি অন্যের জন্য সহায়ক হবে :)


3

গত এক বছরেরও বেশি সময় থেকে, আমি বর্তমান অবস্থান পেতে জিপিএসপ্রোভিডার এবং নেটওয়র্ককিপ্রোভিডার সংমিশ্রণটি ব্যবহার করছিলাম এবং এটি ভাল কাজ করছিল, তবে গত কয়েকমাস থেকে আমি দীর্ঘ বিলম্বের পরে অবস্থান পাচ্ছি, তাই আমি সর্বশেষ এপিআই ফিউজডলোকেশনপ্রাইডার ক্লায়েন্ট এবং স্যুইচ করেছি and এটা বেশ ভাল কাজ করছে।

FusedLocationProviderClient ব্যবহার করে বর্তমান অবস্থান পেতে আমি যে ক্লাসটি লিখেছিলাম তা এখানে। নীচের কোডে, আমি একটি টাইমার ব্যবহার করে বর্তমান অবস্থানটি পেতে অপেক্ষা করছিলাম, আমি টাইমারকে 15 সেকেন্ড বিলম্বিত করেছিলাম, আপনি নিজের অনুসারে এটি পরিবর্তন করতে পারেন।

private static FusedLocationService ourInstance;
private final LocationRequest locationRequest;
private FusedLocationProviderClient mFusedLocationClient;
private Location mLastLocation;
private Context context;
private FindOutLocation findOutLocation;
private boolean callbackTriggered = false;
private Timer timer;

public static FusedLocationService getInstance(Context pContext) {

    if (null == ourInstance) ourInstance = new FusedLocationService(pContext);

    return ourInstance;
}

private FusedLocationService(Context pContext) {
    context = pContext;
    mFusedLocationClient = LocationServices.getFusedLocationProviderClient(context);
    locationRequest = getLocationRequest();
    requestLocation(context);
}

public Location getLastKnownLocation() {
    return mLastLocation;
}

private void requestLocation(Context context) {

    if (ActivityCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(context, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
        return;
    }
    mFusedLocationClient.requestLocationUpdates(locationRequest, mLocationCallback, null);
    mFusedLocationClient.getLastLocation().addOnSuccessListener(location -> {
        if (location != null) {
            mLastLocation = location;
            triggerCallback(mLastLocation);
        }
    });
}

private LocationRequest getLocationRequest() {
    LocationRequest locationRequest = new LocationRequest();
    long INTERVAL = 10 * 1000;
    long FASTEST_INTERVAL = 5 * 1000;
    locationRequest.setInterval(INTERVAL);
    locationRequest.setFastestInterval(FASTEST_INTERVAL);
    locationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);
    return locationRequest;
}

private LocationCallback mLocationCallback = new LocationCallback() {
    @Override
    public void onLocationResult(LocationResult locationResult) {
        for (Location location : locationResult.getLocations()) {
            if (location != null) mLastLocation = location;
        }
        if (null != mLastLocation) triggerCallback(mLastLocation);
    }
};

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

@SuppressLint("MissingPermission")
public void findLocation(FindOutLocation findOutLocation) {
    long TIMER_TIME_OUT = 15 * 1000;
    this.findOutLocation = findOutLocation;
    callbackTriggered = false;

    try {
        requestLocation(context);
        timer = new Timer();
        timer.schedule(new GetLastLocation(context), TIMER_TIME_OUT);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

private class GetLastLocation extends TimerTask {
    Context context;

    GetLastLocation(Context context) {
        this.context = context;
    }

    @Override
    public void run() {
        triggerCallback(mLastLocation);
    }
}

private void triggerCallback(Location location) {
    if (null != location) mLastLocation = location;
    if (!callbackTriggered && null != findOutLocation) {
        callbackTriggered = true;
        removeLocationUpdates();
        findOutLocation.gotLocation(location);
        findOutLocation = null;
    }
}

private void removeLocationUpdates() {
    if (null != timer) timer.cancel();
    if (null != mFusedLocationClient)
        mFusedLocationClient.removeLocationUpdates(mLocationCallback);
}
}

এবং এটি ক্রিয়াকলাপ থেকে বলা হয়, এখানে কোড

    FusedLocationService.FindOutLocation findOutLocation = new FusedLocationService.FindOutLocation() {
        @Override
        public void gotLocation(Location currentLocation) {
            if (currentLocation != null) {
                /*TODO DO SOMETHING WITH CURRENT LOCATION*/
            }
        }
    };
    FusedLocationService.getInstance(this).findLocation(findOutLocation);

AndroidManLive.xML এ নিম্নলিখিত এন্ট্রি যুক্ত করুন

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

<!-- Needed only if your app targets Android 5.0 (API level 21) or higher. -->
<uses-feature android:name="android.hardware.location.gps" />

2
public static Location getBestLocation(Context ctxt) {
    Location gpslocation = getLocationByProvider(
        LocationManager.GPS_PROVIDER, ctxt);
    Location networkLocation = getLocationByProvider(
        LocationManager.NETWORK_PROVIDER, ctxt);
    Location fetchedlocation = null;
    // if we have only one location available, the choice is easy
    if (gpslocation != null) {
        Log.i("New Location Receiver", "GPS Location available.");
        fetchedlocation = gpslocation;
    } else {
        Log.i("New Location Receiver",
            "No GPS Location available. Fetching Network location lat="
                + networkLocation.getLatitude() + " lon ="
                + networkLocation.getLongitude());
        fetchedlocation = networkLocation;
    }
    return fetchedlocation;
}

/**
 * get the last known location from a specific provider (network/gps)
 */
private static Location getLocationByProvider(String provider, Context ctxt) {
    Location location = null;
    // if (!isProviderSupported(provider)) {
    // return null;
    // }
    LocationManager locationManager = (LocationManager) ctxt
            .getSystemService(Context.LOCATION_SERVICE);
    try {
        if (locationManager.isProviderEnabled(provider)) {
            location = locationManager.getLastKnownLocation(provider);
        }
    } catch (IllegalArgumentException e) {
        Log.i("New Location Receiver", "Cannot access Provider " + provider);
    }
    return location;
}

2

এটি কোড যা ব্যবহারকারীদের বর্তমান অবস্থান সরবরাহ করে

মানচিত্র অ্যাক্টিভিটি তৈরি করুন:

public class Maps extends MapActivity {

    public static final String TAG = "MapActivity";
    private MapView mapView;
    private LocationManager locationManager;
    Geocoder geocoder;
    Location location;
    LocationListener locationListener;
    CountDownTimer locationtimer;
    MapController mapController;
    MapOverlay mapOverlay = new MapOverlay();

    @Override
    protected void onCreate(Bundle icicle) {
        super.onCreate(icicle);
        setContentView(R.layout.main);
        initComponents();
        mapView.setBuiltInZoomControls(true);
        mapView.setSatellite(true);
        mapView.setTraffic(true);
        mapView.setStreetView(true);
        mapController = mapView.getController();
        mapController.setZoom(16);
        locationManager = (LocationManager) getSystemService(LOCATION_SERVICE);
        if (locationManager == null) {
            Toast.makeText(Maps.this, "Location Manager Not Available",
                Toast.LENGTH_SHORT).show();
            return;
        }
        location = locationManager
                .getLastKnownLocation(LocationManager.GPS_PROVIDER);
        if (location == null)
            location = locationManager
                    .getLastKnownLocation(LocationManager.NETWORK_PROVIDER);
        if (location != null) {
            double lat = location.getLatitude();
            double lng = location.getLongitude();
            Toast.makeText(Maps.this, "Location Are" + lat + ":" + lng,
                Toast.LENGTH_SHORT).show();
            GeoPoint point = new GeoPoint((int) (lat * 1E6), (int) (lng * 1E6));
            mapController.animateTo(point, new Message());
            mapOverlay.setPointToDraw(point);
            List<Overlay> listOfOverlays = mapView.getOverlays();
            listOfOverlays.clear();
            listOfOverlays.add(mapOverlay);
        }
        locationListener = new LocationListener() {

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

            public void onProviderEnabled(String arg0) {}

            public void onProviderDisabled(String arg0) {}

            public void onLocationChanged(Location l) {
                location = l;
                locationManager.removeUpdates(this);
                if (l.getLatitude() == 0 || l.getLongitude() == 0) {
                } else {
                    double lat = l.getLatitude();
                    double lng = l.getLongitude();
                    Toast.makeText(Maps.this, "Location Are" + lat + ":" + lng,
                        Toast.LENGTH_SHORT).show();
                }
            }
        };
        if (locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER))
            locationManager.requestLocationUpdates(
                LocationManager.GPS_PROVIDER, 1000, 10f, locationListener);
        locationManager.requestLocationUpdates(
            LocationManager.NETWORK_PROVIDER, 1000, 10f, locationListener);
        locationtimer = new CountDownTimer(30000, 5000) {

            @Override
            public void onTick(long millisUntilFinished) {
                if (location != null) locationtimer.cancel();
            }

            @Override
            public void onFinish() {
                if (location == null) {
                }
            }
        };
        locationtimer.start();
    }

    public MapView getMapView() {
        return this.mapView;
    }

    private void initComponents() {
        mapView = (MapView) findViewById(R.id.map_container);
        ImageView ivhome = (ImageView) this.findViewById(R.id.imageView_home);
        ivhome.setOnClickListener(new OnClickListener() {

            public void onClick(View arg0) {
                // TODO Auto-generated method stub
                Intent intent = new Intent(Maps.this, GridViewContainer.class);
                startActivity(intent);
                finish();
            }
        });
    }

    @Override
    protected boolean isRouteDisplayed() {
        return false;
    }

    class MapOverlay extends Overlay {

        private GeoPoint pointToDraw;

        public void setPointToDraw(GeoPoint point) {
            pointToDraw = point;
        }

        public GeoPoint getPointToDraw() {
            return pointToDraw;
        }

        @Override
        public boolean draw(Canvas canvas, MapView mapView, boolean shadow,
                long when) {
            super.draw(canvas, mapView, shadow);
            Point screenPts = new Point();
            mapView.getProjection().toPixels(pointToDraw, screenPts);
            Bitmap bmp = BitmapFactory.decodeResource(getResources(),
                R.drawable.select_map);
            canvas.drawBitmap(bmp, screenPts.x, screenPts.y - 24, null);
            return true;
        }
    }
}

main.xml:

    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="@android:color/black"
        android:orientation="vertical" >

        <com.google.android.maps.MapView
            android:id="@+id/map_container"
            android:layout_width="fill_parent"
            android:layout_height="fill_parent"
            android:apiKey="yor api key"
            android:clickable="true"
            android:focusable="true" />

    </LinearLayout>

এবং ম্যানিফেস্টে নিম্নলিখিত অনুমোদনের সংজ্ঞা দিন:

<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"/>

2

এইভাবে আমি ব্যবহারকারীর অনুমতিগুলির জন্য অনুরোধ করছি।

অ্যান্ড্রয়েড ম্যানিফেস্ট.এক্সএমএলে আপনার অ্যাপ্লিকেশন ট্যাগের বাইরে এই অনুমতি অনুরোধগুলি যুক্ত করুন।

<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" />

তারপরে অ্যাপ গ্রেডল ফাইলটিতে গুগলের অবস্থান নির্ভরতা যুক্ত করুন।

implementation 'com.google.android.gms:play-services-location:15.0.0'

এখন কিছু গ্লোবাল ভেরিয়েবল ঘোষণা করুন।

private lateinit var mFusedLocationProvider:FusedLocationProviderClient
private lateinit var mLocationCallback: LocationCallback
private lateinit var mLocationRequest: LocationRequest
private var mLocationPermissionGranted:Boolean = false

আপনার ক্রিয়াকলাপের অনক্রিয়েট পদ্ধতিতে (আমি কোডটি সঠিকভাবে ফর্ম্যাট করতে পারিনি, তার জন্য ক্ষমা প্রার্থনা)

mFusedLocationProvider = LocationServices.getFusedLocationProviderClient(this)

//Location Callback
mLocationCallback = object: LocationCallback(){
 override fun onLocationResult(p0: LocationResult?) {
  if(p0==null){
     //todo(request user to enable location from settings then remove return)
     return
  }else{
      getDeviceLocation()
       }
  }
}

//Location Request
mLocationRequest = LocationRequest.create()
mLocationRequest.priority = LocationRequest.PRIORITY_BALANCED_POWER_ACCURACY
//Set the Interval for Latest Interval Update
mLocationRequest.interval = 5000
//Set How Many Location Updated you Want
mLocationRequest.numUpdates = 1

getLocationPermission()
getDeviceLocation()

এখন উভয় ফাংশন তৈরি করুন।

 private fun getLocationPermission() {

            val permission:Array<String> = arrayOf(android.Manifest.permission.ACCESS_FINE_LOCATION,android.Manifest.permission.ACCESS_COARSE_LOCATION)
            if(ContextCompat.checkSelfPermission(applicationContext,Constant.FINE_LOCATION)== PermissionChecker.PERMISSION_GRANTED){
                if(ContextCompat.checkSelfPermission(applicationContext,Constant.COARSE_LOCATION)== PermissionChecker.PERMISSION_GRANTED){
                    mLocationPermissionGranted = true
                }
            }else{
                ActivityCompat.requestPermissions(this,permission,Constant.LOCATION_REQUEST_CODE)
            }

    }

দ্বিতীয় পদ্ধতি

private fun getDeviceLocation() {
        try{
            if(mLocationPermissionGranted){

                mFusedLocationProvider.lastLocation.addOnCompleteListener(this,{task: Task<Location> ->
                    if(task.isSuccessful){
                        var currentLocation: Location? = task.result
                        if(currentLocation!=null){

                            Log.i("Location","Latitude is ${currentLocation.latitude} and Longitude" +
                                    "${currentLocation.longitude}")
                        }

                        else
                            mFusedLocationProvider.requestLocationUpdates(mLocationRequest,mLocationCallback,null)
                    }
                })
            }
        }catch (e:SecurityException){
            Log.e("Error", "Security Exception ${e.message}")
        }
    }

কনস্ট্যান্ট.কেটের জন্য

class Constant{
    companion object {

        //Location Request Settings
        const val SET_INTERVAL:Long = 2000
        const val NUM_UPDATES:Int = 1

        //Location Permission
        const val FINE_LOCATION:String = android.Manifest.permission.ACCESS_FINE_LOCATION
        const val COARSE_LOCATION:String = android.Manifest.permission.ACCESS_COARSE_LOCATION
    }
}

2

@ ফেডার এর সমাধানে উন্নতি। '0' সময়ের ব্যবধান এবং '0' দূরত্বের সাথে লোকেশনটির অনুরোধ করার পরিবর্তে আমরা লোকেশন ম্যানেজারের অনুরোধসিংলআপডেট পদ্ধতিটি ব্যবহার করতে পারি । আপডেট হওয়া কোড (কোটলিন সংস্করণ)

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 java.util.*

@SuppressLint("MissingPermission")
class AppLocationProvider {

  private lateinit var timer: Timer
  private var locationManager: LocationManager? = null
  private lateinit var locationCallBack: LocationCallBack
  private var gpsEnabled = false
  private var networkEnabled = false

  private var locationListener: LocationListener = object : LocationListener {

    override fun onLocationChanged(location: Location) {
      timer.cancel()
      locationCallBack.locationResult(location)
    }

    override fun onProviderDisabled(provider: String) {}
    override fun onProviderEnabled(provider: String) {}
    override fun onStatusChanged(provider: String, status: Int, extras: Bundle) {}
  }

  fun getLocation(context : Context, callBack: LocationCallBack): Boolean {
    locationCallBack = callBack
    if (locationManager == null)
      locationManager = context.getSystemService(Context.LOCATION_SERVICE) as LocationManager?

    //exceptions will be thrown if provider is not permitted.
    try {
      gpsEnabled = locationManager!!.isProviderEnabled(LocationManager.GPS_PROVIDER)
    } catch (ex: Exception) {
      ex.printStackTrace()
    }

    try {
      networkEnabled = locationManager!!.isProviderEnabled(LocationManager.NETWORK_PROVIDER)
    } catch (ex: Exception) {
      ex.printStackTrace()
    }

    //don't start listeners if no provider is enabled
    if (!gpsEnabled && !networkEnabled)
      return false

    val criteria = Criteria()
    if (gpsEnabled) {
      criteria.accuracy = Criteria.ACCURACY_FINE
    } else {
      criteria.accuracy = Criteria.ACCURACY_COARSE
    }
    locationManager!!.requestSingleUpdate(criteria, locationListener, null)

    timer = Timer()
    timer.schedule(GetLastKnownLocation(), 5000)
    return true
  }

  inner class GetLastKnownLocation : TimerTask() {

    override fun run() {
      locationManager!!.removeUpdates(locationListener)

      var netLoc: Location? = null
      var gpsLoc: Location? = null

      if (gpsEnabled)
        gpsLoc = locationManager!!.getLastKnownLocation(LocationManager.GPS_PROVIDER)
      if (networkEnabled)
        netLoc = locationManager!!.getLastKnownLocation(LocationManager.NETWORK_PROVIDER)

      //check which value use the latest one
      if (gpsLoc != null && netLoc != null) {
        if (gpsLoc.time > netLoc.time)
          locationCallBack.locationResult(gpsLoc)
        else
          locationCallBack.locationResult(netLoc)
        return
      }

      if (gpsLoc != null) {
        locationCallBack.locationResult(gpsLoc)
        return
      }
      if (netLoc != null) {
        locationCallBack.locationResult(netLoc)
        return
      }
      locationCallBack.locationResult(null)
    }
  }

  interface LocationCallBack {
    fun locationResult(location: Location?)
  }
}

অবস্থান পেতে কেবল getLocation পদ্ধতি হিসাবে কল করতে হবে -

AppLocationProvider().getLocation(context, object : AppLocationProvider.LocationCallBack {
  override fun locationResult(location: Location?) {
    // use location, this might get called in a different thread if a location is a last known location. In that case, you can post location on main thread
  }
})

দ্রষ্টব্য: getLocation পদ্ধতিতে কল করার আগে প্রয়োজনীয় অবস্থানের অনুমতি দিতে হবে।


1

পেতে এবং ব্যবহারকারীর বর্তমান অবস্থান দেখাতে, আপনার কাছে ব্যবহার করতে পারে MyLocationOverlay। ধরুন mapViewআপনার ক্রিয়াকলাপে আপনার কোনও ক্ষেত্র রয়েছে। ব্যবহারকারীর অবস্থানটি দেখানোর জন্য আপনাকে যা করতে হবে তা হ'ল:

myLocationOverlay = new MyLocationOverlay(this, mapView);
myLocationOverlay.enableMyLocation();
mapView.getOverlays().add(myLocationOverlay);

এটি জিপিএস বা নেটওয়ার্ক উভয় থেকে বর্তমান অবস্থান পায়। উভয় ব্যর্থ হলে, enableMyLocation()ফিরে আসবে false

আশেপাশের জিনিসগুলির অবস্থানগুলির জন্য, একটি ItemizedOverlayকৌশলটি করা উচিত।

আমি আশা করি আপনার প্রশ্নটি আমি ভুল বুঝি নি। শুভকামনা।


2
ধন্যবাদ. প্রশ্নটি এমন ক্রিয়াকলাপগুলির জন্য ছিল যেগুলিতে মানচিত্রের দৃষ্টিভঙ্গি নেই এবং ব্যবহারকারীর কাছে অবস্থানটি প্রদর্শনের দরকার নেই।
emmby

1

সম্পাদনা: গুগল প্লে পরিষেবা গ্রন্থাগার থেকে সর্বশেষ অবস্থান পরিষেবা এপিআই দিয়ে আপডেট হয়েছে (জুলাই ২০১৪)

আমি আপনাকে নতুন অবস্থান পরিষেবা API ব্যবহার করার পরামর্শ দিচ্ছি গুগল প্লে পরিষেবা লাইব্রেরি থেকে পাওয়া যা আরও শক্তিশালী, উচ্চ-স্তরের কাঠামো সরবরাহ করে যা লোকেশন সরবরাহকারীর পছন্দ এবং শক্তি পরিচালনার মতো কাজগুলিকে স্বয়ংক্রিয় করে তোলে mates অফিসিয়াল ডকুমেন্টেশন অনুসারে: "... অন্তর্নিহিত লোকেশন প্রযুক্তির বিশদটিতে ফোকাস করার প্রয়োজন ছাড়াই লোকেশন এপিআই আপনার পক্ষে অবস্থান-সচেতন অ্যাপ্লিকেশনগুলি তৈরি করা সহজ করে They ডিভাইস হার্ডওয়্যার। "

আরও তথ্যের জন্য দেখুন: আপনার অ্যাপ্লিকেশন অবস্থান-সচেতন করা

সর্বশেষতম পরিষেবা পরিষেবা এপিআই পরিদর্শন করে একটি পূর্ণ উদাহরণ দেখতে: অ্যান্ড্রয়েড লোকেশনক্লিয়েন্ট শ্রেণি অবনতিযুক্ত কিন্তু ডকুমেন্টেশনে ব্যবহৃত হয়েছে


0

জিওলোকেশনের জন্য সহজ এবং সর্বোত্তম উপায়।

LocationManager lm = null;
boolean network_enabled;


if (lm == null)
                lm = (LocationManager) Kikit.this.getSystemService(Context.LOCATION_SERVICE);

            network_enabled = lm.isProviderEnabled(LocationManager.NETWORK_PROVIDER);

            dialog = ProgressDialog.show(Kikit.this, "", "Fetching location...", true);


            final Handler handler = new Handler();
            timer = new Timer();
            TimerTask doAsynchronousTask = new TimerTask() {

                @Override
                public void run() {
                    handler.post(new Runnable() {

                        @Override
                        public void run() 
                        {

                            Log.e("counter value","value "+counter);

                            if(counter<=8)
                            {
                                try 
                                {
                                    counter++;


                                    if (network_enabled) {

                                        lm = (LocationManager) Kikit.this.getSystemService(Context.LOCATION_SERVICE);

                                        Log.e("in network_enabled..","in network_enabled");

                                        // Define a listener that responds to location updates
                                        LocationListener locationListener = new LocationListener() 
                                        {


                                            public void onLocationChanged(Location location) 
                                            {
                                                if(attempt == false)

                                                {
                                                    attempt = true;
                                                    Log.e("in location listener..","in location listener..");
                                                    longi = location.getLongitude();
                                                    lati = location.getLatitude();
                                                    Data.longi = "" + longi; 
                                                    Data.lati = "" + lati;


                                                    Log.e("longitude : ",""+longi);
                                                    Log.e("latitude : ",""+lati);



                                                    if(faceboo_name.equals(""))
                                                    {
                                                        if(dialog!=null){
                                                        dialog.cancel();}
                                                        timer.cancel();
                                                        timer.purge();
                                                        Data.homepage_resume = true;
                                                        lm = null;
                                                        Intent intent = new Intent();                              
                                                        intent.setClass(Kikit.this,MainActivity.class);

                                                        startActivity(intent);      
                                                        finish();
                                                    }
                                                    else
                                                    {           

                                                        isInternetPresent = cd.isConnectingToInternet();

                                                        if (isInternetPresent) 
                                                        {
                                                            if(dialog!=null)
                                                                dialog.cancel();

                                                            Showdata();
                                                        }
                                                        else
                                                        {
                                                            error_view.setText(Data.internet_error_msg);
                                                            error_view.setVisibility(0);
                                                            error_gone();
                                                        }

                                                    }   
                                                }

                                            }

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

                                            public void onProviderEnabled(String provider) {
                                                //Toast.makeText(getApplicationContext(), "Location enabled", Toast.LENGTH_LONG).show();

                                            }

                                            public void onProviderDisabled(String provider) {


                                            }
                                        };



                                        // Register the listener with the Location Manager to receive
                                        // location updates
                                        lm.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 100000, 10,locationListener);

                                    } else{
                                        //Toast.makeText(getApplicationContext(), "No Internet Connection.", 2000).show();
                                        buildAlertMessageNoGps();

                                    }



                                } catch (Exception e) {
                                    // TODO
                                    // Auto-generated
                                    // catch
                                    // block
                                }
                            }
                            else
                            {

                                timer.purge();
                                timer.cancel();

                                if(attempt == false)
                                {
                                    attempt = true;

                                    String locationProvider = LocationManager.NETWORK_PROVIDER;
                                    // Or use LocationManager.GPS_PROVIDER

                                    try {
                                        Location lastKnownLocation = lm.getLastKnownLocation(locationProvider);

                                        longi = lastKnownLocation.getLongitude();
                                        lati = lastKnownLocation.getLatitude();
                                        Data.longi = "" + longi; 
                                        Data.lati = "" + lati;
                                    } catch (Exception e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                        Log.i("exception in loc fetch", e.toString());
                                    }

                                    Log.e("longitude of last known location : ",""+longi);
                                    Log.e("latitude of last known location : ",""+lati);

                                    if(Data.fb_access_token == "")
                                    {

                                        if(dialog!=null){
                                            dialog.cancel();}
                                        timer.cancel();
                                        timer.purge();
                                        Data.homepage_resume = true;
                                        Intent intent = new Intent();                              
                                        intent.setClass(Kikit.this,MainActivity.class);

                                        startActivity(intent);  
                                        finish();
                                    }
                                    else
                                    {           

                                        isInternetPresent = cd.isConnectingToInternet();

                                        if (isInternetPresent) 
                                        {
                                            if(dialog!=null){
                                                dialog.cancel();}           
                                            Showdata();
                                        }
                                        else
                                        {
                                            error_view.setText(Data.internet_error_msg);
                                            error_view.setVisibility(0);
                                            error_gone();
                                        }

                                    }   

                                }
                            }
                        }
                    });
                }
            };
            timer.schedule(doAsynchronousTask, 0, 2000);


private void buildAlertMessageNoGps() {
        final AlertDialog.Builder builder = new AlertDialog.Builder(this);

        builder.setMessage("Your WiFi & mobile network location is disabled , do you want to enable it?")
        .setCancelable(false)
        .setPositiveButton("Yes", new DialogInterface.OnClickListener() {


            public void onClick(@SuppressWarnings("unused") final DialogInterface dialog, @SuppressWarnings("unused") final int id) 
            {
                startActivity(new Intent(android.provider.Settings.ACTION_LOCATION_SOURCE_SETTINGS));
                setting_page = true;
            }
        })
        .setNegativeButton("No", new DialogInterface.OnClickListener() {
            public void onClick(final DialogInterface dialog, @SuppressWarnings("unused") final int id) {
                dialog.cancel();
                finish();
            }
        });
        final AlertDialog alert = builder.create();
        alert.show();
    }

0

এখানে কিছুটা দেরি হয়েছে তবে আমি কী এমন পরিস্থিতিতে চাই তা হ'ল গুগল ম্যাপস এপিআই ব্যবহার করা এবং গুগল ম্যাপের ল্যাট এবং লম্বা এপিআই ব্যবহার করে কাছের অবস্থানগুলি চিহ্নিত করা। আপনি যদি কোনও মানচিত্রে তার অবস্থান প্রদর্শন করতে পারেন তবে ব্যবহারকারীর অভিজ্ঞতা আরও ভাল। ব্যবহারকারীর অবস্থান আপডেট হওয়া বা অ্যান্ড্রয়েড এপিআই দিয়ে ফ্রিজিংয়ের বিষয়ে মাথা ঘামানোর দরকার নেই। গুগল ম্যাপগুলি আপনার জন্য ইন্টার্নালগুলি পরিচালনা করতে দিন।

@ এমএমবিই সম্ভবত এটি তার অ্যাপ্লিকেশনটিতে সমাধান হয়ে গেছে তবে ভবিষ্যতের রেফারেন্সের জন্য লোকেশন নির্দিষ্ট সামগ্রীর জন্য গুগল ম্যাপস এপিআইয়ের উপর নজর দেওয়া হ'ল আমি সহকর্মী বিকাশকারীদের প্রস্তাব দিই।

সম্পাদনা করুন: গুগল ম্যাপে ব্যবহারকারীর অবস্থান প্রদর্শনের জন্য লিঙ্ক


0

অ্যান্ড্রয়েডে অবস্থান আপডেট পেতে এর জন্য প্রচুর পরিমাণে জিনিস প্রয়োজন, প্রচুর বোলিয়ারপ্লিট কোড প্রয়োজন।

আপনার যত্ন নেওয়া দরকার

  • গুগল প্লে পরিষেবাগুলি উপলভ্যতা পরীক্ষা করুন,
  • গুগল প্লে পরিষেবাটি পুরানো বা উপলভ্য থাকলে আপডেট করুন
  • GoogleApiClient এর সংলাপ তৈরি এবং এর কলব্যাকগুলি সংযুক্ত, সংযোগ বিচ্ছিন্ন করা ইত্যাদি
  • অবস্থান আপডেটের জন্য সংস্থানগুলি বন্ধ করা এবং ছেড়ে দেওয়া
  • অবস্থান অনুমতি পরিস্থিতি হ্যান্ডলিং
  • অবস্থানের পরিষেবাগুলি পরীক্ষা করা চালু বা বন্ধ রয়েছে
  • সর্বশেষ জ্ঞাত অবস্থান পাওয়া এত সহজ নয়
  • নির্দিষ্ট সময়ের পরে অবস্থান না পাওয়া গেলে সর্বশেষ জ্ঞাত স্থানে ফ্যালব্যাক

আমি অ্যান্ড্রয়েড-ইজিলোকেশন (ছোট অ্যান্ড্রয়েড লাইব্রেরি) তৈরি করেছি যা এই সমস্ত জিনিস যত্ন নেবে এবং আপনি ব্যবসায়ের যুক্তিতে মনোনিবেশ করতে পারেন।

আপনার যা দরকার তা হ'ল ইজিলোকেশনএকটিভিটি এবং এটি প্রসারিত

requestSingleLocationFix(easyLocationRequest);

অথবা

requestLocationUpdates(easyLocationRequest);

চেকআউট নমুনা অ্যাপ্লিকেশন এবং প্রয়োজনীয় পদক্ষেপগুলি এখানে https://github.com/akhgapt/Android- এসিএসএল লোকেশন


0

আমি যা করি তা এখানে:

  1. সবার আগে আমি যাচ্ছি যে নেটওয়র্ক বা জিপিএস সরবরাহকারী সক্ষম রয়েছে কিনা। কিছু ডিভাইসে অক্ষম হতে পারে, কিছু অ্যাপ্লিকেশন ম্যানিফেস্টে অক্ষম হতে পারে। যদি কোনও সরবরাহকারী সক্ষম হয়ে থাকে তবে আমি এই সরবরাহকারীর জন্য শেষ অবস্থানটি ক্যাশে করেছি এবং এই সরবরাহকারীর জন্য অবস্থান আপডেট শ্রোতাদের শুরু করি।
  2. সেখানে কিনা তা নির্ধারণ করতে একটি অবস্থান সর্বশেষ প্রাপ্ত অবস্থান লিঙ্কে উল্লিখিত বেশী ভালো একটি পদ্ধতি: - https://developer.android.com/guide/topics/location/strategies.html#BestEstimate
  3. যদি আমি অবস্থান শ্রোতার কাছ থেকে আপডেট পাই তবে আমি পরীক্ষা করে নিই যে এই অবস্থানটি আগের প্রাপ্ত স্থানের চেয়ে ভাল। এবং যদি এই অবস্থানটি আগের সেরা অবস্থান ( mFinalLocation) এ প্রতিস্থাপন করা ভাল হয় ।
  4. এছাড়াও দুই মিনিটের জন্য একটি হ্যান্ডলার (টাইমার) রয়েছে, যা পরিশেষে পরিষেবাটি বন্ধ করে দেয় এবং পরিষেবার onDestroy()পদ্ধতিতে, প্রতিটি সরবরাহকারীর জন্য অবস্থান আপডেটের জন্য শোনা বন্ধ করে দেয়।

নীচে পরিষেবার জন্য কোড দেওয়া আছে। আপনার প্রয়োজনীয় অবস্থান আপডেটের ফ্রিকোয়েন্সি অনুসারে আপনি এটি চালাতে পারেন।

import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.support.annotation.Nullable;
import android.util.Log;


public class RecordLocationService extends Service {

    private final String TAG = RecordLocationService.class.getSimpleName();

    private final int TWO_MINUTES = 1000 * 60 * 2;

    private LocationManager mLocationManager;

    private MyLocationListener mLocationListeners[] = new MyLocationListener[]{
            new MyLocationListener(LocationManager.NETWORK_PROVIDER),
            new MyLocationListener(LocationManager.GPS_PROVIDER)
    };

    private Location mFinalLocation;

    private class MyLocationListener implements LocationListener {
        private String mProvider;

        public MyLocationListener(String provider) {
            Log.d(TAG, "LocationListener : " + provider);
            mProvider = provider;
        }

        public String getProvider() {
            return mProvider;
        }

        @Override
        public void onLocationChanged(Location location) {
            Log.d(TAG, "onLocationChanged : " + location);

            if (isBetterLocation(location, mFinalLocation)) {
                Log.d(TAG, "Setting current Final Location to recent most Location for Provider : " + location.getProvider());
                Log.d(TAG, "Setting current Final Location to : " + location);
                mFinalLocation = location;
            } else {
                Log.d(TAG, "Keeping current Final Location to previous Final Location");
            }

        }

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

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

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

    private Handler mStopServiceHandler = new Handler() {

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 1: {
                    stopSelf();
                }
                break;
            }
        }
    };

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

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        super.onStartCommand(intent, flags, startId);
        Log.d(TAG, "onStartCommand");
        return START_STICKY;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        Log.d(TAG, "onCreate");
        requestLocation();
        mStopServiceHandler.sendEmptyMessageDelayed(1, TWO_MINUTES);
    }

    private void requestLocation() {
        // Acquire a reference to the system Location Manager
        if (mLocationManager == null) {
            mLocationManager = (LocationManager) this.getApplicationContext().getSystemService(Context.LOCATION_SERVICE);
        }

        try {
            if (mLocationManager.getAllProviders().contains(LocationManager.NETWORK_PROVIDER) && mLocationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER)) {
                Log.d(TAG, "Fetching Cached Location for Provider : " + LocationManager.NETWORK_PROVIDER);
                Location cachedNetworkLocation = mLocationManager.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);

                if (cachedNetworkLocation != null) {
                    Log.d(TAG, "Setting Final Location to Cached Location for Provider : " + LocationManager.NETWORK_PROVIDER);
                    Log.d(TAG, "Setting Final Location to : " + cachedNetworkLocation);
                    mFinalLocation = cachedNetworkLocation;
                } else {
                    Log.d(TAG, "Cached Location for Provider : " + LocationManager.NETWORK_PROVIDER + " is NULL");
                }

                Log.d(TAG, "Requesting Location Update for Provider : " + LocationManager.NETWORK_PROVIDER);
                mLocationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 0, 0, mLocationListeners[0]);
            }

        } catch (SecurityException se) {
            Log.e(TAG, se.getMessage(), se);
        } catch (IllegalArgumentException iae) {
            Log.e(TAG, iae.getMessage(), iae);
        }

        try {
            if (mLocationManager.getAllProviders().contains(LocationManager.GPS_PROVIDER) && mLocationManager.isProviderEnabled(LocationManager.GPS_PROVIDER)) {
                Log.d(TAG, "Fetching Cached Location for Provider : " + LocationManager.GPS_PROVIDER);
                Location cachedGPSLocation = mLocationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER);

                if (cachedGPSLocation != null) {
                    if (isBetterLocation(cachedGPSLocation, mFinalLocation)) {
                        Log.d(TAG, "Setting Final Location to Cached Location for Provider : " + LocationManager.GPS_PROVIDER);
                        Log.d(TAG, "Setting Final Location to : " + cachedGPSLocation);
                        mFinalLocation = cachedGPSLocation;
                    }
                } else {
                    Log.d(TAG, "Cached Location for Provider : " + LocationManager.GPS_PROVIDER + " is NULL");
                }

                Log.d(TAG, "Requesting Location Update for Provider : " + LocationManager.GPS_PROVIDER);
                mLocationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, mLocationListeners[1]);
            }

        } catch (SecurityException se) {
            Log.e(TAG, se.getMessage(), se);
        } catch (IllegalArgumentException iae) {
            Log.e(TAG, iae.getMessage(), iae);
        }


    }

    /**
     * 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);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.d(TAG, "onDestroy");
        if (mLocationManager != null) {
            for (int i = 0; i < mLocationListeners.length; i++) {
                try {
                    Log.d(TAG, "Removing Location Update for Provider : " + mLocationListeners[i].getProvider());
                    mLocationManager.removeUpdates(mLocationListeners[i]);
                } catch (Exception ex) {
                    Log.e(TAG, "fail to remove location listeners, ignore", ex);
                }
            }
        }
    }
}

0

@Fedor এর Kotlin সংস্করণ Greate উত্তর:

শ্রেণীর ব্যবহার:

val locationResult = object : MyLocation.LocationResult() {

    override fun gotLocation(location: Location?) {

        val lat = location!!.latitude
        val lon = location.longitude

        Toast.makeText(context, "$lat --SLocRes-- $lon", Toast.LENGTH_SHORT).show()
    }

}

val myLocation = MyLocation()
myLocation.getLocation(inflater.context, locationResult)

MyLocation শ্রেণি:

class MyLocation {
    internal lateinit var timer1: Timer
    internal var lm: LocationManager? = null
    internal lateinit var locationResult: LocationResult
    internal var gps_enabled = false
    internal var network_enabled = false

    internal var locationListenerGps: LocationListener = object : LocationListener {


        override fun onLocationChanged(location: Location) {
            timer1.cancel()
            locationResult.gotLocation(location)
            lm!!.removeUpdates(this)
            lm!!.removeUpdates(locationListenerNetwork)
        }

        override fun onProviderDisabled(provider: String) {}
        override fun onProviderEnabled(provider: String) {}
        override fun onStatusChanged(provider: String, status: Int, extras: Bundle) {}
    }

    internal var locationListenerNetwork: LocationListener = object : LocationListener {
        override fun onLocationChanged(location: Location) {
            timer1.cancel()
            locationResult.gotLocation(location)
            lm!!.removeUpdates(this)
            lm!!.removeUpdates(locationListenerGps)
        }

        override fun onProviderDisabled(provider: String) {}
        override fun onProviderEnabled(provider: String) {}
        override fun onStatusChanged(provider: String, status: Int, extras: Bundle) {}
    }

    fun getLocation(context: Context, result: LocationResult): Boolean {
        //I use LocationResult callback class to pass location value from MyLocation to user code.
        locationResult = result
        if (lm == null)
            lm = context.getSystemService(Context.LOCATION_SERVICE) as LocationManager?

        //exceptions will be thrown if provider is not permitted.
        try {
            gps_enabled = lm!!.isProviderEnabled(LocationManager.GPS_PROVIDER)
        } catch (ex: Exception) {
        }

        try {
            network_enabled = lm!!.isProviderEnabled(LocationManager.NETWORK_PROVIDER)
        } catch (ex: Exception) {
        }

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

        if (ActivityCompat.checkSelfPermission(context,
                Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED ||
            ActivityCompat.checkSelfPermission(context, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) run {

            ActivityCompat.requestPermissions(context as Activity,
                arrayOf(Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION), 111)
        }


        if (gps_enabled)
            lm!!.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0f, locationListenerGps)
        if (network_enabled)
            lm!!.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 0, 0f, locationListenerNetwork)
        timer1 = Timer()
        timer1.schedule(GetLastLocation(context), 20000)
        return true
    }

    internal inner class GetLastLocation(var context: Context) : TimerTask() {
        override fun run() {
            lm!!.removeUpdates(locationListenerGps)
            lm!!.removeUpdates(locationListenerNetwork)

            var net_loc: Location? = null
            var gps_loc: Location? = null

            if (ActivityCompat.checkSelfPermission(context,
                    Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED ||
                ActivityCompat.checkSelfPermission(context, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED
            ) run {

                ActivityCompat.requestPermissions(context as Activity,
                    arrayOf(Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION),111)
            }


            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)
        }
    }

     abstract class LocationResult {
          abstract fun gotLocation(location: Location?)
    }
}

0

ক্রিয়াকলাপ শ্রেণিতে একটি কাস্টমাইজড পদ্ধতি তৈরি করে:

private void getTheUserPermission() {
        ActivityCompat.requestPermissions(this, new String[]
                {Manifest.permission.ACCESS_FINE_LOCATION}, REQUEST_LOCATION);
        locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
        LocationGetter locationGetter = new LocationGetter(FreshMenuSearchActivity.this, REQUEST_LOCATION, locationManager);


        if (!locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER)) {

            locationGetter.OnGPS();
        } else {

            locationGetter.getLocation();
        }
    }

একটি ব্যবহারকারীর সংজ্ঞায়িত শ্রেণীর নাম লোকেশনগেটর করুন: -

public class LocationGetter {

        private int REQUEST_LOCATION;
        private FreshMenuSearchActivity mContext;
        private LocationManager locationManager;
        private Geocoder geocoder;

        public LocationGetter(FreshMenuSearchActivity mContext, int requestLocation, LocationManager locationManager) {
            this.mContext = mContext;
            this.locationManager = locationManager;
            this.REQUEST_LOCATION = requestLocation;
        }


        public void getLocation() {

            if (ActivityCompat.checkSelfPermission(mContext, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(mContext,

                    Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
                ActivityCompat.requestPermissions(mContext, new String[]
                        {Manifest.permission.ACCESS_FINE_LOCATION}, REQUEST_LOCATION);
            } else {
                Location LocationGps = locationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER);
                Location LocationNetwork = locationManager.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);
                Location LocationPassive = locationManager.getLastKnownLocation(LocationManager.PASSIVE_PROVIDER);

                if (LocationGps != null) {
                    double lat = LocationGps.getLatitude();
                    double longi = LocationGps.getLongitude();
                    getTheAddress(lat, longi);
                } else if (LocationNetwork != null) {
                    double lat = LocationNetwork.getLatitude();
                    double longi = LocationNetwork.getLongitude();
                    getTheAddress(lat, longi);
                } else if (LocationPassive != null) {
                    double lat = LocationPassive.getLatitude();
                    double longi = LocationPassive.getLongitude();
                    getTheAddress(lat, longi);
                } else {
                    Toast.makeText(mContext, "Can't Get Your Location", Toast.LENGTH_SHORT).show();
                }

            }

        }

        private void getTheAddress(double latitude, double longitude) {
            List<Address> addresses;
            geocoder = new Geocoder(mContext, Locale.getDefault());

            try {
                addresses = geocoder.getFromLocation(latitude, longitude, 1);
                String address = addresses.get(0).getAddressLine(0);
                String city = addresses.get(0).getLocality();
                String state = addresses.get(0).getAdminArea();
                String country = addresses.get(0).getCountryName();
                String postalCode = addresses.get(0).getPostalCode();
                String knownName = addresses.get(0).getFeatureName();
                Log.d("neel", address);
            } catch (IOException e) {
                e.printStackTrace();
            }


        }

        public void OnGPS() {

            final AlertDialog.Builder builder = new AlertDialog.Builder(mContext);

            builder.setMessage("Enable GPS").setCancelable(false).setPositiveButton("YES", new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    mContext.startActivity(new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS));
                }
            }).setNegativeButton("NO", new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {

                    dialog.cancel();
                }
            });
            final AlertDialog alertDialog = builder.create();
            alertDialog.show();
        }

    }

ব্যবহারকারীদের কনফিগারেশনে পুনর্নির্দেশের পরিবর্তে "YES" এ ক্লিক করে কীভাবে GPS সক্ষম করবেন?
অ্যালিটন অলিভিরা

যখন আপনি হ্যাঁ বোতামটিতে ক্লিক করুন: এমকন্টেক্সট.স্টার্টঅ্যাক্টিভিটি (নতুন উদ্দ্যোহ (সেটিংস.অ্যাকশন_এলশন_সেসিআরসিটিএসটিটিংস)); সুস্পষ্ট অভিপ্রায়টি জিপিএস সক্ষম করতে নিক্ষেপ করা হবে। @AlitonOliveira
neelkanth_vyas

-1

FusedLocationProviderApi ব্যবহার করে যা সর্বশেষতম এপিআই এবং অ্যান্ড্রয়েডে অবস্থান পাওয়ার জন্য উপলব্ধ সম্ভাবনার মধ্যে সেরা। বিল্ড.gradle ফাইল এ এটি যোগ করুন

dependencies {
    compile 'com.google.android.gms:play-services:6.5.87'
}

আপনি এই url দ্বারা সম্পূর্ণ উত্স কোড পেতে পারেন http://javapapers.com/android/android-location-fused-provider/


-1

কোডটির অবস্থান পাওয়ার জন্য সম্প্রতি রিফ্যাক্টর করে কিছু ভাল ধারণা শিখুন এবং শেষ পর্যন্ত তুলনামূলকভাবে নিখুঁত গ্রন্থাগার এবং ডেমো অর্জন করেছেন।

//request all valid provider(network/gps)
private boolean requestAllProviderUpdates() {
    checkRuntimeEnvironment();
    checkPermission();

    if (isRequesting) {
        EasyLog.d("Request location update is busy");
        return false;
    }


    long minTime = getCheckTimeInterval();
    float minDistance = getCheckMinDistance();

    if (mMapLocationListeners == null) {
        mMapLocationListeners = new HashMap<>();
    }

    mValidProviders = getValidProviders();
    if (mValidProviders == null || mValidProviders.isEmpty()) {
        throw new IllegalArgumentException("Not available provider.");
    }

    for (String provider : mValidProviders) {
        LocationListener locationListener = new LocationListener() {
            @Override
            public void onLocationChanged(Location location) {
                if (location == null) {
                    EasyLog.e("LocationListener callback location is null.");
                    return;
                }
                printf(location);
                mLastProviderTimestamp = location.getTime();

                if (location.getProvider().equals(LocationManager.GPS_PROVIDER)) {
                    finishResult(location);
                } else {
                    doLocationResult(location);
                }

                removeProvider(location.getProvider());
                if (isEmptyValidProviders()) {
                    requestTimeoutMsgInit();
                    removeUpdates();
                }
            }

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

            @Override
            public void onProviderEnabled(String provider) {
            }

            @Override
            public void onProviderDisabled(String provider) {
            }
        };
        getLocationManager().requestLocationUpdates(provider, minTime, minDistance, locationListener);
        mMapLocationListeners.put(provider, locationListener);
        EasyLog.d("Location request %s provider update.", provider);
    }
    isRequesting = true;
    return true;
}

//remove request update
public void removeUpdates() {
    checkRuntimeEnvironment();

    LocationManager locationManager = getLocationManager();
    if (mMapLocationListeners != null) {
        Set<String> keys = mMapLocationListeners.keySet();
        for (String key : keys) {
            LocationListener locationListener = mMapLocationListeners.get(key);
            if (locationListener != null) {
                locationManager.removeUpdates(locationListener);
                EasyLog.d("Remove location update, provider is " + key);
            }
        }
        mMapLocationListeners.clear();
        isRequesting = false;
    }
}

//Compared with the last successful position, to determine whether you need to filter
private boolean isNeedFilter(Location location) {
    checkLocation(location);

    if (mLastLocation != null) {
        float distance = location.distanceTo(mLastLocation);
        if (distance < getCheckMinDistance()) {
            return true;
        }
        if (location.getAccuracy() >= mLastLocation.getAccuracy()
                && distance < location.getAccuracy()) {
            return true;
        }
        if (location.getTime() <= mLastProviderTimestamp) {
            return true;
        }
    }
    return false;
}

private void doLocationResult(Location location) {
    checkLocation(location);

    if (isNeedFilter(location)) {
        EasyLog.d("location need to filtered out, timestamp is " + location.getTime());
        finishResult(mLastLocation);
    } else {
        finishResult(location);
    }
}

//Return to the finished position
private void finishResult(Location location) {
    checkLocation(location);

    double latitude = location.getLatitude();
    double longitude = location.getLongitude();
    float accuracy = location.getAccuracy();
    long time = location.getTime();
    String provider = location.getProvider();

    if (mLocationResultListeners != null && !mLocationResultListeners.isEmpty()) {
        String format = "Location result:<%f, %f> Accuracy:%f Time:%d Provider:%s";
        EasyLog.i(String.format(format, latitude, longitude, accuracy, time, provider));

        mLastLocation = location;
        synchronized (this) {
            Iterator<LocationResultListener> iterator =  mLocationResultListeners.iterator();
            while (iterator.hasNext()) {
                LocationResultListener listener = iterator.next();
                if (listener != null) {
                    listener.onResult(location);
                }
                iterator.remove();
            }
        }
    }
}

সম্পূর্ণ কোড: https://github.com/bingerz/FastLocation/blob/master/fastlocationlib/src/main/java/cn/bingerz/fastlocation/FastLocation.java

* অবস্থানটি সম্পূর্ণ করার জন্য প্রতিটি অনুরোধ, আপডেটগুলি অপসারণ করা ভাল, অন্যথায় ফোনের স্থিতি দণ্ড সর্বদা অবস্থানের আইকনটি প্রদর্শন করবে।


-1

সমস্ত উত্তর এবং প্রশ্ন দেখার পরে ( সিম্পলস্ট এবং রবস্ট )। আমি কেবল লাইব্রেরি অ্যান্ড্রয়েড-রিএ্যাকটিভ লোকেশন সম্পর্কে ক্লিক করেছি ।

যখন আমি একটি অবস্থান ট্র্যাকিং অ্যাপ তৈরি করেছি। তখন আমি বুঝতে পারি যে ব্যাটারি দিয়ে অনুকূলিতকরণের সাথে লোকেশন ট্র্যাকিং পরিচালনা করতে এটি খুব সাধারণ।

সুতরাং আমি ফ্রেশারদের এবং বিকাশকারীদেরও বলতে চাই যারা ভবিষ্যতের অপটিমাইজেশন সহ তাদের অবস্থানের কোডটি বজায় রাখতে চান না। এই গ্রন্থাগারটি ব্যবহার করুন।

ReactiveLocationProvider locationProvider = new 

    ReactiveLocationProvider(context);
    locationProvider.getLastKnownLocation()
        .subscribe(new Consumer<Location>() {
            @Override
            public void call(Location location) {
                doSthImportantWithObtainedLocation(location);
            }
        });

অ্যাপ্লিকেশন স্তরের build.gradle স্থাপনের উপর নির্ভরশীলতা

dependencies {
    ...
    compile 'pl.charmas.android:android-reactive-location2:2.1@aar'
    compile 'com.google.android.gms:play-services-location:11.0.4' //you can use newer GMS version if you need
    compile 'com.google.android.gms:play-services-places:11.0.4'
    compile 'io.reactivex:rxjava:2.0.5' //you can override RxJava version if you need
}

এই lib ব্যবহারের পেশাদাররা:

  • এই lib হয় এবং সক্রিয়ভাবে রক্ষণাবেক্ষণ করা হবে।
  • আপনি ব্যাটারি অপ্টিমাইজেশন সম্পর্কে চিন্তা করবেন না। বিকাশকারীরা তাদের সেরাটি করেছেন।
  • সহজ ইনস্টলেশন, নির্ভরতা রাখুন এবং খেলুন।
  • প্লে পরিষেবাদি এপিআইতে সহজেই সংযুক্ত হন
  • সর্বশেষ পরিচিত অবস্থান প্রাপ্ত
  • অবস্থান আপডেট ব্যবহারের জন্য সাবস্ক্রাইব করুন
  • অবস্থান সেটিংস API
  • জিওফেন্স পরিচালনা করুন
  • ঠিকানাগুলির তালিকাতে জিওকোডের অবস্থান
  • ক্রিয়াকলাপ স্বীকৃতি
  • বর্তমান স্থান এপিআই আনার জায়গা ব্যবহার করুন
  • স্বতঃসিদ্ধ পরামর্শ
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.