java - स्थान स्थिति के आधार पर स्थान अपडेट किया जा रहा है




android google-api (2)

ActivityRecognition उपयोगकर्ता स्थिति (जो हर 3 मिनट कॉल करता है), जैसे IN_VEHICLE, ON_FOOT, रनिंग आदि के लिए मुझे उपयोगकर्ता की फ्यूजस्लोकेशन एपीआई (स्थानांतरित करने की आवश्यकता है)।

प्रत्येक ईवेंट पर मुझे नियमित अंतराल के बाद उपयोगकर्ता स्थान की आवश्यकता होती है उदाहरण के लिए:

यदि उपयोगकर्ता अभी भी सेट setInterval(5*60*60*1000); और 5 घंटे से पहले के स्थान पर अगले स्थान अपडेट की जांच न करें। लेकिन गतिविधि की मान्यता हर 3 मिनट पर कॉल करेंगे

यदि उपयोगकर्ता चल रहा है तो सेट setInterval(2*60*1000); और 2 मिनट के बाद / पहले नहीं के अगले स्थान अपडेट की जांच करें लेकिन गतिविधि की मान्यता हर 3 मिनट पर कॉल करेंगे

यदि उपयोगकर्ता चल रहा है तो उपयोगकर्ता हर 1 मिनट में स्थान भेजते हैं, तो उपयोगकर्ता हर 15 मिनट में स्थानांतरित हो रहा है।

मैंने बुलियन झूठे को सेट करने की कोशिश की, कक्षा स्तर पर गलत और सही पर onConnected । लेकिन यह हमेशा सच हो जाता है क्योंकि पूरे इंटेंट सेवा को 3 मिनट के बाद कहा जाता है

if (startLocationFirst){
requestLocatonSetting(5*60*60*1000,3*60*60*1000,LocationRequest.PRIORITY_HIGH_ACCURACY); 
  LocationAPIclient.connect();// RequestLocation and GoogleAPIClient won't call until device comes from another ActivityRecognation State running,walking etc. And keep Updating location every 5 hours.
              }

मुद्दा मैं वर्तमान में कर रहा हूँ

  • गतिविधि startLocationFirst उपयोगकर्ता राज्य को हर 3 मिनट में मिल जाता है लेकिन इसे startLocationFirst में प्रवेश नहीं करना चाहिए startLocationFirst बुलियन जब तक कि यह किसी अन्य गतिविधि की startLocationFirst राज्य से नहीं आता है और startLocationFirst में निर्धारित स्थान के रूप में अद्यतन रखना startLocationFirst

यहाँ फ्यूजलेक्शन के साथ इंटेंट सेवा है

public class Activity_Recognized_Service extends IntentService implements GoogleApiClient.OnConnectionFailedListener, GoogleApiClient.ConnectionCallbacks, LocationListener {
    /**
     * Creates an IntentService.  Invoked by your subclass's constructor.
     *
     * @param name Used to name the worker thread, important only for debugging.
     */
    public static final String TAG = "###RECOGNISED SRVCE###";
    Timer timer;
    GoogleApiClient LocationAPIclient;
    LocationRequest mLocationRequest;
    Location mCurrentLocation;
    boolean startLocationFirst=true;


    public Activity_Recognized_Service() {
        super("Activity_Recognized_Service");
    }

    public Activity_Recognized_Service(String name) {
        super(name);
    }

    @Override
    protected void onHandleIntent(@Nullable Intent intent) {
        Log.d(TAG, "On Handle Intent");
        if (ActivityRecognitionResult.hasResult(intent)) {
            Log.d(TAG, "ActivityRecognition Has Result");
            ActivityRecognitionResult result = ActivityRecognitionResult.extractResult(intent);
            handleDetectedActivities(result.getProbableActivities());
            Navigation_Drawer nav = new Navigation_Drawer();
            nav.UserMovementResult(result);

        }
    }

