несколько аварийных сигналов, вызывающих одно и то же обслуживание

Question

У меня есть несколько сигналов тревоги, вызывающих трансляцию, которая, в свою очередь, вызывает службу определения местоположения. Идея состоит в том, чтобы получить местоположение в отдельные тайминги. Служба определения местоположения занимает некоторое время, чтобы вернуть место, после которого оно завершается. Мне было интересно, что произойдет в случае, когда два будильника называют это обычным сервисом местоположения в одно и то же время или говорят, что сигнал тревоги 1 уже называется службой определения местоположения, и в течение второго аварийного сигнала 2 также называется службой определения местоположения, потому что у меня есть службы чтения только с одним экземпляром.

И что лучше всего подходит для таких случаев, как тот, который я упомянул выше?

Intent intent = new Intent(context, NotificationView.class); 
PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT); 

    alarmManager.set(AlarmManager.RTC_WAKEUP, dateTime.getTimeInMillis(), pendingIntent); 

В моей NotificationView.class я называю Службу

Intent serviceIntent = new Intent(context,MyLocationService.class); 
    context.startService(serviceIntent); //start service for get location 

Там может быть несколько сигналов тревоги по расписанию в пределах разницы некоторых secods призывающих эту же услугу с помощью этого отложенного намерения.

Answer 1

да, вы правильно. Я показываю свой код, где мой код запроса - i. Вы можете изменить его для вас

public static void setAlarmReceiver(Context context, ArrayList<CheckPoint> checkPoints) { 

     clearAlarmReceiver(context); 

     if (checkPoints.size() == 0) 
      return; 

     int i = 0; 
     for (CheckPoint checkPoint : checkPoints) { 
      Intent intent = new Intent(context, CheckAlarmReceiver.class); 
      intent.putExtra("checkPoint", checkPoint); 
      PendingIntent pendingIntent = PendingIntent.getBroadcast(context, i, intent, PendingIntent.FLAG_CANCEL_CURRENT); 
      Calendar calendar = Calendar.getInstance(); 
      calendar.set(Calendar.DAY_OF_MONTH, Integer.valueOf(getDay(checkPoint.getDate()))); 
      calendar.set(Calendar.MONTH, Integer.valueOf(getMonth(checkPoint.getDate())) - 1); 
      calendar.set(Calendar.YEAR, Integer.valueOf(getYear(checkPoint.getDate()))); 
      calendar.set(Calendar.HOUR_OF_DAY, Integer.valueOf(getHour(checkPoint.getCheckInTime()))); 
      calendar.set(Calendar.MINUTE, Integer.valueOf(getMinute(checkPoint.getCheckInTime()))); 
      calendar.set(Calendar.SECOND, 0); 
      AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE); 
      if (android.os.Build.VERSION.SDK_INT >= 19) { 
       alarmManager.setExact(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis(), pendingIntent); 
      } else { 
       alarmManager.set(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis(), pendingIntent); 
      } 

      i++; 
     } 
    } 

Answer 2

На мой взгляд, самое лучшее решение это создать вспомогательный класс, который был бы кэш местоположение и предотвратить дополнительный вызов на обслуживание, например.

public class LocationHelper { 
    public static AbstractMap.SimpleEntry<Long, Location> cache = null; //location stored here 
    public static int expiryTime = 5000; // 5 seconds for example 

    private static boolean requested = false; 

    private static List<LocationListener> callbacks = new ArrayList<>();// request heap 

    public static void getLocation(LocationManager lm, LocationListener ll){ 
    Long currentTimeStamp = getTimeStamp(); 
    final LocationListener mLocationListener = new LocationListener() { 
     @Override 
     public void onLocationChanged(final Location location) { 
     cache = new AbstractMap.SimpleEntry<>(getTimeStamp(), location); 

     synchronized(LocationHelper.class){ 
      for(LocationListener loclist : callbacks){ 
      loclist.onLocationChanged(location); // call each listener 
      } 
      callbacks.clear(); 
      requested = false; 
     } 
     } 
    }; 
    if (cache != null && currentTimeStamp - cache.getKey() < expiryTime){ 
     ll.onLocationChanged(cache.getValue()); 
    } else { 
     if(!requested){ 
     synchronized(LocationHelper.class){ // synchronize class to prevent thread collision and additional request 
      if(!requested){ 
      lm.requestLocationUpdates(LocationManager.GPS_PROVIDER, LOCATION_REFRESH_TIME, LOCATION_REFRESH_DISTANCE, mLocationListener); 
      requested = true; 
      } 
     } 
     } else { 
     synchronized(LocationHelper.class){ 
      callbacks.add(ll); 
     } 
     } 
    } 
    } 

    public static Long getTimeStamp(){/*some code here*/} 
} 

это решение немного сложно, но он должен работать