উত্তর:
আমি বর্তমান অবস্থানের জিপিএস স্থানাঙ্ক পেতে ধাপে ধাপে বর্ণনা সহ একটি ছোট অ্যাপ্লিকেশন তৈরি করেছি।
সম্পূর্ণ উদাহরণ উত্স কোডটি বর্তমান অবস্থান স্থানাঙ্ক, নগরের নাম - অ্যান্ড্রয়েডে রয়েছে ।
দেখো এটা কিভাবে কাজ করে:
আমাদের কেবল যা করা দরকার তা হল ম্যানিফেস্ট ফাইলটিতে এই অনুমতিটি যুক্ত করা:
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />এবং এটির মতো একটি লোকেশন ম্যানেজার উদাহরণ তৈরি করুন:
LocationManager locationManager = (LocationManager)
getSystemService(Context.LOCATION_SERVICE);জিপিএস সক্ষম আছে কিনা তা পরীক্ষা করে দেখুন।
এবং তারপরে লোকেশনলিস্টনার বাস্তবায়ন করুন এবং সমন্বয়গুলি পান:
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) {}
}adressesলাইনটিতে কেবল একটি ঠিকানা থাকলে শুরু করে cityName =ব্যতিক্রম হবে। ধনুর্বন্ধনী ব্যবহার করে এটি ঠিক হয়ে যাবে।
getLastKnownLocation()আরও "বাসি" অবস্থান - এটি কেন? কলিং কি getLastKnownLocation()ফোনের জিপিএসের সর্বশেষতম জিপিএস পাবে না?
অন্যান্য উত্তরের জন্য অতিরিক্ত তথ্য এখানে।
যেহেতু অ্যান্ড্রয়েড রয়েছে
GPS_PROVIDER and NETWORK_PROVIDERআপনি উভয়টিতে নিবন্ধন করতে পারেন onLocationChanged(Location location)এবং একই সাথে দু'এর থেকে ইভেন্টগুলি আনতে শুরু করতে পারেন । এ পর্যন্ত সব ঠিকই. এখন প্রশ্নটি আমাদের কী দুটি ফলাফলের প্রয়োজন বা আমাদের সেরা হওয়া উচিত। আমি জানি GPS_PROVIDERফলাফলের চেয়ে ভাল নির্ভুলতা আছে NETWORK_PROVIDER।
Locationফিল্ডটি সংজ্ঞায়িত করা যাক :
private Location currentBestLocation = null;অবস্থান পরিবর্তন সম্পর্কে শোনার আগে আমরা নিম্নলিখিত পদ্ধতিটি প্রয়োগ করব। এই পদ্ধতিটি জিপিএস এবং একটি নেটওয়ার্কের মধ্যে সর্বশেষ জ্ঞাত অবস্থানটি প্রদান করে। এই পদ্ধতির জন্য আরও ভাল।
/**
* @return the last know best location
*/
private Location getLastBestLocation() {
Location locationGPS = mLocationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER);
Location locationNet = mLocationManager.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);
long GPSLocationTime = 0;
if (null != locationGPS) { GPSLocationTime = locationGPS.getTime(); }
long NetLocationTime = 0;
if (null != locationNet) {
NetLocationTime = locationNet.getTime();
}
if ( 0 < GPSLocationTime - NetLocationTime ) {
return locationGPS;
}
else {
return locationNet;
}
}প্রতিবার যখন আমরা কোনও নতুন অবস্থান পুনরুদ্ধার করি তখন আমরা এটি আমাদের পূর্ববর্তী ফলাফলের সাথে তুলনা করব।
...
static final int TWO_MINUTES = 1000 * 60 * 2;
...আমি এতে একটি নতুন পদ্ধতি যুক্ত করেছি onLocationChanged:
@Override
public void onLocationChanged(Location location) {
makeUseOfNewLocation(location);
if(currentBestLocation == null){
currentBestLocation = location;
}
....
}
/**
* This method modify the last know good location according to the arguments.
*
* @param location The possible new location.
*/
void makeUseOfNewLocation(Location location) {
if ( isBetterLocation(location, currentBestLocation) ) {
currentBestLocation = location;
}
}
....
/** Determines whether one location reading is better than the current location fix
* @param location The new location that you want to evaluate
* @param currentBestLocation The current location fix, to which you want to compare the new one.
*/
protected boolean isBetterLocation(Location location, Location currentBestLocation) {
if (currentBestLocation == null) {
// A new location is always better than no location
return true;
}
// Check whether the new location fix is newer or older
long timeDelta = location.getTime() - currentBestLocation.getTime();
boolean isSignificantlyNewer = timeDelta > TWO_MINUTES;
boolean isSignificantlyOlder = timeDelta < -TWO_MINUTES;
boolean isNewer = timeDelta > 0;
// If it's been more than two minutes since the current location, use the new location,
// because the user has likely moved.
if (isSignificantlyNewer) {
return true;
// If the new location is more than two minutes older, it must be worse.
} else if (isSignificantlyOlder) {
return false;
}
// Check whether the new location fix is more or less accurate
int accuracyDelta = (int) (location.getAccuracy() - currentBestLocation.getAccuracy());
boolean isLessAccurate = accuracyDelta > 0;
boolean isMoreAccurate = accuracyDelta < 0;
boolean isSignificantlyLessAccurate = accuracyDelta > 200;
// Check if the old and new location are from the same provider
boolean isFromSameProvider = isSameProvider(location.getProvider(),
currentBestLocation.getProvider());
// Determine location quality using a combination of timeliness and accuracy
if (isMoreAccurate) {
return true;
} else if (isNewer && !isLessAccurate) {
return true;
} else if (isNewer && !isSignificantlyLessAccurate && isFromSameProvider) {
return true;
}
return false;
}
// Checks whether two providers are the same
private boolean isSameProvider(String provider1, String provider2) {
if (provider1 == null) {
return provider2 == null;
}
return provider1.equals(provider2);
}
....private Location currentBestLocation = null;করুন এবং oc MakeUseOfNewLocation (অবস্থান); add onLocationChanged (..) পদ্ধতিতে যুক্ত করুন
আপনি যে কোনও স্থান দ্বারা সন্ধান করতে পারেন GPS_PROVIDER or NETWORK_PROVIDER।
অ্যান্ড্রয়েডে অবস্থান পরিষেবাগুলির ওভারভিউ ।
এখানে একটি উদাহরণ যা জিপিএস ব্যবহার করে অবস্থানটি অনুসন্ধান করার চেষ্টা করে। যদি আপনার জিপিএস না পাওয়া যায় তবে অবস্থানটি অনুসন্ধানের জন্য নেটওয়ার্ক ব্যবহার করার চেষ্টা করুন।
GPSTracker.java
public class GPSTracker extends Service implements LocationListener {
private final Context mContext;
// Flag for GPS status
boolean isGPSEnabled = false;
// Flag for network status
boolean isNetworkEnabled = false;
// Flag for GPS status
boolean canGetLocation = false;
Location location; // Location
double latitude; // Latitude
double longitude; // Longitude
// The minimum distance to change Updates in meters
private static final long MIN_DISTANCE_CHANGE_FOR_UPDATES = 10; // 10 meters
// The minimum time between updates in milliseconds
private static final long MIN_TIME_BW_UPDATES = 1000 * 60 * 1; // 1 minute
// Declaring a Location Manager
protected LocationManager locationManager;
public GPSTracker(Context context) {
this.mContext = context;
getLocation();
}
public Location getLocation() {
try {
locationManager = (LocationManager) mContext
.getSystemService(LOCATION_SERVICE);
// Getting GPS status
isGPSEnabled = locationManager
.isProviderEnabled(LocationManager.GPS_PROVIDER);
// Getting network status
isNetworkEnabled = locationManager
.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
if (!isGPSEnabled && !isNetworkEnabled) {
// No network provider is enabled
} else {
this.canGetLocation = true;
if (isNetworkEnabled) {
locationManager.requestLocationUpdates(
LocationManager.NETWORK_PROVIDER,
MIN_TIME_BW_UPDATES,
MIN_DISTANCE_CHANGE_FOR_UPDATES, this);
Log.d("Network", "Network");
if (locationManager != null) {
location = locationManager
.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);
if (location != null) {
latitude = location.getLatitude();
longitude = location.getLongitude();
}
}
}
// If GPS enabled, get latitude/longitude using GPS Services
if (isGPSEnabled) {
if (location == null) {
locationManager.requestLocationUpdates(
LocationManager.GPS_PROVIDER,
MIN_TIME_BW_UPDATES,
MIN_DISTANCE_CHANGE_FOR_UPDATES, this);
Log.d("GPS Enabled", "GPS Enabled");
if (locationManager != null) {
location = locationManager
.getLastKnownLocation(LocationManager.GPS_PROVIDER);
if (location != null) {
latitude = location.getLatitude();
longitude = location.getLongitude();
}
}
}
}
}
}
catch (Exception e) {
e.printStackTrace();
}
return location;
}
/**
* Stop using GPS listener
* Calling this function will stop using GPS in your app.
* */
public void stopUsingGPS(){
if(locationManager != null){
locationManager.removeUpdates(GPSTracker.this);
}
}
/**
* Function to get latitude
* */
public double getLatitude(){
if(location != null){
latitude = location.getLatitude();
}
// return latitude
return latitude;
}
/**
* Function to get longitude
* */
public double getLongitude(){
if(location != null){
longitude = location.getLongitude();
}
// return longitude
return longitude;
}
/**
* Function to check GPS/Wi-Fi enabled
* @return boolean
* */
public boolean canGetLocation() {
return this.canGetLocation;
}
/**
* Function to show settings alert dialog.
* On pressing the Settings button it will launch Settings Options.
* */
public void showSettingsAlert(){
AlertDialog.Builder alertDialog = new AlertDialog.Builder(mContext);
// Setting Dialog Title
alertDialog.setTitle("GPS is settings");
// Setting Dialog Message
alertDialog.setMessage("GPS is not enabled. Do you want to go to settings menu?");
// On pressing the Settings button.
alertDialog.setPositiveButton("Settings", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog,int which) {
Intent intent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
mContext.startActivity(intent);
}
});
// On pressing the cancel button
alertDialog.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
dialog.cancel();
}
});
// Showing Alert Message
alertDialog.show();
}
@Override
public void onLocationChanged(Location location) {
}
@Override
public void onProviderDisabled(String provider) {
}
@Override
public void onProviderEnabled(String provider) {
}
@Override
public void onStatusChanged(String provider, int status, Bundle extras) {
}
@Override
public IBinder onBind(Intent arg0) {
return null;
}
}ক্রিয়াকলাপ - অ্যান্ড্রয়েড জিপিএসট্র্যাকিংঅ্যাক্টিভিটি.জভা
public class AndroidGPSTrackingActivity extends Activity {
Button btnShowLocation;
// GPSTracker class
GPSTracker gps;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
btnShowLocation = (Button) findViewById(R.id.btnShowLocation);
// Show location button click event
btnShowLocation.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View arg0) {
// Create class object
gps = new GPSTracker(AndroidGPSTrackingActivity.this);
// Check if GPS enabled
if(gps.canGetLocation()) {
double latitude = gps.getLatitude();
double longitude = gps.getLongitude();
// \n is for new line
Toast.makeText(getApplicationContext(), "Your Location is - \nLat: " + latitude + "\nLong: " + longitude, Toast.LENGTH_LONG).show();
} else {
// Can't get location.
// GPS or network is not enabled.
// Ask user to enable GPS/network in settings.
gps.showSettingsAlert();
}
}
});
}
}বিন্যাস- main.xml
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical" >
<Button android:id="@+id/btnShowLocation"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Show Location"
android:layout_centerVertical="true"
android:layout_centerHorizontal="true"/>
</RelativeLayout>Andro আইডি
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.INTERNET" />ইতিমধ্যে সেখানে অনেক উত্তর রয়েছে তবে আমি গুগল এপিআই ব্যবহার করে অবস্থানের সর্বশেষ উপায়টি দেখাতে চাই, যাতে নতুন প্রোগ্রামাররা নতুন পদ্ধতি ব্যবহার করতে পারেন:
অ্যানড্রয়েডের বর্তমান অবস্থান সম্পর্কিত বিশদ টিউটোরিয়াল আমি আমার ব্লগ demutsuts.com এ লিখেছি আপনি অ্যান্ড্রয়েড স্টুডিওতে বিকাশিত পুরো উত্স কোডটিও খুঁজে পেতে পারেন।
প্রথমত, গ্রেড ফাইল এ রাখুন
compile 'com.google.android.gms:play-services:9.0.2'তারপরে প্রয়োজনীয় ইন্টারফেস প্রয়োগ করুন
public class MainActivity extends BaseActivitiy implements GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener, com.google.android.gms.location.LocationListenerদৃষ্টান্তগুলি ঘোষণা করুন
private GoogleApiClient mGoogleApiClient;
private Location mLocation;
private LocationManager locationManager;
private LocationRequest mLocationRequest;এটি 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;
} startLocationUpdates();
mLocation = LocationServices.FusedLocationApi.getLastLocation(mGoogleApiClient);
if(mLocation == null){
startLocationUpdates();
}
if (mLocation != null) {
double latitude = mLocation.getLatitude();
double longitude = mLocation.getLongitude();
} else {
// Toast.makeText(this, "Location not Detected", Toast.LENGTH_SHORT).show();
}
}
protected void startLocationUpdates() {
// Create the location request
mLocationRequest = LocationRequest.create()
.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY)
.setInterval(UPDATE_INTERVAL)
.setFastestInterval(FASTEST_INTERVAL);
// Request location updates
if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
// TODO: Consider calling
// ActivityCompat#requestPermissions
// here to request the missing permissions, and then overriding
// public void onRequestPermissionsResult(int requestCode, String[] permissions,
// int[] grantResults)
// to handle the case where the user grants the permission. See the documentation
// for ActivityCompat#requestPermissions for more details.
return;
}
LocationServices.FusedLocationApi.requestLocationUpdates(mGoogleApiClient,
mLocationRequest, this);
Log.d("reque", "--->>>>");
}
@Override
public void onConnectionSuspended(int i) {
Log.i(TAG, "Connection Suspended");
mGoogleApiClient.connect();
}
@Override
public void onConnectionFailed(ConnectionResult connectionResult) {
Log.i(TAG, "Connection failed. Error: " + connectionResult.getErrorCode());
}
@Override
public void onStart() {
super.onStart();
mGoogleApiClient.connect();
}
@Override
public void onStop() {
super.onStop();
if (mGoogleApiClient.isConnected()) {
mGoogleApiClient.disconnect();
}
}
@Override
public void onLocationChanged(Location location) {
}অ্যাপ্লিকেশন চালানোর আগে আপনার ডিভাইসে জিপিএস শুরু করতে ভুলবেন না।
mLocationসর্বদা নাল দেয় আমি উল্লিখিত হিসাবে একই চেষ্টা করেছি
compile 'com.google.android.gms:play-services-location:11.0.4'আপনার অ্যাপ্লিকেশনটিতে সমস্ত গুগল প্লে পরিষেবা যুক্ত করার পরিবর্তে ব্যবহার করতে পারেন ।
যেহেতু আমি অন্যান্য উত্তরে কিছু কোড পছন্দ করি না, সুতরাং এটি আমার সহজ সমাধান। এই সমাধানটি কোনও কার্যকলাপ বা পরিষেবাতে অবস্থানটি ট্র্যাক করার জন্য ব্যবহারযোগ্য হওয়ার জন্য বোঝানো হয়েছে। এটি নিশ্চিত করে যে এটি বাসি ডেটা কখনই প্রেরণ করে না যদি না আপনি স্পষ্টভাবে বাসি ডেটার জন্য অনুরোধ না করেন। আপডেটগুলি গ্রহণ করার সাথে সাথে এটি আপডেট পেতে এটি একটি কলব্যাক মোডে চালানো যেতে পারে, বা সাম্প্রতিক তথ্যের জন্য পোল মোডে পোল মোডে।
জেনেরিক লোকেশনট্র্যাকার ইন্টারফেস। আমাদের একাধিক ধরণের লোকেশন ট্র্যাকার রাখতে দেয় এবং উপযুক্তটিকে সহজেই প্লাগ করতে দেয়:
package com.gabesechan.android.reusable.location;
import android.location.Location;
public interface LocationTracker {
public interface LocationUpdateListener{
public void onUpdate(Location oldLoc, long oldTime, Location newLoc, long newTime);
}
public void start();
public void start(LocationUpdateListener update);
public void stop();
public boolean hasLocation();
public boolean hasPossiblyStaleLocation();
public Location getLocation();
public Location getPossiblyStaleLocation();
}প্রোভাইডার লোকেশন ট্র্যাকার- এই শ্রেণিটি জিপিএস বা নেট ওয়ার্কের জন্য লোকেশন ট্র্যাক করবে।
package com.gabesechan.android.reusable.location;
import android.content.Context;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.Bundle;
public class ProviderLocationTracker implements LocationListener, LocationTracker {
// The minimum distance to change Updates in meters
private static final long MIN_UPDATE_DISTANCE = 10;
// The minimum time between updates in milliseconds
private static final long MIN_UPDATE_TIME = 1000 * 60;
private LocationManager lm;
public enum ProviderType{
NETWORK,
GPS
};
private String provider;
private Location lastLocation;
private long lastTime;
private boolean isRunning;
private LocationUpdateListener listener;
public ProviderLocationTracker(Context context, ProviderType type) {
lm = (LocationManager)context.getSystemService(Context.LOCATION_SERVICE);
if(type == ProviderType.NETWORK){
provider = LocationManager.NETWORK_PROVIDER;
}
else{
provider = LocationManager.GPS_PROVIDER;
}
}
public void start(){
if(isRunning){
//Already running, do nothing
return;
}
//The provider is on, so start getting updates. Update current location
isRunning = true;
lm.requestLocationUpdates(provider, MIN_UPDATE_TIME, MIN_UPDATE_DISTANCE, this);
lastLocation = null;
lastTime = 0;
return;
}
public void start(LocationUpdateListener update) {
start();
listener = update;
}
public void stop(){
if(isRunning){
lm.removeUpdates(this);
isRunning = false;
listener = null;
}
}
public boolean hasLocation(){
if(lastLocation == null){
return false;
}
if(System.currentTimeMillis() - lastTime > 5 * MIN_UPDATE_TIME){
return false; //stale
}
return true;
}
public boolean hasPossiblyStaleLocation(){
if(lastLocation != null){
return true;
}
return lm.getLastKnownLocation(provider)!= null;
}
public Location getLocation(){
if(lastLocation == null){
return null;
}
if(System.currentTimeMillis() - lastTime > 5 * MIN_UPDATE_TIME){
return null; //stale
}
return lastLocation;
}
public Location getPossiblyStaleLocation(){
if(lastLocation != null){
return lastLocation;
}
return lm.getLastKnownLocation(provider);
}
public void onLocationChanged(Location newLoc) {
long now = System.currentTimeMillis();
if(listener != null){
listener.onUpdate(lastLocation, lastTime, newLoc, now);
}
lastLocation = newLoc;
lastTime = now;
}
public void onProviderDisabled(String arg0) {
}
public void onProviderEnabled(String arg0) {
}
public void onStatusChanged(String arg0, int arg1, Bundle arg2) {
}
}এটি হ'ল ফ্যালব্যাকলোকেশন ট্র্যাকার, যা জিপিএস এবং নেটওয়াক উভয় দ্বারা ট্র্যাক করবে এবং যে কোনও অবস্থানটি আরও নির্ভুলভাবে ব্যবহার করবে।
package com.gabesechan.android.reusable.location;
import android.content.Context;
import android.location.Location;
import android.location.LocationManager;
public class FallbackLocationTracker implements LocationTracker, LocationTracker.LocationUpdateListener {
private boolean isRunning;
private ProviderLocationTracker gps;
private ProviderLocationTracker net;
private LocationUpdateListener listener;
Location lastLoc;
long lastTime;
public FallbackLocationTracker(Context context) {
gps = new ProviderLocationTracker(context, ProviderLocationTracker.ProviderType.GPS);
net = new ProviderLocationTracker(context, ProviderLocationTracker.ProviderType.NETWORK);
}
public void start(){
if(isRunning){
//Already running, do nothing
return;
}
//Start both
gps.start(this);
net.start(this);
isRunning = true;
}
public void start(LocationUpdateListener update) {
start();
listener = update;
}
public void stop(){
if(isRunning){
gps.stop();
net.stop();
isRunning = false;
listener = null;
}
}
public boolean hasLocation(){
//If either has a location, use it
return gps.hasLocation() || net.hasLocation();
}
public boolean hasPossiblyStaleLocation(){
//If either has a location, use it
return gps.hasPossiblyStaleLocation() || net.hasPossiblyStaleLocation();
}
public Location getLocation(){
Location ret = gps.getLocation();
if(ret == null){
ret = net.getLocation();
}
return ret;
}
public Location getPossiblyStaleLocation(){
Location ret = gps.getPossiblyStaleLocation();
if(ret == null){
ret = net.getPossiblyStaleLocation();
}
return ret;
}
public void onUpdate(Location oldLoc, long oldTime, Location newLoc, long newTime) {
boolean update = false;
//We should update only if there is no last location, the provider is the same, or the provider is more accurate, or the old location is stale
if(lastLoc == null){
update = true;
}
else if(lastLoc != null && lastLoc.getProvider().equals(newLoc.getProvider())){
update = true;
}
else if(newLoc.getProvider().equals(LocationManager.GPS_PROVIDER)){
update = true;
}
else if (newTime - lastTime > 5 * 60 * 1000){
update = true;
}
if(update){
if(listener != null){
listener.onUpdate(lastLoc, lastTime, newLoc, newTime);
}
lastLoc = newLoc;
lastTime = newTime;
}
}
}যেহেতু উভয়ই লোকেশনট্র্যাকার ইন্টারফেস প্রয়োগ করে, আপনি কোনটি ব্যবহার করবেন তা সহজেই আপনার মন পরিবর্তন করতে পারেন। পোল মোডে ক্লাস চালানোর জন্য, কেবল কল (স্টার্ট) কল করুন। এটি আপডেট মোডে চালাতে, কল স্টার্ট (শ্রোতা)।
এছাড়া আমার কটাক্ষপাত করা ব্লগ পোস্ট কোডের উপর
FallbackLocationTracker fallbackLocationTracker = new FallbackLocationTracker(mContext); fallbackLocationTracker.start(); if (fallbackLocationTracker.hasLocation()) { return fallbackLocationTracker.getLocation(); }
এর মাধ্যমে জিপিএসের অবস্থান পান -
LocationManager locationManager = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
LocationListener locationListener = new LocationListener()
{
@Override
public void onStatusChanged(String provider, int status, Bundle extras) {
// TODO Auto-generated method stub
}
@Override
public void onProviderEnabled(String provider) {
// TODO Auto-generated method stub
}
@Override
public void onProviderDisabled(String provider) {
// TODO Auto-generated method stub
}
@Override
public void onLocationChanged(Location location) {
// TODO Auto-generated method stub
double latitude = location.getLatitude();
double longitude = location.getLongitude();
double speed = location.getSpeed(); //spedd in meter/minute
speed = (speed*3600)/1000; // speed in km/minute Toast.makeText(GraphViews.this, "Current speed:" + location.getSpeed(),Toast.LENGTH_SHORT).show();
}
};
locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, locationListener);
}location.getSpeed()মিটার / সেকেন্ডে গতি ফেরত দেয় (মিটার / মিনিট নয়)।
আপনাকে সর্বশেষ / নতুন ব্যবহার করতে হবে
GoogleApiClient Api
মূলত আপনার যা করা দরকার তা হ'ল:
private GoogleApiClient mGoogleApiClient;
mGoogleApiClient = new GoogleApiClient.Builder(this)
.addApi(LocationServices.API)
.addConnectionCallbacks(this)
.addOnConnectionFailedListener(this)
.build();তারপর
@Override
public void onConnected(Bundle connectionHint) {
mLastLocation = LocationServices.FusedLocationApi.getLastLocation(
mGoogleApiClient);
if (mLastLocation != null) {
mLatitudeText.setText(String.valueOf(mLastLocation.getLatitude()));
mLongitudeText.setText(String.valueOf(mLastLocation.getLongitude()));
}
}সবচেয়ে নির্ভুল এবং নির্ভরযোগ্য অবস্থানের জন্য। আমার পোস্টটি এখানে দেখুন:
https://stackoverflow.com/a/33599228/2644905
লোকেশনলিস্টনার ব্যবহার করবেন না যা সঠিক নয় এবং প্রতিক্রিয়া বিলম্ব করেছে। সত্যি কথা বলতে এটিকে কার্যকর করা সহজ। ডকুমেন্টেশন এছাড়াও পড়ুন: https://developers.google.com/android/references/com/google/android/gms/common/api/GoogleApiClient
class MyLocation {
Timer timer1;
LocationManager lm;
LocationResult locationResult;
boolean gps_enabled = false;
boolean network_enabled = false;
public boolean getLocation(Context context, LocationResult result) {
// I use LocationResult callback class to pass location value from
// MyLocation to user code.
locationResult = result;
if (lm == null)
lm = (LocationManager) context
.getSystemService(Context.LOCATION_SERVICE);
// Exceptions will be thrown if the provider is not permitted.
try {
gps_enabled = lm.isProviderEnabled(LocationManager.GPS_PROVIDER);
}
catch (Exception ex) {
}
try {
network_enabled = lm
.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
}
catch (Exception ex) {
}
// Don't start listeners if no provider is enabled.
if (!gps_enabled && !network_enabled)
return false;
if (gps_enabled)
lm.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0,
locationListenerGps);
if (network_enabled)
lm.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 0, 0,
locationListenerNetwork);
timer1 = new Timer();
timer1.schedule(new GetLastLocation(), 5000);
return true;
}
LocationListener locationListenerGps = new LocationListener() {
public void onLocationChanged(Location location) {
timer1.cancel();
locationResult.gotLocation(location);
lm.removeUpdates(this);
lm.removeUpdates(locationListenerNetwork);
}
public void onProviderDisabled(String provider) {
}
public void onProviderEnabled(String provider) {
}
public void onStatusChanged(String provider, int status, Bundle extras) {
}
};
LocationListener locationListenerNetwork = new LocationListener() {
public void onLocationChanged(Location location) {
timer1.cancel();
locationResult.gotLocation(location);
lm.removeUpdates(this);
lm.removeUpdates(locationListenerGps);
}
public void onProviderDisabled(String provider) {
}
public void onProviderEnabled(String provider) {
}
public void onStatusChanged(String provider, int status, Bundle extras) {
}
};
class GetLastLocation extends TimerTask {
@Override
public void run() {
lm.removeUpdates(locationListenerGps);
lm.removeUpdates(locationListenerNetwork);
Location net_loc = null, gps_loc = null;
if (gps_enabled)
gps_loc = lm.getLastKnownLocation(LocationManager.GPS_PROVIDER);
if (network_enabled)
net_loc = lm
.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);
// If there are both values, use the latest one.
if (gps_loc != null && net_loc != null) {
if (gps_loc.getTime() > net_loc.getTime())
locationResult.gotLocation(gps_loc);
else
locationResult.gotLocation(net_loc);
return;
}
if (gps_loc != null) {
locationResult.gotLocation(gps_loc);
return;
}
if (net_loc != null) {
locationResult.gotLocation(net_loc);
return;
}
locationResult.gotLocation(null);
}
}
public static abstract class LocationResult {
public abstract void gotLocation(Location location);
}
}আমি আশা করি এটা তোমাকে সাহায্য করবে...
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
এখন যখন গুগল প্লে লোকেশন পরিষেবাগুলি এখানে রয়েছে, আমি প্রস্তাব দিচ্ছি যে বিকাশকারীরা নতুন ফিউজড অবস্থান সরবরাহকারীর ব্যবহার শুরু করুন। আপনি এটি ব্যবহার করা সহজ এবং আরও নির্ভুল পাবেন। দয়া করে ব্লু ডট ছাড়িয়ে গুগল আই / ও ভিডিও দেখুন : নতুন গুগল প্লে লোকেশন পরিষেবাদি এপিআই তৈরি করেছেন এমন দু'জনের দ্বারা অ্যান্ড্রয়েড লোকেশনে নতুন বৈশিষ্ট্য ।
আমি বেশ কয়েকটি মোবাইল প্ল্যাটফর্মে লোকেশন এপিআইয়ের সাথে কাজ করছি এবং আমি মনে করি এই দু'জন লোক যা করেছে তা সত্যই বিপ্লবী। এটি বিভিন্ন সরবরাহকারী ব্যবহার করার জটিলতার একটি বিশাল পরিমাণ থেকে মুক্তি পেয়েছে। স্ট্যাক ওভারফ্লো কোন প্রোডাক্টরটি ব্যবহার করবেন, শেষ পরিচিত অবস্থানটি ব্যবহার করবেন কিনা, লোকেশন ম্যানেজারে কীভাবে অন্যান্য বৈশিষ্ট্য সেট করবেন ইত্যাদি ইত্যাদি প্রশ্নে ফাঁক হয়ে যায় they ব্যবহার করুন।
আমি একটি অ্যান্ড্রয়েড অ্যাপ লিখেছি যা পর্যায়ক্রমে গুগল প্লে লোকেশন পরিষেবা ব্যবহার করে লোকেশন পায় এবং লোকেশনটি এমন একটি ওয়েব সার্ভারে প্রেরণ করে যেখানে এটি একটি ডাটাবেসে সঞ্চিত রয়েছে এবং গুগল ম্যাপে দেখা যাবে । আমি ক্লায়েন্ট সফটওয়্যার (অ্যান্ড্রয়েড, আইওএস, উইন্ডোজ ফোন এবং জাভা এমই এর জন্য ) এবং সার্ভার সফ্টওয়্যার (এএসপি.নেট এবং এসকিউএল সার্ভার বা পিএইচপি এবং মাইএসকিউএল ) উভয় লিখেছি । সফ্টওয়্যারটি প্রতিটি প্ল্যাটফর্মে স্থানীয় ভাষায় লেখা এবং প্রতিটিের পটভূমিতে সঠিকভাবে কাজ করে। সবশেষে, সফ্টওয়্যারটির এমআইটি লাইসেন্স রয়েছে । আপনি এখানে অ্যান্ড্রয়েড ক্লায়েন্ট খুঁজে পেতে পারেন:
https://github.com/nickfox/GpsTracker/tree/master/phoneClients/android
সবচেয়ে সহজ আপনি খুঁজে পেতে পারেন
package com.javapapers.android.geolocationfinder;
import android.os.Bundle;
import android.app.Activity;
import android.content.Context;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.widget.TextView;
import android.util.Log;
public class MainActivity extends Activity implements LocationListener{
protected LocationManager locationManager;
protected LocationListener locationListener;
protected Context context;
TextView txtLat;
String lat;
String provider;
protected String latitude,longitude;
protected boolean gps_enabled,network_enabled;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
txtLat = (TextView) findViewById(R.id.textview1);
locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, this);
}
@Override
public void onLocationChanged(Location location) {
txtLat = (TextView) findViewById(R.id.textview1);
txtLat.setText("Latitude:" + location.getLatitude() + ", Longitude:" + location.getLongitude());
}
@Override
public void onProviderDisabled(String provider) {
Log.d("Latitude","disable");
}
@Override
public void onProviderEnabled(String provider) {
Log.d("Latitude","enable");
}
@Override
public void onStatusChanged(String provider, int status, Bundle extras) {
Log.d("Latitude","status");
}
}লোকেশনম্যানেজার এমন একটি শ্রেণি যা সর্বশেষে জানার অবস্থান পাওয়ার জন্য অন্তর্নির্মিত পদ্ধতিগুলি সরবরাহ করে
পদক্ষেপ 1: নীচের মতো লোকেশন ম্যানেজার অবজেক্ট তৈরি করুন
লোকেশনম্যানেজার লোকেশন ম্যানেজার = (লোকেশনম্যানেজার) কনটেক্সট.জেটসিসটেমসোর্সেস (প্রসঙ্গ।
পদক্ষেপ 2: মানদণ্ড যুক্ত করুন
*Criteria is use for setting accuracy*
Criteria criteria = new Criteria();
int currentapiVersion = android.os.Build.VERSION.SDK_INT;
if (currentapiVersion >= android.os.Build.VERSION_CODES.HONEYCOMB) {
criteria.setSpeedAccuracy(Criteria.ACCURACY_HIGH);
criteria.setAccuracy(Criteria.ACCURACY_FINE);
criteria.setAltitudeRequired(true);
criteria.setBearingRequired(true);
criteria.setSpeedRequired(true);
}পদক্ষেপ 3: GET উপলভ্য সরবরাহকারী
হুমকি দুটি ধরণের সরবরাহকারী জিপিএস এবং নেটওয়ার্ক
String provider = locationManager.getBestProvider(criteria, true);পদক্ষেপ 4: সর্বশেষ জ্ঞানের অবস্থান পান
Location location = locationManager.getLastKnownLocation(provider);পদক্ষেপ 5: অক্ষাংশ এবং দ্রাঘিমাংশ পান
যদি অবস্থান বস্তুর নাল তারপর নিচের পদ্ধতি কলে Dont চেষ্টা নেই গুলি
getLatitude and getLongitude is methods which returns double values
অবস্থানের আপডেটগুলি পেতে অ্যান্ড্রয়েডে প্রচুর বোলিয়ারপ্লিট কোড প্রয়োজন, আপনার যত্ন নেওয়া দরকার to
এই সমস্ত পদক্ষেপগুলি সহজ করার জন্য আমি অ্যান্ড্রয়েড-ইজিলোকেশন (ছোট অ্যান্ড্রয়েড লাইব্রেরি) তৈরি করেছি যা এই সমস্ত জিনিস যত্ন নেবে এবং আপনি ব্যবসায়ের যুক্তিতে মনোনিবেশ করতে পারেন।
আপনার যা দরকার তা হ'ল ইজিলোকেশনএকটিভিটি এবং এটি প্রসারিত
requestSingleLocationFix(easyLocationRequest);অথবা
requestLocationUpdates(easyLocationRequest);চেকআউট নমুনা অ্যাপ্লিকেশন এবং প্রয়োজনীয় পদক্ষেপগুলি এখানে https://github.com/akhgapt/Android- এসিএসএল লোকেশন
আমি একটি প্রকল্প তৈরি করেছি যা থেকে আমরা গুগল প্লে পরিষেবা, জিপিএস এবং নেটওয়ার্ক সরবরাহকারী ব্যবহার করে সঠিক অবস্থানটি পেতে পারি। এই প্রকল্পটি এখানে পাওয়া যাবে ।
সেরা অবস্থানটি সন্ধানের কৌশলটি হ'ল প্রথমে গুগল প্লে পরিষেবাগুলি থেকে অবস্থানটি পাওয়া যায় যদি অবস্থানটি পাওয়া যায় তবে আবহাওয়া পরীক্ষা করুন এটি ভাল কিনা না, যদি অবস্থানটি পাওয়া যায় তবে গুগল প্লে পরিষেবাদি পুনরায় আরম্ভ করুন এবং অ্যান্ড্রয়েড অবস্থান এপিআই থেকে অবস্থানটি আনার চেষ্টা করুন। পরিবর্তন শ্রোতাদের উপর অবস্থানটি নিবন্ধ করুন এবং যখন কখনই আরও ভাল অবস্থান পাওয়া যায় তখন কলটি ফিরে ফিরে এটিকে মূল ক্রিয়ায় ফিরিয়ে দেয়।
কোডটি ব্যবহার করা এবং প্রয়োগ করা খুব সহজ যা কেবলমাত্র দুটি ক্লাসে এম্বেড করা দরকার LocationManagerInterfaceএবং SmartLocationManager, LocationActivityইন্টারফেসটি প্রয়োগ করছে এবং অবস্থান আনতে স্মার্টলোকেশনম্যানেজার ব্যবহার করছে।
/**
* Created by Syed Raza Mehdi Naqvi on 8/10/2016.
*/
public interface LocationManagerInterface {
String TAG = LocationManagerInterface.class.getSimpleName();
void locationFetched(Location mLocation, Location oldLocation, String time, String locationProvider);
}এখানে লোকেশন ম্যানেজার ক্লাস
import android.Manifest;
import android.app.Activity;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.IntentSender;
import android.content.pm.PackageManager;
import android.location.Location;
import android.location.LocationManager;
import android.os.Build;
import android.os.Bundle;
import android.support.v4.app.ActivityCompat;
import android.support.v4.content.ContextCompat;
import android.support.v7.app.AlertDialog;
import android.util.Log;
import android.widget.Toast;
import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.GooglePlayServicesUtil;
import com.google.android.gms.common.api.GoogleApiClient;
import com.google.android.gms.location.LocationListener;
import com.google.android.gms.location.LocationRequest;
import com.google.android.gms.location.LocationServices;
import java.text.DateFormat;
import java.util.Date;
/**
* Created by Syed Raza Mehdi Naqvi on 8/9/2016.
*/
public class SmartLocationManager implements
GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener, LocationListener {
private static final String TAG = SmartLocationManager.class.getSimpleName();
private static final int TWO_MINUTES = 1000 * 60 * 2;
private static final int PERMISSION_REQUEST_CODE = 1000;
private static final int CONNECTION_FAILURE_RESOLUTION_REQUEST = 9000;
// default value is false but user can change it
private String mLastLocationUpdateTime; // fetched location time
private String locationProvider; // source of fetched location
private Location mLastLocationFetched; // location fetched
private Location mLocationFetched; // location fetched
private Location networkLocation;
private Location gpsLocation;
private int mLocationPiority;
private long mLocationFetchInterval;
private long mFastestLocationFetchInterval;
private Context mContext; // application context
private Activity mActivity; // activity context
private LocationRequest mLocationRequest;
private GoogleApiClient mGoogleApiClient;
private LocationManagerInterface mLocationManagerInterface;
private android.location.LocationManager locationManager;
private android.location.LocationListener locationListener;
boolean isGPSEnabled;
boolean isNetworkEnabled;
private int mProviderType;
public static final int NETWORK_PROVIDER = 1;
public static final int ALL_PROVIDERS = 0;
public static final int GPS_PROVIDER = 2;
// private final double STANDARD_LOCATION_ACCURACY = 100.0;
// private final double STANDARD_LOCATION_SEED_LIMIT = 6.95;
public static final int LOCATION_PROVIDER_ALL_RESTICTION = 1;
public static final int LOCATION_PROVIDER_RESTRICTION_NONE = 0;
public static final int LOCATION_PROVIDER_GPS_ONLY_RESTICTION = 2;
public static final int LOCATION_PROVIDER_NETWORK_ONLY_RESTICTION = 3;
private int mForceNetworkProviders = 0;
public SmartLocationManager(Context context, Activity activity, LocationManagerInterface locationInterface, int providerType, int locationPiority, long locationFetchInterval, long fastestLocationFetchInterval, int forceNetworkProviders) {
mContext = context;
mActivity = activity;
mProviderType = providerType;
mLocationPiority = locationPiority;
mForceNetworkProviders = forceNetworkProviders;
mLocationFetchInterval = locationFetchInterval;
mFastestLocationFetchInterval = fastestLocationFetchInterval;
mLocationManagerInterface = locationInterface;
initSmartLocationManager();
}
public void initSmartLocationManager() {
// 1) ask for permission for Android 6 above to avoid crash
// 2) check if gps is available
// 3) get location using awesome strategy
askLocationPermission(); // for android version 6 above
checkNetworkProviderEnable(mForceNetworkProviders); //
if (isGooglePlayServicesAvailable()) // if googleplay services available
initLocationObjts(); // init obj for google play service and start fetching location
else
getLocationUsingAndroidAPI(); // otherwise get location using Android API
}
private void initLocationObjts() {
// Create the LocationRequest object
mLocationRequest = LocationRequest.create()
.setPriority(mLocationPiority)
.setInterval(mLocationFetchInterval) // 10 seconds, in milliseconds
.setFastestInterval(mFastestLocationFetchInterval); // 1 second, in milliseconds
if (mGoogleApiClient == null) {
mGoogleApiClient = new GoogleApiClient.Builder(mActivity)
.addConnectionCallbacks(this)
.addOnConnectionFailedListener(this)
.addApi(LocationServices.API)
.build();
}
startLocationFetching(); // connect google play services to fetch location
}
@Override
public void onConnected(Bundle connectionHint) {
Location location = LocationServices.FusedLocationApi.getLastLocation(mGoogleApiClient);
startLocationUpdates();
if (location == null) {
LocationServices.FusedLocationApi.requestLocationUpdates(mGoogleApiClient, mLocationRequest, this);
getLocationUsingAndroidAPI();
} else {
setNewLocation(getBetterLocation(location, mLocationFetched), mLocationFetched);
}
}
@Override
public void onLocationChanged(Location location) {
if (location == null) {
getLastKnownLocation();
} else {
setNewLocation(getBetterLocation(location, mLocationFetched), mLocationFetched);
}
}
@Override
public void onConnectionSuspended(int i) {
Log.i(TAG, "Connection suspended");
}
@Override
public void onConnectionFailed(ConnectionResult connectionResult) {
if (connectionResult.hasResolution()) {
try {
connectionResult.startResolutionForResult(mActivity, CONNECTION_FAILURE_RESOLUTION_REQUEST); // Start an Activity that tries to resolve the error
getLocationUsingAndroidAPI(); // try to get location using Android API locationManager
} catch (IntentSender.SendIntentException e) {
e.printStackTrace();
}
} else {
Log.i(TAG, "Location services connection failed with code " + connectionResult.getErrorCode());
}
}
private void setNewLocation(Location location, Location oldLocation) {
if (location != null) {
mLastLocationFetched = oldLocation;
mLocationFetched = location;
mLastLocationUpdateTime = DateFormat.getTimeInstance().format(new Date());
locationProvider = location.getProvider();
mLocationManagerInterface.locationFetched(location, mLastLocationFetched, mLastLocationUpdateTime, location.getProvider());
}
}
private void getLocationUsingAndroidAPI() {
// Acquire a reference to the system Location Manager
locationManager = (LocationManager) mContext.getSystemService(Context.LOCATION_SERVICE);
setLocationListner();
captureLocation();
}
public void captureLocation() {
if (Build.VERSION.SDK_INT >= 23 &&
ContextCompat.checkSelfPermission(mContext, android.Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED &&
ContextCompat.checkSelfPermission(mContext, android.Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
return;
}
try {
if (mProviderType == SmartLocationManager.GPS_PROVIDER) {
locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, locationListener);
} else if (mProviderType == SmartLocationManager.NETWORK_PROVIDER) {
locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 0, 0, locationListener);
} else {
locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 0, 0, locationListener);
locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, locationListener);
}
} catch (Exception e) {
Log.e(TAG, e.getMessage());
}
}
private void setLocationListner() {
// Define a listener that responds to location updates
locationListener = new android.location.LocationListener() {
public void onLocationChanged(Location location) {
// Called when a new location is found by the network location provider.
if (location == null) {
getLastKnownLocation();
} else {
setNewLocation(getBetterLocation(location, mLocationFetched), mLocationFetched);
// if (isLocationAccurate(location) && location.getAccuracy() < STANDARD_LOCATION_ACCURACY && location.getSpeed() < STANDARD_LOCATION_SEED_LIMIT) {// no use of this if
// setNewLocation(getBetterLocation(location, mLocationFetched), mLocationFetched);
// } else {
// setNewLocation(getBetterLocation(location, mLocationFetched), mLocationFetched);
// }
}
}
public void onStatusChanged(String provider, int status, Bundle extras) {
}
public void onProviderEnabled(String provider) {
}
public void onProviderDisabled(String provider) {
}
};
}
public Location getAccurateLocation() {
if (Build.VERSION.SDK_INT >= 23 &&
ContextCompat.checkSelfPermission(mContext, android.Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED &&
ContextCompat.checkSelfPermission(mContext, android.Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
return null;
}
try {
gpsLocation = locationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER);
networkLocation = locationManager.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);
Location newLocalGPS, newLocalNetwork;
if (gpsLocation != null || networkLocation != null) {
newLocalGPS = getBetterLocation(mLocationFetched, gpsLocation);
newLocalNetwork = getBetterLocation(mLocationFetched, networkLocation);
setNewLocation(getBetterLocation(newLocalGPS, newLocalNetwork), mLocationFetched);
}
} catch (Exception ex) {
Log.e(TAG, ex.getMessage());
}
return mLocationFetched;
}
protected void startLocationUpdates() {
LocationServices.FusedLocationApi.requestLocationUpdates(mGoogleApiClient, mLocationRequest, this);
}
public void startLocationFetching() {
mGoogleApiClient.connect();
if (mGoogleApiClient.isConnected()) {
startLocationUpdates();
}
}
public void pauseLocationFetching() {
if (mGoogleApiClient.isConnected()) {
LocationServices.FusedLocationApi.removeLocationUpdates(mGoogleApiClient, this);
mGoogleApiClient.disconnect();
}
}
public void abortLocationFetching() {
mGoogleApiClient.disconnect();
// Remove the listener you previously added
if (locationManager != null && locationListener != null) {
if (Build.VERSION.SDK_INT >= 23 &&
ContextCompat.checkSelfPermission(mContext, android.Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED &&
ContextCompat.checkSelfPermission(mContext, android.Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
return;
}
try {
locationManager.removeUpdates(locationListener);
locationManager = null;
} catch (Exception ex) {
Log.e(TAG, ex.getMessage());
}
}
}
public void resetLocation() {
mLocationFetched = null;
mLastLocationFetched = null;
networkLocation = null;
gpsLocation = null;
}
// Android M Permission check
public void askLocationPermission() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
if (ContextCompat.checkSelfPermission(mActivity, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED
|| ContextCompat.checkSelfPermission(mActivity, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED
) {
if (ActivityCompat.shouldShowRequestPermissionRationale(mActivity, Manifest.permission.ACCESS_COARSE_LOCATION)
|| ActivityCompat.shouldShowRequestPermissionRationale(mActivity, Manifest.permission.ACCESS_FINE_LOCATION)) {
final AlertDialog.Builder builder = new AlertDialog.Builder(mActivity);
builder.setMessage("Please allow all permissions in App Settings for additional functionality.")
.setCancelable(false)
.setPositiveButton("Allow", new DialogInterface.OnClickListener() {
public void onClick(@SuppressWarnings("unused") final DialogInterface dialog, @SuppressWarnings("unused") final int id) {
Toast.makeText(mContext, "Welcome", Toast.LENGTH_SHORT).show();
}
})
.setNegativeButton("Deny", new DialogInterface.OnClickListener() {
public void onClick(final DialogInterface dialog, @SuppressWarnings("unused") final int id) {
mActivity.finish();
}
});
final AlertDialog alert = builder.create();
alert.show();
} else
ActivityCompat.requestPermissions(mActivity, new String[]{Manifest.permission.ACCESS_COARSE_LOCATION
, Manifest.permission.ACCESS_FINE_LOCATION
}, PERMISSION_REQUEST_CODE);
}
}
}
public void checkNetworkProviderEnable(int enforceActive) {
locationManager = (LocationManager) mContext.getSystemService(Context.LOCATION_SERVICE);
isGPSEnabled = locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
isNetworkEnabled = locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
if (!isGPSEnabled && !isNetworkEnabled) {
buildAlertMessageTurnOnLocationProviders("Your location providers seems to be disabled, please enable it", "OK", "Cancel");
} else if (!isGPSEnabled && mForceNetworkProviders == LOCATION_PROVIDER_GPS_ONLY_RESTICTION) {
buildAlertMessageTurnOnLocationProviders("Your GPS seems to be disabled, please enable it", "OK", "Cancel");
} else if (!isNetworkEnabled && mForceNetworkProviders == LOCATION_PROVIDER_NETWORK_ONLY_RESTICTION) {
buildAlertMessageTurnOnLocationProviders("Your Network location provider seems to be disabled, please enable it", "OK", "Cancel");
}
// getting network status
if (!isGPSEnabled && !isNetworkEnabled) {
Toast.makeText(mContext, "Location can't be fetched!", Toast.LENGTH_SHORT).show(); // show alert
mActivity.finish();
}
}
private void buildAlertMessageTurnOnLocationProviders(String message, String positiveButtonText, String negativeButtonText) {
final AlertDialog.Builder builder = new AlertDialog.Builder(mActivity);
builder.setMessage(message)
.setCancelable(false)
.setPositiveButton(positiveButtonText, new DialogInterface.OnClickListener() {
public void onClick(@SuppressWarnings("unused") final DialogInterface dialog, @SuppressWarnings("unused") final int id) {
Intent mIntent = new Intent(android.provider.Settings.ACTION_LOCATION_SOURCE_SETTINGS);
mIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
mContext.startActivity(mIntent);
}
})
.setNegativeButton(negativeButtonText, new DialogInterface.OnClickListener() {
public void onClick(final DialogInterface dialog, @SuppressWarnings("unused") final int id) {
mActivity.finish();
}
});
final AlertDialog alert = builder.create();
alert.show();
}
public Location getLastKnownLocation() {
locationProvider = LocationManager.NETWORK_PROVIDER;
Location lastKnownLocation = null;
// Or use LocationManager.GPS_PROVIDER
if (Build.VERSION.SDK_INT >= 23 &&
ContextCompat.checkSelfPermission(mContext, android.Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED &&
ContextCompat.checkSelfPermission(mContext, android.Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
return lastKnownLocation;
}
try {
lastKnownLocation = locationManager.getLastKnownLocation(locationProvider);
return lastKnownLocation;
} catch (Exception e) {
Log.e(TAG, e.getMessage());
}
return lastKnownLocation;
}
public boolean isGooglePlayServicesAvailable() {
int status = GooglePlayServicesUtil.isGooglePlayServicesAvailable(mContext);
if (status == ConnectionResult.SUCCESS) {
return true;
} else {
return false;
}
}
/**
* Determines whether one Location reading is better than the current Location fix
*
* @param location The new Location that you want to evaluate
* @param currentBestLocation The current Location fix, to which you want to compare the new one
*/
protected Location getBetterLocation(Location location, Location currentBestLocation) {
if (currentBestLocation == null) {
// A new location is always better than no location
return location;
}
// Check whether the new location fix is newer or older
long timeDelta = location.getTime() - currentBestLocation.getTime();
boolean isSignificantlyNewer = timeDelta > TWO_MINUTES;
boolean isSignificantlyOlder = timeDelta < -TWO_MINUTES;
boolean isNewer = timeDelta > 0;
// If it's been more than two minutes since the current location, use the new location
// because the user has likely moved
if (isSignificantlyNewer) {
return location;
// If the new location is more than two minutes older, it must be worse
} else if (isSignificantlyOlder) {
return currentBestLocation;
}
// Check whether the new location fix is more or less accurate
int accuracyDelta = (int) (location.getAccuracy() - currentBestLocation.getAccuracy());
boolean isLessAccurate = accuracyDelta > 0;
boolean isMoreAccurate = accuracyDelta < 0;
boolean isSignificantlyLessAccurate = accuracyDelta > 200;
// Check if the old and new location are from the same provider
boolean isFromSameProvider = isSameProvider(location.getProvider(),
currentBestLocation.getProvider());
// Determine location quality using a combination of timeliness and accuracy
if (isMoreAccurate) {
return location;
} else if (isNewer && !isLessAccurate) {
return location;
} else if (isNewer && !isSignificantlyLessAccurate && isFromSameProvider) {
return location;
}
return currentBestLocation;
}
/**
* Checks whether two providers are the same
*/
private boolean isSameProvider(String provider1, String provider2) {
if (provider1 == null) {
return provider2 == null;
}
return provider1.equals(provider2);
}
public boolean isLocationAccurate(Location location) {
if (location.hasAccuracy()) {
return true;
} else {
return false;
}
}
public Location getStaleLocation() {
if (mLastLocationFetched != null) {
return mLastLocationFetched;
}
if (Build.VERSION.SDK_INT >= 23 &&
ContextCompat.checkSelfPermission(mContext, android.Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED &&
ContextCompat.checkSelfPermission(mContext, android.Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
return null;
}
if (mProviderType == SmartLocationManager.GPS_PROVIDER) {
return locationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER);
} else if (mProviderType == SmartLocationManager.NETWORK_PROVIDER) {
return locationManager.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);
} else {
return getBetterLocation(locationManager.getLastKnownLocation(LocationManager.NETWORK_PROVIDER), locationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER));
}
}
}আমরা এটি ক্রিয়াকলাপ বা কোনও টুকরা দিয়ে ব্যবহার করতে পারি, এখানে আমি এটি ক্রিয়াকলাপের সাথে ব্যবহার করছি
import android.location.Location;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.widget.TextView;
import android.widget.Toast;
import com.example.raza.locationaware.location.LocationManagerInterface;
import com.example.raza.locationaware.location.SmartLocationManager;
import com.google.android.gms.location.LocationRequest;
public class LocationActivity extends AppCompatActivity implements LocationManagerInterface {
public static final String TAG = LocationActivity.class.getSimpleName();
SmartLocationManager mLocationManager;
TextView mLocalTV, mLocationProviderTV, mlocationTimeTV;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_location);
mLocationManager = new SmartLocationManager(getApplicationContext(), this, this, SmartLocationManager.ALL_PROVIDERS, LocationRequest.PRIORITY_HIGH_ACCURACY, 10 * 1000, 1 * 1000, SmartLocationManager.LOCATION_PROVIDER_RESTRICTION_NONE); // init location manager
mLocalTV = (TextView) findViewById(R.id.locationDisplayTV);
mLocationProviderTV = (TextView) findViewById(R.id.locationProviderTV);
mlocationTimeTV = (TextView) findViewById(R.id.locationTimeFetchedTV);
}
protected void onStart() {
super.onStart();
mLocationManager.startLocationFetching();
}
protected void onStop() {
super.onStop();
mLocationManager.abortLocationFetching();
}
@Override
protected void onPause() {
super.onPause();
mLocationManager.pauseLocationFetching();
}
@Override
public void locationFetched(Location mLocal, Location oldLocation, String time, String locationProvider) {
Toast.makeText(getApplication(), "Lat : " + mLocal.getLatitude() + " Lng : " + mLocal.getLongitude(), Toast.LENGTH_LONG).show();
mLocalTV.setText("Lat : " + mLocal.getLatitude() + " Lng : " + mLocal.getLongitude());
mLocationProviderTV.setText(locationProvider);
mlocationTimeTV.setText(time);
}
}আশা করি এটি সহায়তা করে, যদি আপনি কোনও উন্নতির পরামর্শ দিতে পারেন তবে দয়া করে এটি গিটে পোস্ট করুন । ধন্যবাদ।
গুগল স্যাম্পেলের সাম্প্রতিক FusedLocationProviderApi ব্যবহার করে ভার্বোজের উদাহরণ রয়েছে। দুর্ভাগ্যক্রমে সর্বাধিক উত্সাহিত উত্তরগুলি তারিখের বাইরে।
FusedLocationProviderApi ব্যবহার করে অবস্থান পরিষেবাগুলি প্রয়োগ করতে নীচের উদাহরণগুলি অনুসরণ করুন
https://github.com/googlesamples/android-play-location/tree/master/LocationUpdates
যদি আপনি অ্যান্ড্রয়েডের জন্য নতুন অবস্থানের প্রকল্পগুলি তৈরি করে থাকেন তবে আপনার নতুন Google Play ব্যবহার করা উচিত লোকেশন পরিষেবাগুলি । এটি অনেক বেশি নির্ভুল এবং ব্যবহার করা সহজ।
আমি বেশ কয়েক বছর ধরে জিপিএসট্রেকার, ওপেন সোর্স জিপিএস ট্র্যাকার প্রকল্পে কাজ করছি। আমি সম্প্রতি অ্যান্ড্রয়েড, আইওএস, উইন্ডোজ ফোন এবং জাভা এমই সেল ফোনগুলির পর্যায়ক্রমিক আপডেটগুলি পরিচালনা করতে এটি আপডেট করেছি । এটি সম্পূর্ণরূপে কার্যকরী এবং আপনার যা প্রয়োজন তা করে এবং এমআইটি লাইসেন্স থাকে ।
জিপিএসট্রেকারের মধ্যে অ্যান্ড্রয়েড প্রকল্পটি নতুন গুগল প্লে পরিষেবা ব্যবহার করে এবং আপনাকে সেই ফোনগুলি ট্র্যাক করার অনুমতি দেওয়ার জন্য দুটি সার্ভার স্ট্যাক ( এএসপি.নেট এবং পিএইচপি ) রয়েছে।
কেবলমাত্র অবস্থান পরীক্ষার জন্য আপনি নিম্নলিখিত কোডটি ব্যবহার করতে পারেন। আপনি এটিকে মূল ক্রিয়াকলাপের আপনার স্টার্ট () এ রেখে দিতে পারেন এবং ফেরত মিথ্যা হলে সতর্কতা ডায়ালগ প্রদর্শন করতে পারেন।
private boolean isLocationAccurate()
{
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT)
{
String provider = Settings.Secure
.getString(getContentResolver(), Settings.Secure.LOCATION_PROVIDERS_ALLOWED);
if (provider != null && !provider.contains("gps"))
{
return false;
}
}
else
{
try
{
int status = Settings.Secure
.getInt(this.getContentResolver(), Settings.Secure.LOCATION_MODE);
if (status != Settings.Secure.LOCATION_MODE_HIGH_ACCURACY)
{
return false;
}
}
catch (Settings.SettingNotFoundException e)
{
Log.e(TAG, e.getMessage());
}
}
return true;
}আমি FusedLocationProviderClient
( গুগল প্লে পরিষেবাগুলির প্রয়োজন ) ব্যবহার করে খুব সঠিক অবস্থান পেয়েছি
অনুমতি প্রয়োজন
android.permission.ACCESS_FINE_LOCATION
android.permission.ACCESS_COARSE_LOCATION
বশ্যতা
'Com.google.android.gms: প্লে-সেবা-অবস্থান: 15.0.0'
কোটলিন কোড
val client = FusedLocationProviderClient(this)
val location = client.lastLocation
location.addOnCompleteListener {
// this is a lambda expression and we get an 'it' iterator to access the 'result'
// it.result.latitude gives the latitude
// it.result.longitude gives the longitude
val geocoder = Geocoder(applicationContext, Locale.getDefault())
val address = geocoder.getFromLocation(it.result.latitude, it.result.longitude, 1)
if (address != null && address.size > 0) {
// Get the current city
city = address[0].locality
}
}
location.addOnFailureListener {
// Some error in getting the location, let's log it
Log.d("xtraces", it.message)
}অবস্থান আনার সর্বোত্তম উপায় নীচে
// put dependancy
implementation 'com.google.android.gms:play-services-location:11.0.4'
// PUT permissions in Menifest
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
// create a Java file as below
public class SingleShotLocationProvider {
public static interface LocationCallback {
public void onNewLocationAvailable(GPSCoordinates location);
}
// calls back to calling thread, note this is for low grain: if you want higher precision, swap the
// contents of the else and if. Also be sure to check gps permission/settings are allowed.
// call usually takes <10ms
public static void requestSingleUpdate(final Context context, final LocationCallback callback) {
final LocationManager locationManager = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
boolean isNetworkEnabled = locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
if (isNetworkEnabled) {
Criteria criteria = new Criteria();
criteria.setAccuracy(Criteria.ACCURACY_COARSE);
if (ActivityCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED &&
ActivityCompat.checkSelfPermission(context, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
return;
}
locationManager.requestSingleUpdate(criteria, new LocationListener() {
@Override
public void onLocationChanged(Location location) {
callback.onNewLocationAvailable(new GPSCoordinates(location.getLatitude(), location.getLongitude()));
}
@Override
public void onStatusChanged(String provider, int status, Bundle extras) {
}
@Override
public void onProviderEnabled(String provider) {
}
@Override
public void onProviderDisabled(String provider) {
}
}, null);
} else {
boolean isGPSEnabled = locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
if (isGPSEnabled) {
Criteria criteria = new Criteria();
criteria.setAccuracy(Criteria.ACCURACY_FINE);
locationManager.requestSingleUpdate(criteria, new LocationListener() {
@Override
public void onLocationChanged(Location location) {
callback.onNewLocationAvailable(new GPSCoordinates(location.getLatitude(), location.getLongitude()));
}
@Override public void onStatusChanged(String provider, int status, Bundle extras) { }
@Override public void onProviderEnabled(String provider) { }
@Override public void onProviderDisabled(String provider) { }
}, null);
}
}
}
// consider returning Location instead of this dummy wrapper class
public static class GPSCoordinates {
public float longitude = -1;
public float latitude = -1;
public GPSCoordinates(float theLatitude, float theLongitude) {
longitude = theLongitude;
latitude = theLatitude;
}
public GPSCoordinates(double theLatitude, double theLongitude) {
longitude = (float) theLongitude;
latitude = (float) theLatitude;
}
}
}
// FILE FINISHED
// FETCH LOCATION FROM ACTIVITY AS BELOW
public void getLocation(Context context) {
MyApplication.log(LOG_TAG, "getLocation() ");
SingleShotLocationProvider.requestSingleUpdate(context,
new SingleShotLocationProvider.LocationCallback() {
@Override
public void onNewLocationAvailable(SingleShotLocationProvider.GPSCoordinates loc) {
location = loc;
MyApplication.log(LOG_TAG, "getLocation() LAT: " + location.latitude + ", LON: " + location.longitude);
}
});
}আমি একটি ছোট লাইব্রেরি প্রকাশ করেছি যা অ্যান্ড্রয়েডে অবস্থানের ডেটা পাওয়া সহজ করে তুলতে পারে, এমনকি এটি অ্যান্ড্রয়েড এম রানটাইম অনুমতিগুলিরও যত্ন নেয়।
আপনি এটি এখানে পরীক্ষা করে দেখতে পারেন: https://github.com/julioromano/RxLocation এবং আপনার প্রয়োগের উদাহরণ হিসাবে এটি বা এর উত্স কোড ব্যবহার করুন।
অন অবস্থানের পদ্ধতিতে সরল সন্ধানের লিখন কোড
public void onLocationChanged(Location location) {
if (mCurrLocationMarker != null) {
mCurrLocationMarker.remove();
}
//Place current location marker
LatLng latLng = new LatLng(location.getLatitude(), location.getLongitude());
MarkerOptions markerOptions = new MarkerOptions();
markerOptions.position(latLng);
markerOptions.title("Current Position");
markerOptions.icon(BitmapDescriptorFactory.defaultMarker(BitmapDescriptorFactory.HUE_RED));
mCurrLocationMarker = mMap.addMarker(markerOptions);
//move map camera
mMap.moveCamera(CameraUpdateFactory.newLatLng(latLng));
mMap.animateCamera(CameraUpdateFactory.zoomTo(18));
PolylineOptions pOptions = new PolylineOptions()
.width(5)
.color(Color.GREEN)
.geodesic(true);
for (int z = 0; z < routePoints.size(); z++) {
LatLng point = routePoints.get(z);
pOptions.add(point);
}
line = mMap.addPolyline(pOptions);
routePoints.add(latLng);
}আমি স্মার্ট লোকেশন লাইব্রেরি ব্যবহার করার পরামর্শ দেব
ব্যবহার করার জন্য খুব সহজ এবং এটি লোকেশনকে যুক্তিযুক্তভাবে সুন্দরভাবে মোড় দেয়।
অবস্থান পরিষেবাটি শুরু করার জন্য:
SmartLocation.with(context).location()
.start(new OnLocationUpdatedListener() { ... });আপনি যদি কেবল একটি একক অবস্থান পেতে চান (পর্যায়ক্রমে নয়) তবে আপনি কেবলমাত্র একটি ফিক্স পরিবর্তনকারী ব্যবহার করতে পারেন। উদাহরণ:
SmartLocation.with(context).location()
.oneFix()
.start(new OnLocationUpdatedListener() { ... });সহজ এবং সহজ উপায়,
Https://github.com/sachinvarma/EasyLocation ব্যবহার করে অবস্থান পান ।
পদক্ষেপ 1: শুধু কল করুন
new EasyLocationInit(MainActivity.this, timeInterval, fastestTimeInterval, runAsBackgroundService);টাইমইন্টারওয়াল -> সেটইন্টারভাল (দীর্ঘ) (ইনমিলি সেকেন্ডস) এর অর্থ - আপনি যে স্থানগুলি পেতে চান সেই বিরতিটি সেট করুন।
fastestTimeInterval -> সেটফেসেস্টেস্টিন্টারভালওয়াল (দীর্ঘ) (ইনমিলিসেকেন্ডস) এর অর্থ - কোনও স্থান যদি তাড়াতাড়ি পাওয়া যায় তবে আপনি এটি পেতে পারেন। (অর্থাত্ অন্য একটি অ্যাপ লোকেশন পরিষেবাদি ব্যবহার করছে)।
রানএসব্যাকগ্রাউন্ডসার্ভিচার = সত্য -> ( সার্ভিসটি ব্যাকগ্রাউন্ডে চলবে এবং প্রায়শই আপডেট করা হবে (সময় অনুসারে এবং দ্রুততম টাইমআইন্টারভাল অনুসারে)) রানআসব্যাকগ্রাউন্ডসেসওয়ার্স = মিথ্যা -> (পরিষেবাটি সফল অবস্থান আপডেটের পরে ডাস্ট্রয়েড হবে)
পদক্ষেপ 2: ইভেন্টবাসের গ্রাহকদের প্রস্তুত করুন: আপনার সাবস্ক্রাইব করার পদ্ধতিটি ঘোষণা করুন এবং এ্যানোটেট করুন optionচ্ছিকভাবে একটি থ্রেড মোড উল্লেখ করুন:
উদাহরণ:
@Override
public void onStart() {
super.onStart();
EventBus.getDefault().register(this);
}
@Override
public void onStop() {
super.onStop();
EventBus.getDefault().unregister(this);
}
@SuppressLint("SetTextI18n")
@Subscribe
public void getEvent(final Event event) {
if (event instanceof LocationEvent) {
if (((LocationEvent) event).location != null) {
((TextView) findViewById(R.id.tvLocation)).setText("The Latitude is "
+ ((LocationEvent) event).location.getLatitude()
+ " and the Longitude is "
+ ((LocationEvent) event).location.getLongitude());
}
}
}এখানেই শেষ.
আশা করি এটি ভবিষ্যতে কাউকে সহায়তা করবে।
2020 এপ্রিল
বর্তমান অবস্থান পেতে সম্পূর্ণ পদক্ষেপ এবং সর্বশেষ জ্ঞাত অবস্থান শূন্যতা এড়ানোর জন্য।
অফিসিয়াল ডকুমেন্টেশন অনুসারে , সর্বশেষ জ্ঞাত অবস্থানটি নাল হতে পারে :
এই ক্ষেত্রে, আপনার উচিত লোকেশন আপডেটগুলি অনুরোধ করা উচিত এবং লোকেশনক্যালব্যাকে নতুন অবস্থানটি গ্রহণ করা উচিত ।
নিম্নলিখিত পদক্ষেপের দ্বারা আপনার শেষ পরিচিত অবস্থানটি কখনই বাতিল হয় না।
পূর্ব-প্রয়োজনীয়: EasyPermission গ্রন্থাগার
পদক্ষেপ 1: ম্যানিফেস্ট ফাইলে এই অনুমতিটি যুক্ত করুন
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />ধাপ ২:
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
//Create location callback when it's ready.
createLocationCallback()
//createing location request, how mant request would be requested.
createLocationRequest()
//Build check request location setting request
buildLocationSettingsRequest()
//FusedLocationApiClient which includes location
mFusedLocationClient = LocationServices.getFusedLocationProviderClient(this)
//Location setting client
mSettingsClient = LocationServices.getSettingsClient(this)
//Check if you have ACCESS_FINE_LOCATION permission
if (!EasyPermissions.hasPermissions(
this@MainActivity,
Manifest.permission.ACCESS_FINE_LOCATION)) {
requestPermissionsRequired()
}
else{
//If you have the permission we should check location is opened or not
checkLocationIsTurnedOn()
}
}পদক্ষেপ 3: অনক্রিটে কল করার জন্য প্রয়োজনীয় ফাংশন তৈরি করুন ()
private fun requestPermissionsRequired() {
EasyPermissions.requestPermissions(
this,
getString(R.string.location_is_required_msg),
LOCATION_REQUEST,
Manifest.permission.ACCESS_FINE_LOCATION
)
}
private fun createLocationCallback() {
//Here the location will be updated, when we could access the location we got result on this callback.
mLocationCallback = object : LocationCallback() {
override fun onLocationResult(locationResult: LocationResult) {
super.onLocationResult(locationResult)
mCurrentLocation = locationResult.lastLocation
}
}
}
private fun buildLocationSettingsRequest() {
val builder = LocationSettingsRequest.Builder()
builder.addLocationRequest(mLocationRequest!!)
mLocationSettingsRequest = builder.build()
builder.setAlwaysShow(true)
}
private fun createLocationRequest() {
mLocationRequest = LocationRequest.create()
mLocationRequest!!.interval = 0
mLocationRequest!!.fastestInterval = 0
mLocationRequest!!.numUpdates = 1
mLocationRequest!!.priority = LocationRequest.PRIORITY_HIGH_ACCURACY
}
public fun checkLocationIsTurnedOn() { // Begin by checking if the device has the necessary location settings.
mSettingsClient!!.checkLocationSettings(mLocationSettingsRequest)
.addOnSuccessListener(this) {
Log.i(TAG, "All location settings are satisfied.")
startLocationUpdates()
}
.addOnFailureListener(this) { e ->
val statusCode = (e as ApiException).statusCode
when (statusCode) {
LocationSettingsStatusCodes.RESOLUTION_REQUIRED -> {
try {
val rae = e as ResolvableApiException
rae.startResolutionForResult(this@MainActivity, LOCATION_IS_OPENED_CODE)
} catch (sie: IntentSender.SendIntentException) {
}
}
LocationSettingsStatusCodes.SETTINGS_CHANGE_UNAVAILABLE -> {
mRequestingLocationUpdates = false
}
}
}
}
private fun startLocationUpdates() {
mFusedLocationClient!!.requestLocationUpdates(
mLocationRequest,
mLocationCallback, null
)
}পদক্ষেপ 4:
অবস্থানটি খোলার বিষয়টি নিশ্চিত করার পরে বা ব্যবহারকারী এটি খুলতে স্বীকার করে নেওয়ার পরে অ্যাক্টিভিটি রেজাল্ট () এ কলব্যাকগুলি পরিচালনা করুন ।
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
super.onActivityResult(requestCode, resultCode, data)
when (requestCode) {
LOCATION_IS_OPENED_CODE -> {
if (resultCode == AppCompatActivity.RESULT_OK) {
Log.d(TAG, "Location result is OK")
} else {
activity?.finish()
}
}
}পদক্ষেপ 5: FusedClientApi থেকে শেষ পরিচিত অবস্থান পান
override fun onMapReady(map: GoogleMap) {
mMap = map
mFusedLocationClient.lastLocation.addOnSuccessListener {
if(it!=null){
locateUserInMap(it)
}
}
}
private fun locateUserInMap(location: Location) {
showLocationSafetyInformation()
if(mMap!=null){
val currentLocation = LatLng(location.latitude,location.longitude )
addMarker(currentLocation)
}
}
private fun addMarker(currentLocation: LatLng) {
val cameraUpdate = CameraUpdateFactory.newLatLng(currentLocation)
mMap?.clear()
mMap?.addMarker(
MarkerOptions().position(currentLocation)
.title("Current Location")
)
mMap?.moveCamera(cameraUpdate)
mMap?.animateCamera(cameraUpdate)
mMap?.setMinZoomPreference(14.0f);
}আমি আশা করি এটি সাহায্য করবে
শুভ কোডিং