    @Override
    public void onCreate() {
        super.onCreate();
        Log.d(TAG,"On Create Calling");
        if (LocationAPIclient == null) {
            Log.d(TAG, "Location API is NULL Value Of This ");
            LocationAPIclient = new GoogleApiClient.Builder(this)
                    .addApi(LocationServices.API)
                    .addConnectionCallbacks(this)
                    .addOnConnectionFailedListener(this)
                    .build();
        }

    }

    private void handleDetectedActivities(List<DetectedActivity> probableActivities) {

        for (DetectedActivity activity : probableActivities) {
            switch (activity.getType()) {
                case DetectedActivity.IN_VEHICLE:
                    Log.d(TAG, "In Vehicle " + activity.getConfidence());
                    if (activity.getConfidence() >= 75) {
                        //Send Notification To User
                        NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
                        builder.setContentText("In Vehicle");
                        builder.setSmallIcon(R.drawable.elaxer_x);
                        builder.setContentTitle("Elaxer");
                        NotificationManagerCompat.from(this).notify(0, builder.build());
                        requestLocatonSetting(10*60*1000,8*60*1000,LocationRequest.PRIORITY_HIGH_ACCURACY); //5 hours= hours * 60 min*60 sec* 1000 milliseconds
                        //requestLocatonSetting(6*60*1000,6*60*1000,LocationRequest.PRIORITY_HIGH_ACCURACY); //TEST
                        LocationAPIclient.connect();
                        if (startLocationFirst){
                            Log.d(TAG,"Start Location Update For Car");
                        }
                    }
                    break;
                case DetectedActivity.ON_BICYCLE:
                    Log.d(TAG, "On Bicycle " + activity.getConfidence());
                    if (activity.getConfidence() >= 75) {
                        //Send Notification To User
                        NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
                        builder.setContentText("On Bicycle");
                        builder.setSmallIcon(R.drawable.elaxer_x);
                        builder.setContentTitle("Elaxer");
                        NotificationManagerCompat.from(this).notify(0, builder.build());
                        requestLocatonSetting(7*60*1000,5*60*1000,LocationRequest.PRIORITY_HIGH_ACCURACY); //5 hours= hours * 60 min*60 sec* 1000 milliseconds
                        //requestLocatonSetting(6*60*1000,6*60*1000,LocationRequest.PRIORITY_HIGH_ACCURACY); //TEST
                        LocationAPIclient.connect();
                    }
                    break;
                case DetectedActivity.ON_FOOT:
                    Log.d(TAG, "On Foot " + activity.getConfidence());
                    if (activity.getConfidence() >= 75) {
                        //Send Notification To User
                        NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
                        builder.setContentText("On Foot");
                        builder.setSmallIcon(R.drawable.elaxer_x);
                        builder.setContentTitle("Elaxer");
                        NotificationManagerCompat.from(this).notify(0, builder.build());
                    }
                    break;
                case DetectedActivity.RUNNING:
                    Log.d(TAG, "On Running " + activity.getConfidence());
                    if (activity.getConfidence() >= 75) {
                        //Send Notification To User
                        NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
                        builder.setContentText("Running");
                        builder.setSmallIcon(R.drawable.elaxer_x);
                        builder.setContentTitle("Elaxer");
                        NotificationManagerCompat.from(this).notify(0, builder.build());
                        requestLocatonSetting(3*60*1000,2*60*1000,LocationRequest.PRIORITY_HIGH_ACCURACY); //5 hours= hours * 60 min*60 sec* 1000 milliseconds
                        //requestLocatonSetting(6*60*1000,6*60*1000,LocationRequest.PRIORITY_HIGH_ACCURACY); //TEST
                        LocationAPIclient.connect();
                    }
                    break;
                case DetectedActivity.STILL:
                    Log.d(TAG, "On Still " + activity.getConfidence());
                    if (activity.getConfidence() >= 75) {
                        //Send Notification To User
                        NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
                        builder.setContentText("Still");
                        builder.setSmallIcon(R.drawable.elaxer_x);
                        builder.setContentTitle("Elaxer");
                        NotificationManagerCompat.from(this).notify(0, builder.build());

                            requestLocatonSetting(5*60*60*1000,3*60*60*1000,LocationRequest.PRIORITY_HIGH_ACCURACY); //5 hours= hours * 60 min*60 sec* 1000 milliseconds
                          //  requestLocatonSetting(3*60*1000,2*60*1000,LocationRequest.PRIORITY_HIGH_ACCURACY); //TEST
                            LocationAPIclient.connect();


                    }
                    break;
                case DetectedActivity.TILTING:
                    Log.d(TAG, "On Tilting " + activity.getConfidence());
                    if (activity.getConfidence() >= 75) {
                        //Send Notification To User
                        NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
                        builder.setContentText("Tilting");
                        builder.setSmallIcon(R.drawable.elaxer_x);
                        builder.setContentTitle("Elaxer");
                        NotificationManagerCompat.from(this).notify(0, builder.build());

                        requestLocatonSetting(3*60*1000,2*60*1000,LocationRequest.PRIORITY_HIGH_ACCURACY); //5 hours= hours * 60 min*60 sec* 1000 milliseconds
                        //requestLocatonSetting(6*60*1000,6*60*1000,LocationRequest.PRIORITY_HIGH_ACCURACY); //TEST
                        LocationAPIclient.connect();
                    }
                    break;
                case DetectedActivity.WALKING:
                    Log.d(TAG, "On Walking " + activity.getConfidence());
                    if (activity.getConfidence() >= 75) {
                        //Send Notification To User
                        NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
                        builder.setContentText("Let's Walk");
                        builder.setSmallIcon(R.drawable.elaxer_x);
                        builder.setContentTitle("Elaxer");
                        NotificationManagerCompat.from(this).notify(0, builder.build());
                        requestLocatonSetting(3*60*1000,2*60*1000,LocationRequest.PRIORITY_HIGH_ACCURACY); //5 hours= hours * 60 min*60 sec* 1000 milliseconds
                        LocationAPIclient.connect();

                    }
                    break;
                case DetectedActivity.UNKNOWN:
                    Log.d(TAG, "UnKnown " + activity.getConfidence());
                    break;
            }
        }
    }

