@Override
 public boolean onPreferenceChange(Preference preference, Object newValue) {
   String id = preference.getKey();
   super.onPreferenceChange(preference, newValue);
   if (id.equals(settings.ROUTER_SERVICE.getId())) {
     routerServicePreference.setSummary(
         getString(R.string.router_service_descr) + "  [" + settings.ROUTER_SERVICE.get() + "]");
     prepareRoutingPrefs(getPreferenceScreen());
     super.updateAllSettings();
   } else if (id.equals(settings.WAKE_ON_VOICE_INT.getId())) {
     Integer value;
     try {
       value = Integer.parseInt(newValue.toString());
     } catch (NumberFormatException e) {
       value = 0;
     }
     if (value > 0) {
       requestLockScreenAdmin();
     }
   }
   return true;
 }
Exemple #2
0
 private void recalculateRouteInBackground(
     boolean force,
     final Location start,
     final LatLon end,
     final List<LatLon> intermediates,
     final GPXRouteParamsBuilder gpxRoute,
     final RouteCalculationResult previousRoute) {
   if (start == null || end == null) {
     return;
   }
   if (currentRunningJob == null) {
     // do not evaluate very often
     if (force || System.currentTimeMillis() - lastTimeEvaluatedRoute > evalWaitInterval) {
       RouteCalculationParams params = new RouteCalculationParams();
       params.start = start;
       params.end = end;
       params.intermediates = intermediates;
       params.gpxRoute = gpxRoute == null ? null : gpxRoute.build(start, settings);
       params.previousToRecalculate = previousRoute;
       params.leftSide = settings.DRIVING_REGION.get().leftHandDriving;
       params.fast = settings.FAST_ROUTE_MODE.getModeValue(mode);
       params.type = settings.ROUTER_SERVICE.getModeValue(mode);
       params.mode = mode;
       params.ctx = app;
       if (previousRoute == null && params.type == RouteService.OSMAND) {
         params.calculationProgress = new RouteCalculationProgress();
         updateProgress(params.calculationProgress);
       }
       synchronized (this) {
         currentRunningJob =
             new RouteRecalculationThread("Calculating route", params); // $NON-NLS-1$
         currentRunningJob.start();
       }
     }
   }
 }
  private void createUI() {
    addPreferencesFromResource(R.xml.navigation_settings);
    PreferenceScreen screen = getPreferenceScreen();
    settings = getMyApplication().getSettings();
    routerServicePreference =
        (ListPreference) screen.findPreference(settings.ROUTER_SERVICE.getId());

    RouteService[] vls = RouteService.getAvailableRouters(getMyApplication());
    String[] entries = new String[vls.length];
    for (int i = 0; i < entries.length; i++) {
      entries[i] = vls[i].getName();
    }
    registerListPreference(settings.ROUTER_SERVICE, screen, entries, vls);

    registerBooleanPreference(settings.SNAP_TO_ROAD, screen);

    Integer[] intValues = new Integer[] {0, 5, 10, 15, 20, 25, 30, 45, 60, 90};
    entries = new String[intValues.length];
    entries[0] = getString(R.string.shared_string_never);
    for (int i = 1; i < intValues.length; i++) {
      entries[i] = (int) intValues[i] + " " + getString(R.string.int_seconds);
    }
    registerListPreference(settings.AUTO_FOLLOW_ROUTE, screen, entries, intValues);

    entries = new String[AutoZoomMap.values().length];
    for (int i = 0; i < entries.length; i++) {
      entries[i] = getString(AutoZoomMap.values()[i].name);
    }
    registerListPreference(settings.AUTO_ZOOM_MAP, screen, entries, AutoZoomMap.values());

    // keep informing option:
    Integer[] keepInformingValues = new Integer[] {0, 1, 2, 3, 5, 7, 10, 15, 20, 25, 30};
    String[] keepInformingNames = new String[keepInformingValues.length];
    keepInformingNames[0] = getString(R.string.keep_informing_never);
    for (int i = 1; i < keepInformingValues.length; i++) {
      keepInformingNames[i] = keepInformingValues[i] + " " + getString(R.string.int_min);
    }
    registerListPreference(
        settings.KEEP_INFORMING, screen, keepInformingNames, keepInformingValues);

    SpeedConstants[] speedValues = SpeedConstants.values();
    String[] speedNamesVls = new String[speedValues.length];
    for (int i = 0; i < speedValues.length; i++) {
      speedNamesVls[i] = speedValues[i].toHumanString(this);
    }
    ;
    registerListPreference(settings.SPEED_SYSTEM, screen, speedNamesVls, speedValues);

    // screen power save option:
    Integer[] screenPowerSaveValues = new Integer[] {0, 5, 10, 15, 20, 30, 45, 60};
    String[] screenPowerSaveNames = new String[screenPowerSaveValues.length];
    screenPowerSaveNames[0] = getString(R.string.shared_string_never);
    for (int i = 1; i < screenPowerSaveValues.length; i++) {
      screenPowerSaveNames[i] = screenPowerSaveValues[i] + " " + getString(R.string.int_seconds);
    }
    registerListPreference(
        settings.WAKE_ON_VOICE_INT, screen, screenPowerSaveNames, screenPowerSaveValues);

    //         registerBooleanPreference(settings.SHOW_ZOOM_BUTTONS_NAVIGATION, screen);

    autoZoomMapPreference = (ListPreference) screen.findPreference(settings.AUTO_ZOOM_MAP.getId());
    autoZoomMapPreference.setOnPreferenceChangeListener(this);

    showAlarms = (Preference) screen.findPreference("show_routing_alarms");
    showAlarms.setOnPreferenceClickListener(this);

    speakAlarms = (Preference) screen.findPreference("speak_routing_alarms");
    speakAlarms.setOnPreferenceClickListener(this);

    Float[] arrivalValues = new Float[] {1.5f, 1f, 0.5f, 0.25f};
    String[] arrivalNames =
        new String[] {
          getString(R.string.arrival_distance_factor_early),
          getString(R.string.arrival_distance_factor_normally),
          getString(R.string.arrival_distance_factor_late),
          getString(R.string.arrival_distance_factor_at_last)
        };
    registerListPreference(settings.ARRIVAL_DISTANCE_FACTOR, screen, arrivalNames, arrivalValues);

    // array size should be equal!
    Float[] speedLimitsKm = new Float[] {0f, 5f, 7f, 10f, 15f, 20f};
    Float[] speedLimitsMiles = new Float[] {0f, 3f, 5f, 7f, 10f, 15f};
    if (settings.METRIC_SYSTEM.get() == OsmandSettings.MetricsConstants.KILOMETERS_AND_METERS) {
      String[] speedNames = new String[speedLimitsKm.length];
      for (int i = 0; i < speedLimitsKm.length; i++) {
        speedNames[i] = speedLimitsKm[i] + " " + getString(R.string.km_h);
      }
      registerListPreference(settings.SPEED_LIMIT_EXCEED, screen, speedNames, speedLimitsKm);
    } else {
      String[] speedNames = new String[speedLimitsKm.length];
      for (int i = 0; i < speedNames.length; i++) {
        speedNames[i] = speedLimitsMiles[i] + " " + getString(R.string.mile_per_hour);
      }
      registerListPreference(settings.SPEED_LIMIT_EXCEED, screen, speedNames, speedLimitsKm);
    }

    PreferenceCategory category =
        (PreferenceCategory) screen.findPreference("guidance_preferences");
    speedLimitExceed = (ListPreference) category.findPreference("speed_limit_exceed");
    ApplicationMode mode = getMyApplication().getSettings().getApplicationMode();
    if (!mode.isDerivedRoutingFrom(ApplicationMode.CAR)) {
      category.removePreference(speedLimitExceed);
    }

    // deprecated 2.2
    //		Integer[] delayIntervals = new Integer[] { -1, 3, 5, 7, 10, 15, 20 };
    //		String[] delayIntervalNames = new String[delayIntervals.length];
    //		for (int i = 0; i < delayIntervals.length; i++) {
    //			if (i == 0) {
    //				delayIntervalNames[i] = getString(R.string.auto_follow_route_never);
    //			} else {
    //				delayIntervalNames[i] = delayIntervals[i] + " " + getString(R.string.int_seconds);
    //			}
    //		}
    // registerListPreference(settings.DELAY_TO_START_NAVIGATION, screen, delayIntervalNames,
    // delayIntervals);

    if (getIntent() != null && getIntent().hasExtra(INTENT_SKIP_DIALOG)) {
      setSelectedAppMode(settings.getApplicationMode());
    } else {
      profileDialog();
    }
  }
 public void updateAllSettings() {
   prepareRoutingPrefs(getPreferenceScreen());
   super.updateAllSettings();
   routerServicePreference.setSummary(
       getString(R.string.router_service_descr) + "  [" + settings.ROUTER_SERVICE.get() + "]");
 }
 private void prepareRoutingPrefs(PreferenceScreen screen) {
   PreferenceCategory cat = (PreferenceCategory) screen.findPreference("routing_preferences");
   cat.removeAll();
   CheckBoxPreference fastRoute =
       createCheckBoxPreference(
           settings.FAST_ROUTE_MODE, R.string.fast_route_mode, R.string.fast_route_mode_descr);
   if (settings.ROUTER_SERVICE.get() != RouteService.OSMAND) {
     cat.addPreference(fastRoute);
   } else {
     ApplicationMode am = settings.getApplicationMode();
     GeneralRouter router = getRouter(getMyApplication().getDefaultRoutingConfig(), am);
     clearParameters();
     if (router != null) {
       Map<String, RoutingParameter> parameters = router.getParameters();
       if (parameters.containsKey("short_way")) {
         cat.addPreference(fastRoute);
       }
       List<RoutingParameter> others = new ArrayList<GeneralRouter.RoutingParameter>();
       for (Map.Entry<String, RoutingParameter> e : parameters.entrySet()) {
         String param = e.getKey();
         if (param.startsWith("avoid_")) {
           avoidParameters.add(e.getValue());
         } else if (param.startsWith("prefer_")) {
           preferParameters.add(e.getValue());
         } else if (!param.equals("short_way")) {
           others.add(e.getValue());
         }
       }
       if (avoidParameters.size() > 0) {
         avoidRouting = new Preference(this);
         avoidRouting.setTitle(R.string.avoid_in_routing_title);
         avoidRouting.setSummary(R.string.avoid_in_routing_descr);
         avoidRouting.setOnPreferenceClickListener(this);
         cat.addPreference(avoidRouting);
       }
       if (preferParameters.size() > 0) {
         preferRouting = new Preference(this);
         preferRouting.setTitle(R.string.prefer_in_routing_title);
         preferRouting.setSummary(R.string.prefer_in_routing_descr);
         preferRouting.setOnPreferenceClickListener(this);
         cat.addPreference(preferRouting);
       }
       for (RoutingParameter p : others) {
         Preference basePref;
         if (p.getType() == RoutingParameterType.BOOLEAN) {
           basePref =
               createCheckBoxPreference(settings.getCustomRoutingBooleanProperty(p.getId()));
         } else {
           Object[] vls = p.getPossibleValues();
           String[] svlss = new String[vls.length];
           int i = 0;
           for (Object o : vls) {
             svlss[i++] = o.toString();
           }
           basePref =
               createListPreference(
                   settings.getCustomRoutingProperty(
                       p.getId(), p.getType() == RoutingParameterType.NUMERIC ? "0.0" : "-"),
                   p.getPossibleValueDescriptions(),
                   svlss,
                   SettingsBaseActivity.getRoutingStringPropertyName(this, p.getId(), p.getName()),
                   SettingsBaseActivity.getRoutingStringPropertyDescription(
                       this, p.getId(), p.getDescription()));
         }
         basePref.setTitle(
             SettingsBaseActivity.getRoutingStringPropertyName(this, p.getId(), p.getName()));
         basePref.setSummary(
             SettingsBaseActivity.getRoutingStringPropertyDescription(
                 this, p.getId(), p.getDescription()));
         cat.addPreference(basePref);
       }
     }
     ApplicationMode mode = getMyApplication().getSettings().getApplicationMode();
     if (mode.isDerivedRoutingFrom(ApplicationMode.CAR)) {
       PreferenceCategory category =
           (PreferenceCategory) screen.findPreference("guidance_preferences");
       category.addPreference(speedLimitExceed);
     } else {
       PreferenceCategory category =
           (PreferenceCategory) screen.findPreference("guidance_preferences");
       category.removePreference(speedLimitExceed);
     }
   }
 }