    public void setTimer(int Minutes) {
        Log.d(TAG, "==================================================");
        Log.d(TAG, "Set Timeer Starts It will Run Every " + Minutes);
        int MilliSeconds = 60000 * Minutes;
        final Handler handler = new Handler();
        timer = new Timer();
        TimerTask doAsynchronousTask = new TimerTask() {
            @Override
            public void run() {
                handler.post(new Runnable() {
                    public void run() {
                        try {
                            //CODE THAT YOU WANT TO EXECUTE AT GIVEN INTERVAL


                        } catch (Exception e) {
                            // TODO Auto-generated catch block
                        }
                    }
                });
            }
        };
        timer.schedule(doAsynchronousTask, 0, MilliSeconds);
        Log.d(TAG, "==================================================");
    }


    @Override
    public void onConnected(@Nullable Bundle bundle) {
        Log.d(TAG, "On Connected Running");
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            return;
        }
         mCurrentLocation = LocationServices.FusedLocationApi.getLastLocation(LocationAPIclient);
        if (mCurrentLocation!=null){
            Log.d(TAG,"Last Known Location Is not Null ");
            new Location_sendeToServer_AsyncTask(this).execute(String.valueOf(mCurrentLocation.getLatitude()),String.valueOf(mCurrentLocation.getLongitude()),String.valueOf(mCurrentLocation.getAccuracy()));
        }
        else {
            Log.d(TAG,"Last Known Location Is NULL Start Location Updates");
            LocationServices.FusedLocationApi.requestLocationUpdates(LocationAPIclient,mLocationRequest,this);
        }

    }

    @Override
    public void onConnectionSuspended(int i) {

    }

    @Override
    public void onConnectionFailed(@NonNull ConnectionResult connectionResult) {

    }

    @Override
    public void onLocationChanged(Location location) {
        Log.d(TAG,"On Location Changed Calling");
        mCurrentLocation=location;
        new Location_sendeToServer_AsyncTask(this).execute(String.valueOf(mCurrentLocation.getLatitude()),String.valueOf(mCurrentLocation.getLongitude()),String.valueOf(mCurrentLocation.getAccuracy()));
        Log.d(TAG,"Stopping Location Update");
       // LocationServices.FusedLocationApi.removeLocationUpdates(LocationAPIclient,this);
    }

    public void requestLocatonSetting(int Interval,int FastestInterval,int LocationAccuracy){
        mLocationRequest=new LocationRequest();
        mLocationRequest.setInterval(Interval);
        mLocationRequest.setFastestInterval(FastestInterval);
        mLocationRequest.setPriority(LocationAccuracy);

    }

}

संपादित करें

आपके द्वारा उपरोक्त प्रदान किए गए कोड का उपयोग करके यह एक बेहतर उदाहरण है:

अपनी गतिविधि पंजीयन एपीआई दर्ज करते समय इस सेवा का उपयोग करें:

public class LocationUpdateService extends Service implements GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener {

    public static final String TAG = "###RECOGNISED SRVCE###";

    private GoogleApiClient apiClient;
    private PendingIntent pendingIntent;
    private DetectedActivity lastActivity;

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

    @Override
    public void onCreate() {
        apiClient = new GoogleApiClient.Builder(this)
                .addApi(LocationServices.API)
                .addConnectionCallbacks(this)
                .addOnConnectionFailedListener(this)
                .build();

        apiClient.connect();
        pendingIntent = PendingIntent.getService(this, 1, new Intent(this, YourIntentService.class), PendingIntent.FLAG_UPDATE_CURRENT);
    }

    @Override
    public int onStartCommand(Intent intent, int flag, int startId) {
        Log.d(TAG, "onStartCommand");
        if (ActivityRecognitionResult.hasResult(intent)) {
            Log.d(TAG, "ActivityRecognition Has Result");
            ActivityRecognitionResult result = ActivityRecognitionResult.extractResult(intent);
            handleDetectedActivity(result);

            /* You should really use LocalBroadcastManager to send events out to an activity for UI updates */

//            Navigation_Drawer nav = new Navigation_Drawer();
//            nav.UserMovementResult(result);
        }
        return START_STICKY;
    }

    @Override
    public void onConnected(@Nullable Bundle bundle) {
        Log.d(TAG, "On Connected Running");
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            return;
        }
        Location location = LocationServices.FusedLocationApi.getLastLocation(apiClient);
        if (location!=null){
            Log.d(TAG,"Last Known Location Is not Null ");
            Intent intent = new Intent(this, YourIntentService.class).putExtra("lastKnown", location);
            startService(intent);

            /* No more need for this! */
//            new Location_sendeToServer_AsyncTask(this).execute(String.valueOf(mCurrentLocation.getLatitude()),String.valueOf(mCurrentLocation.getLongitude()),String.valueOf(mCurrentLocation.getAccuracy()));
        }
        else {
            Log.d(TAG,"Last Known Location Is NULL Start Location Updates");
            updateLocationSetting(5*60*60*1000,3*60*60*1000,LocationRequest.PRIORITY_HIGH_ACCURACY);
//            LocationServices.FusedLocationApi.requestLocationUpdates(apiClient,mLocationRequest,this);
        }
    }

    @Override
    public void onConnectionSuspended(int i) {

    }

    @Override
    public void onConnectionFailed(@NonNull ConnectionResult connectionResult) {

    }

    private void handleDetectedActivity(ActivityRecognitionResult result) {
        DetectedActivity mostProbableActivity = result.getMostProbableActivity();
        switch (result.getMostProbableActivity().getType()) {
            case DetectedActivity.IN_VEHICLE:
//                    Log.d(TAG, "In Vehicle " + activity.getConfidence());
                if (mostProbableActivity.getConfidence() >= 75 && mostProbableActivity != lastActivity) {
                    //Send Notification To User
//                        NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
//                        builder.setContentText("In Vehicle");
//                        builder.setSmallIcon(R.drawable.elaxer_x);
//                        builder.setContentTitle("Elaxer");
//                        NotificationManagerCompat.from(this).notify(0, builder.build());
                    //requestLocatonSetting(6*60*1000,6*60*1000,LocationRequest.PRIORITY_HIGH_ACCURACY); //TEST
                    if (apiClient.isConnected()) {
                        updateLocationSetting(10 * 60 * 1000, 8 * 60 * 1000, LocationRequest.PRIORITY_HIGH_ACCURACY); //5 hours= hours * 60 min*60 sec* 1000 milliseconds
                        lastActivity = mostProbableActivity;
                    }
                }
                break;
            case DetectedActivity.ON_BICYCLE:
                Log.d(TAG, "On Bicycle " + mostProbableActivity.getConfidence());
                if (mostProbableActivity.getConfidence() >= 75 && mostProbableActivity != lastActivity) {
                    //Send Notification To User
//                    NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
//                    builder.setContentText("On Bicycle");
//                    builder.setSmallIcon(R.drawable.elaxer_x);
//                    builder.setContentTitle("Elaxer");
//                    NotificationManagerCompat.from(this).notify(0, builder.build());
                    if (apiClient.isConnected()) {
                        updateLocationSetting(7 * 60 * 1000, 5 * 60 * 1000, LocationRequest.PRIORITY_HIGH_ACCURACY); //5 hours= hours * 60 min*60 sec* 1000 milliseconds
                        lastActivity = mostProbableActivity;
                    }
                }
                break;

            case DetectedActivity.ON_FOOT:
                Log.d(TAG, "On Foot " + mostProbableActivity.getConfidence());
                if (mostProbableActivity.getConfidence() >= 75) {
                    DetectedActivity nextHighest = result.getProbableActivities().get(1);
                    if (nextHighest.getType() == DetectedActivity.RUNNING && nextHighest != lastActivity) {
                        Log.d(TAG, "On Running " + mostProbableActivity.getConfidence());
                        //Send Notification To User
//                        NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
//                        builder.setContentText("Running");
//                        builder.setSmallIcon(R.drawable.elaxer_x);
//                        builder.setContentTitle("Elaxer");
//                        NotificationManagerCompat.from(this).notify(0, builder.build());
                        if (apiClient.isConnected()) {
                            updateLocationSetting(3 * 60 * 1000, 2 * 60 * 1000, LocationRequest.PRIORITY_HIGH_ACCURACY); //5 hours= hours * 60 min*60 sec* 1000 milliseconds
                            lastActivity = nextHighest;
                        }
                    }
                    else if (nextHighest.getConfidence() >= 75 && nextHighest != lastActivity) {
                        Log.d(TAG, "On Walking " + mostProbableActivity.getConfidence());
                        //Send Notification To User
//                        NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
//                        builder.setContentText("Let's Walk");
//                        builder.setSmallIcon(R.drawable.elaxer_x);
//                        builder.setContentTitle("Elaxer");
//                        NotificationManagerCompat.from(this).notify(0, builder.build());

                        if (apiClient.isConnected()) {
                            updateLocationSetting(3 * 60 * 1000, 2 * 60 * 1000, LocationRequest.PRIORITY_HIGH_ACCURACY); //5 hours= hours * 60 min*60 sec* 1000 milliseconds
                            lastActivity = nextHighest;
                        }
                    }
                    //Send Notification To User
//                    NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
//                    builder.setContentText("On Foot");
//                    builder.setSmallIcon(R.drawable.elaxer_x);
//                    builder.setContentTitle("Elaxer");
//                    NotificationManagerCompat.from(this).notify(0, builder.build());
                }
                break;
            case DetectedActivity.STILL:
                Log.d(TAG, "On Still " + mostProbableActivity.getConfidence());
                if (mostProbableActivity.getConfidence() >= 75 && mostProbableActivity != lastActivity) {
                    //Send Notification To User
//                    NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
//                    builder.setContentText("Still");
//                    builder.setSmallIcon(R.drawable.elaxer_x);
//                    builder.setContentTitle("Elaxer");
//                    NotificationManagerCompat.from(this).notify(0, builder.build());

                    if (apiClient.isConnected()) {
                        updateLocationSetting(5 * 60 * 60 * 1000, 3 * 60 * 60 * 1000, LocationRequest.PRIORITY_HIGH_ACCURACY); //5 hours= hours * 60 min*60 sec* 1000 milliseconds
                        lastActivity = mostProbableActivity;
                    }
                }
                break;
            case DetectedActivity.TILTING:
                Log.d(TAG, "On Tilting " + mostProbableActivity.getConfidence());
                if (mostProbableActivity.getConfidence() >= 75 && mostProbableActivity != lastActivity) {
                    //Send Notification To User
//                    NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
//                    builder.setContentText("Tilting");
//                    builder.setSmallIcon(R.drawable.elaxer_x);
//                    builder.setContentTitle("Elaxer");
//                    NotificationManagerCompat.from(this).notify(0, builder.build());

                    if (apiClient.isConnected()) {
                        updateLocationSetting(3 * 60 * 1000, 2 * 60 * 1000, LocationRequest.PRIORITY_HIGH_ACCURACY); //5 hours= hours * 60 min*60 sec* 1000 milliseconds
                        lastActivity = mostProbableActivity;
                    }
                }
                break;
//            case DetectedActivity.WALKING:
//                Log.d(TAG, "On Walking " + mostProbableActivity.getConfidence());
//                if (mostProbableActivity.getConfidence() >= 75) {
//                    //Send Notification To User
//                    NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
//                    builder.setContentText("Let's Walk");
//                    builder.setSmallIcon(R.drawable.elaxer_x);
//                    builder.setContentTitle("Elaxer");
//                    NotificationManagerCompat.from(this).notify(0, builder.build());
//
//                    if (apiClient.isConnected()) {
//                        updateLocationSetting(3 * 60 * 1000, 2 * 60 * 1000, LocationRequest.PRIORITY_HIGH_ACCURACY); //5 hours= hours * 60 min*60 sec* 1000 milliseconds
//                    }
//                }
//                break;
            case DetectedActivity.UNKNOWN:
                Log.d(TAG, "UnKnown " + mostProbableActivity.getConfidence());
                lastActivity = mostProbableActivity;
                break;
        }
    }

    private void updateLocationSetting(int Interval, int FastestInterval, int LocationAccuracy) {
        LocationRequest request = new LocationRequest();
        request.setInterval(Interval);
        request.setFastestInterval(FastestInterval);
        request.setPriority(LocationAccuracy);
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_DENIED) {
            //TODO DO SOMETHING HERE!
            return;
        }
        LocationServices.FusedLocationApi.requestLocationUpdates(apiClient, request, pendingIntent);
    }
}

और यह आप का उपयोग करने के लिए AsyncTask का उपयोग करने के बजाय उपयोग करने के लिए IntentService होगा:

public class YourIntentService extends IntentService {

    public YourIntentService() {
        super("YOUR_INTENT_SERVICE");
    }

    @Override
    protected void onHandleIntent(@Nullable Intent intent) {
        if (intent != null) {
            if (LocationResult.hasResult(intent)) {
                LocationResult result = LocationResult.extractResult(intent);
                Location location = result.getLastLocation();
                Log.d("YourIntentService", "Got new location: " + location);
            }
            else if (intent.hasExtra("lastKnown")) {
                Location location = intent.getParcelableExtra("lastKnown");
                Log.d("YourIntentService", "Got last known location: " + location);
            }
            else if (LocationAvailability.hasLocationAvailability(intent)) {
                LocationAvailability locationAvailability = LocationAvailability.extractLocationAvailability(intent);
                Log.d("YourIntentService", "Location Availability: " + locationAvailability.isLocationAvailable());
            }
        }
    }
}

यह आशय सेवा अवरुद्ध नेटवर्क अनुरोधों को तब तक संभाल सकता है जब तक कि onHandleIntent कहा जाता है

मैंने handleDetectedActivity कोड को handleDetectedActivity संशोधित किया है ताकि प्रत्येक गतिविधि अद्यतन पर, एक नया स्थान अपडेट नहीं हो।

सबसे पहले, मैंने सुझाव नहीं दिया था कि आप अब जिस तरह से IntentService का इस्तेमाल करते हैं, क्योंकि सेवा एक बार इसे onHandleIntent बाहर निकल जाने पर मार डाला जाएगा, जिसके कारण आप कई कॉलबैक पर निर्भर हैं। इन सभी को इसके बजाय Service में रखा जाना चाहिए।

गतिविधि पहचान के आधार पर स्थान अपडेट को संभालने के लिए, मुझे यह अच्छी लाइब्रेरी मिली, जो इस को सरल करती है और इसका प्रयोग करना बहुत आसान है। https://github.com/mrmans0n/smart-location-lib

गतिविधि परिणामों के आधार पर स्थान अपडेट के साथ लाइब्रेरी का उपयोग कैसे करें इसका उदाहरण यहां दिया गया है।

SmartLocation.with(this).location(new LocationBasedOnActivityProvider(new LocationBasedOnActivityProvider.LocationBasedOnActivityListener() {
    @Override
    public LocationParams locationParamsForActivity(DetectedActivity detectedActivity) {
        if (detectedActivity.getConfidence() >= 75) {
            LocationParams.Builder builder = new LocationParams.Builder();
            switch (detectedActivity.getType()) {
                case DetectedActivity.IN_VEHICLE:
                    builder.setInterval(/*Interval*/)
                            .setAccuracy(/*Locaiton Accuracy*/);
                    break;

                case DetectedActivity.ON_BICYCLE:
                    /* So on and so forth.... */

                    break;
            }
            return builder.build();
        }
        return null;
    }
})).start(new OnLocationUpdatedListener() {
    @Override
    public void onLocationUpdated(Location location) {
        //Do what you need here.
    }
});

इसे onStart फ़ंक्शन में किसी Service में छोड़ दिया जाना चाहिए, इसके साथ ही onStartCommand आपको उपलब्ध कराए गए इरादे के आधार पर परिवर्तनों को संभालना होगा। आप अंतिम ज्ञात स्थान प्राप्त करने के लिए इस लायब्रेरी का भी उपयोग कर सकते हैं, और एक ही सुधार प्राप्त कर सकते हैं।

एक आखिरी बात, मैं सुझाव करता AsyncTask कि आप AsyncTask से दूर हो AsyncTask यदि आप इसके संदर्भ में जा रहे हैं। इसके बजाय IntentService उपयोग करें, क्योंकि onHandleIntent फ़ंक्शन को पृष्ठभूमि थ्रेड में चलाया जाता है, और आप इसके साथ जो कुछ भी कार्य करना चाहते हैं उसके लिए आप IntentService के संदर्भ का उपयोग कर सकते हैं। जब आप अपना IntentService प्रारंभ करते हैं, तो आप Location वस्तु को अतिरिक्त उद्देश्य के रूप में उत्तीर्ण कर सकते हैं।


मैं इसके बाद के संस्करण के रूप में एक ही कोड को कुछ लाइनों को जोड़ने के बाद इस कोड निष्पादित।

  • सबसे पहले मैं IntentService में वर्ग स्तर पर स्थिर इंट की घोषणा करता IntentService क्योंकि DectectedActivity.getType() वापसी int static int detectedActivity;
  • फिर मैं इसकी जांच करता हूं कि आखिर में ऐसा ही राज्य क्या होगा if (activity.getConfidence() >= 75 && activity.getType()!=detectedActivity)

यही है। पब्लो बैक्सटर के लिए धन्यवाद, जिन्होंने मुझे आवेदन करने के लिए कोई तर्क दिया था। मैंने इसे IntentService सेवा पर परीक्षण किया लेकिन मुझे सर्विस पर इसका परीक्षण करना होगा ताकि मैं स्थानों को अपडेट कर IntentService





activity-recognition