Repo created

iphone/Maps/Core/Settings/MWMCoreUnits.h

@@ -0,0 +1,19 @@
+#include "platform/measurement_utils.hpp"
+
+static inline measurement_utils::Units coreUnits(MWMUnits units)
+{
+  switch (units)
+  {
+  case MWMUnitsMetric: return measurement_utils::Units::Metric;
+  case MWMUnitsImperial: return measurement_utils::Units::Imperial;
+  }
+}
+
+static inline MWMUnits mwmUnits(measurement_utils::Units units)
+{
+  switch (units)
+  {
+  case measurement_utils::Units::Metric: return MWMUnitsMetric;
+  case measurement_utils::Units::Imperial: return MWMUnitsImperial;
+  }
+}

iphone/Maps/Core/Settings/MWMRoutingOptions.h

@@ -0,0 +1,20 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+NS_SWIFT_NAME(RoutingOptions)
+@interface MWMRoutingOptions : NSObject
+
+@property(nonatomic) BOOL avoidToll;
+@property(nonatomic) BOOL avoidDirty;
+@property(nonatomic) BOOL avoidPaved;
+@property(nonatomic) BOOL avoidFerry;
+@property(nonatomic) BOOL avoidMotorway;
+@property(nonatomic) BOOL avoidSteps;
+@property(nonatomic, readonly) BOOL hasOptions;
+
+- (void)save;
+
+@end
+
+NS_ASSUME_NONNULL_END

iphone/Maps/Core/Settings/MWMRoutingOptions.mm

@@ -0,0 +1,94 @@
+#import "MWMRoutingOptions.h"
+
+#include "routing/routing_options.hpp"
+
+@interface MWMRoutingOptions() {
+  routing::RoutingOptions _options;
+}
+
+@end
+
+@implementation MWMRoutingOptions
+
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    _options = routing::RoutingOptions::LoadCarOptionsFromSettings();
+  }
+
+  return self;
+}
+
+- (BOOL)avoidToll {
+  return _options.Has(routing::RoutingOptions::Road::Toll);
+}
+
+- (void)setAvoidToll:(BOOL)avoid {
+  [self setOption:(routing::RoutingOptions::Road::Toll) enabled:avoid];
+}
+
+- (BOOL)avoidDirty {
+  return _options.Has(routing::RoutingOptions::Road::Dirty);
+}
+
+- (void)setAvoidDirty:(BOOL)avoid {
+  [self setOption:(routing::RoutingOptions::Road::Dirty) enabled:avoid];
+}
+
+- (BOOL)avoidPaved {
+  return _options.Has(routing::RoutingOptions::Road::Paved);
+}
+
+- (void)setAvoidPaved:(BOOL)avoid {
+  [self setOption:(routing::RoutingOptions::Road::Paved) enabled:avoid];
+}
+
+- (BOOL)avoidFerry {
+  return _options.Has(routing::RoutingOptions::Road::Ferry);
+}
+
+- (void)setAvoidFerry:(BOOL)avoid {
+  [self setOption:(routing::RoutingOptions::Road::Ferry) enabled:avoid];
+}
+
+- (BOOL)avoidMotorway {
+  return _options.Has(routing::RoutingOptions::Road::Motorway);
+}
+
+- (void)setAvoidMotorway:(BOOL)avoid {
+  [self setOption:(routing::RoutingOptions::Road::Motorway) enabled:avoid];
+}
+
+- (BOOL)avoidSteps {
+  return _options.Has(routing::RoutingOptions::Road::Steps);
+}
+
+- (void)setAvoidSteps:(BOOL)avoid {
+  [self setOption:(routing::RoutingOptions::Road::Steps) enabled:avoid];
+}
+
+- (BOOL)hasOptions {
+  return self.avoidToll || self.avoidDirty || self.avoidPaved|| self.avoidFerry || self.avoidMotorway || self.avoidSteps;
+}
+
+- (void)save {
+  routing::RoutingOptions::SaveCarOptionsToSettings(_options);
+}
+
+- (void)setOption:(routing::RoutingOptions::Road)option enabled:(BOOL)enabled {
+  if (enabled) {
+    _options.Add(option);
+  } else {
+    _options.Remove(option);
+  }
+}
+
+- (BOOL)isEqual:(id)object {
+  if (![object isMemberOfClass:self.class]) {
+    return NO;
+  }
+  MWMRoutingOptions *another = (MWMRoutingOptions *)object;
+  return another.avoidToll == self.avoidToll && another.avoidDirty == self.avoidDirty && another.avoidPaved == self.avoidPaved && another.avoidFerry == self.avoidFerry && another.avoidMotorway == self.avoidMotorway && another.avoidSteps == self.avoidSteps;
+}
+
+@end

iphone/Maps/Core/Settings/MWMSettings.h

@@ -0,0 +1,60 @@
+NS_SWIFT_NAME(SettingsBridge)
+@interface MWMSettings : NSObject
+
++ (BOOL)buildings3dViewEnabled;
++ (void)setBuildings3dViewEnabled:(BOOL)buildings3dViewEnabled;
+
++ (BOOL)perspectiveViewEnabled;
++ (void)setPerspectiveViewEnabled:(BOOL)perspectiveViewEnabled;
+
++ (BOOL)autoZoomEnabled;
++ (void)setAutoZoomEnabled:(BOOL)autoZoomEnabled;
+
++ (BOOL)autoDownloadEnabled;
++ (void)setAutoDownloadEnabled:(BOOL)autoDownloadEnabled;
+
++ (MWMUnits)measurementUnits;
++ (void)setMeasurementUnits:(MWMUnits)measurementUnits;
+
++ (BOOL)zoomButtonsEnabled;
++ (void)setZoomButtonsEnabled:(BOOL)zoomButtonsEnabled;
+
++ (BOOL)compassCalibrationEnabled;
++ (void)setCompassCalibrationEnabled:(BOOL)compassCalibrationEnabled;
+
++ (MWMTheme)theme;
++ (void)setTheme:(MWMTheme)theme;
+
++ (NSInteger)powerManagement;
++ (void)setPowerManagement:(NSInteger)powerManagement;
+
++ (BOOL)routingDisclaimerApproved;
++ (void)setRoutingDisclaimerApproved;
+
++ (NSString *)spotlightLocaleLanguageId;
++ (void)setSpotlightLocaleLanguageId:(NSString *)spotlightLocaleLanguageId;
+
++ (BOOL)largeFontSize;
++ (void)setLargeFontSize:(BOOL)largeFontSize;
+
++ (NSDictionary<NSString *, NSString *> *)availableMapLanguages;
++ (NSString *)mapLanguageCode;
++ (void)setMapLanguageCode:(NSString *)mapLanguageCode;
+
++ (BOOL)transliteration;
++ (void)setTransliteration:(BOOL)transliteration;
+
++ (BOOL)isTrackWarningAlertShown;
++ (void)setTrackWarningAlertShown:(BOOL)shown;
+
++ (NSString *)donateUrl;
+
++ (BOOL)iCLoudSynchronizationEnabled;
++ (void)setICLoudSynchronizationEnabled:(BOOL)iCLoudSyncEnabled;
+
++ (void)initializeLogging;
++ (BOOL)isFileLoggingEnabled;
++ (void)setFileLoggingEnabled:(BOOL)fileLoggingEnabled;
++ (NSInteger)logFileSize;
+
+@end

iphone/Maps/Core/Settings/MWMSettings.mm

@@ -0,0 +1,296 @@
+#import "MWMSettings.h"
+#import "MWMCoreUnits.h"
+#import "MWMMapViewControlsManager.h"
+#import "SwiftBridge.h"
+
+#include <CoreApi/Framework.h>
+#include <CoreApi/Logger.h>
+
+using namespace power_management;
+
+namespace
+{
+char const * kAutoDownloadEnabledKey = "AutoDownloadEnabled";
+char const * kZoomButtonsEnabledKey = "ZoomButtonsEnabled";
+char const * kCompassCalibrationEnabledKey = "CompassCalibrationEnabled";
+char const * kMapLanguageCode = "MapLanguageCode";
+char const * kRoutingDisclaimerApprovedKey = "IsDisclaimerApproved";
+
+// TODO(igrechuhin): Remove outdated kUDAutoNightModeOff
+NSString * const kUDAutoNightModeOff = @"AutoNightModeOff";
+NSString * const kThemeMode = @"ThemeMode";
+NSString * const kSpotlightLocaleLanguageId = @"SpotlightLocaleLanguageId";
+NSString * const kUDTrackWarningAlertWasShown = @"TrackWarningAlertWasShown";
+NSString * const kiCLoudSynchronizationEnabledKey = @"iCLoudSynchronizationEnabled";
+NSString * const kUDFileLoggingEnabledKey = @"FileLoggingEnabledKey";
+}  // namespace
+
+@implementation MWMSettings
+
++ (BOOL)buildings3dViewEnabled;
+{
+  bool _ = true, on = true;
+  GetFramework().Load3dMode(_, on);
+  if (GetFramework().GetPowerManager().GetScheme() == power_management::Scheme::EconomyMaximum) {
+    return false;
+  } else {
+    return on;
+  }
+}
+
++ (void)setBuildings3dViewEnabled:(BOOL)buildings3dViewEnabled;
+{
+  auto &f = GetFramework();
+  bool _ = true, is3dBuildings = true;
+  f.Load3dMode(_, is3dBuildings);
+  is3dBuildings = static_cast<bool>(buildings3dViewEnabled);
+  f.Save3dMode(_, is3dBuildings);
+  f.Allow3dMode(_, is3dBuildings);
+}
+
++ (BOOL)perspectiveViewEnabled;
+{
+  bool _ = true, on = true;
+  auto &f = GetFramework();
+  f.Load3dMode(on, _);
+  return on;
+}
+
++ (void)setPerspectiveViewEnabled:(BOOL)perspectiveViewEnabled;
+{
+  auto &f = GetFramework();
+  bool is3d = true, _ = true;
+  f.Load3dMode(is3d, _);
+  is3d = static_cast<bool>(perspectiveViewEnabled);
+  f.Save3dMode(is3d, _);
+  f.Allow3dMode(is3d, _);
+}
+
++ (BOOL)autoZoomEnabled
+{
+  return GetFramework().LoadAutoZoom();
+}
+
++ (void)setAutoZoomEnabled:(BOOL)autoZoomEnabled
+{
+  auto &f = GetFramework();
+  f.AllowAutoZoom(autoZoomEnabled);
+  f.SaveAutoZoom(autoZoomEnabled);
+}
+
++ (BOOL)autoDownloadEnabled
+{
+  bool autoDownloadEnabled = true;
+  UNUSED_VALUE(settings::Get(kAutoDownloadEnabledKey, autoDownloadEnabled));
+  return autoDownloadEnabled;
+}
+
++ (void)setAutoDownloadEnabled:(BOOL)autoDownloadEnabled
+{
+  settings::Set(kAutoDownloadEnabledKey, static_cast<bool>(autoDownloadEnabled));
+}
+
++ (MWMUnits)measurementUnits
+{
+  auto units = measurement_utils::Units::Metric;
+  UNUSED_VALUE(settings::Get(settings::kMeasurementUnits, units));
+  return mwmUnits(units);
+}
+
++ (void)setMeasurementUnits:(MWMUnits)measurementUnits
+{
+  settings::Set(settings::kMeasurementUnits, coreUnits(measurementUnits));
+  GetFramework().SetupMeasurementSystem();
+}
+
++ (BOOL)zoomButtonsEnabled
+{
+  bool enabled = true;
+  UNUSED_VALUE(settings::Get(kZoomButtonsEnabledKey, enabled));
+  return enabled;
+}
+
++ (void)setZoomButtonsEnabled:(BOOL)zoomButtonsEnabled
+{
+  settings::Set(kZoomButtonsEnabledKey, static_cast<bool>(zoomButtonsEnabled));
+  [MWMMapViewControlsManager manager].zoomHidden = !zoomButtonsEnabled;
+}
+
++ (BOOL)compassCalibrationEnabled
+{
+  bool enabled = true;
+  UNUSED_VALUE(settings::Get(kCompassCalibrationEnabledKey, enabled));
+  return enabled;
+}
+
++ (void)setCompassCalibrationEnabled:(BOOL)compassCalibrationEnabled
+{
+  settings::Set(kCompassCalibrationEnabledKey, static_cast<bool>(compassCalibrationEnabled));
+}
+
++ (MWMTheme)theme
+{
+  if ([MWMCarPlayService shared].isCarplayActivated) {
+    UIUserInterfaceStyle style = [[MWMCarPlayService shared] interfaceStyle];
+    switch (style) {
+      case UIUserInterfaceStyleLight: return MWMThemeDay;
+      case UIUserInterfaceStyleDark: return MWMThemeNight;
+      case UIUserInterfaceStyleUnspecified: break;
+    }
+  }
+  auto ud = NSUserDefaults.standardUserDefaults;
+  if (![ud boolForKey:kUDAutoNightModeOff])
+    return MWMThemeAuto;
+  return static_cast<MWMTheme>([ud integerForKey:kThemeMode]);
+}
+
++ (void)setTheme:(MWMTheme)theme
+{
+  if ([self theme] == theme)
+    return;
+  auto ud = NSUserDefaults.standardUserDefaults;
+  [ud setInteger:theme forKey:kThemeMode];
+  BOOL const autoOff = theme != MWMThemeAuto;
+  [ud setBool:autoOff forKey:kUDAutoNightModeOff];
+  [MWMThemeManager invalidate];
+}
+
++ (NSInteger)powerManagement
+{
+  Scheme scheme = GetFramework().GetPowerManager().GetScheme();
+  if (scheme == Scheme::EconomyMaximum) {
+    return 2;
+  } else if (scheme == Scheme::Auto) {
+    return 1;
+  }
+
+  return 0;
+}
+
++ (void)setPowerManagement:(NSInteger)powerManagement
+{
+  Scheme scheme = Scheme::Normal;
+  if (powerManagement == 2) {
+    scheme = Scheme::EconomyMaximum;
+  } else if (powerManagement == 1) {
+    scheme = Scheme::Auto;
+  }
+  GetFramework().GetPowerManager().SetScheme(scheme);
+}
+
++ (BOOL)routingDisclaimerApproved
+{
+  bool enabled = false;
+  UNUSED_VALUE(settings::Get(kRoutingDisclaimerApprovedKey, enabled));
+  return enabled;
+}
+
++ (void)setRoutingDisclaimerApproved { settings::Set(kRoutingDisclaimerApprovedKey, true); }
++ (NSString *)spotlightLocaleLanguageId
+{
+  return [NSUserDefaults.standardUserDefaults stringForKey:kSpotlightLocaleLanguageId];
+}
+
++ (void)setSpotlightLocaleLanguageId:(NSString *)spotlightLocaleLanguageId
+{
+  NSUserDefaults * ud = NSUserDefaults.standardUserDefaults;
+  [ud setObject:spotlightLocaleLanguageId forKey:kSpotlightLocaleLanguageId];
+}
+
++ (BOOL)largeFontSize { return GetFramework().LoadLargeFontsSize(); }
++ (void)setLargeFontSize:(BOOL)largeFontSize
+{
+  GetFramework().SetLargeFontsSize(static_cast<bool>(largeFontSize));
+}
+
++ (NSDictionary<NSString *, NSString *> *)availableMapLanguages;
+{
+  NSMutableDictionary<NSString *, NSString *> *availableLanguages = [[NSMutableDictionary alloc] init];
+  auto const & v = StringUtf8Multilang::GetSupportedLanguages(false);
+  for (auto i: v) {
+    [availableLanguages setObject:@(std::string(i.m_name).c_str()) forKey:@(std::string(i.m_code).c_str())];
+  }
+  return availableLanguages;
+}
+
++ (NSString *)mapLanguageCode;
+{
+  std::string mapLanguageCode;
+  bool hasMapLanguageCode = settings::Get(kMapLanguageCode, mapLanguageCode);
+  if (hasMapLanguageCode) {
+    return @(mapLanguageCode.c_str());
+  }
+
+  return @"auto";
+}
+
++ (void)setMapLanguageCode:(NSString *)mapLanguageCode;
+{
+  auto &f = GetFramework();
+  if ([mapLanguageCode isEqual: @"auto"]) {
+    f.ResetMapLanguageCode();
+  } else {
+    f.SetMapLanguageCode(std::string([mapLanguageCode UTF8String]));
+  }
+}
+
++ (BOOL)transliteration { return GetFramework().LoadTransliteration(); }
++ (void)setTransliteration:(BOOL)transliteration
+{
+  bool const isTransliteration = static_cast<bool>(transliteration);
+  auto & f = GetFramework();
+  f.SaveTransliteration(isTransliteration);
+  f.AllowTransliteration(isTransliteration);
+}
+
++ (BOOL)isTrackWarningAlertShown
+{
+  return [NSUserDefaults.standardUserDefaults boolForKey:kUDTrackWarningAlertWasShown];
+}
+
++ (void)setTrackWarningAlertShown:(BOOL)shown
+{
+  NSUserDefaults * ud = NSUserDefaults.standardUserDefaults;
+  [ud setBool:shown forKey:kUDTrackWarningAlertWasShown];
+}
+
++ (NSString *)donateUrl
+{
+  std::string url;
+  return settings::Get(settings::kDonateUrl, url) ? @(url.c_str()) : nil;
+}
+
++ (BOOL)iCLoudSynchronizationEnabled
+{
+  return [NSUserDefaults.standardUserDefaults boolForKey:kiCLoudSynchronizationEnabledKey];
+}
+
++ (void)setICLoudSynchronizationEnabled:(BOOL)iCLoudSyncEnabled
+{
+  [NSUserDefaults.standardUserDefaults setBool:iCLoudSyncEnabled forKey:kiCLoudSynchronizationEnabledKey];
+  [NSNotificationCenter.defaultCenter postNotificationName:NSNotification.iCloudSynchronizationDidChangeEnabledState object:nil];
+}
+
++ (void)initializeLogging {
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    [self setFileLoggingEnabled:[self isFileLoggingEnabled]];
+  });
+}
+
++ (BOOL)isFileLoggingEnabled {
+  return [NSUserDefaults.standardUserDefaults boolForKey:kUDFileLoggingEnabledKey];
+}
+
++ (void)setFileLoggingEnabled:(BOOL)fileLoggingEnabled {
+  [NSUserDefaults.standardUserDefaults setBool:fileLoggingEnabled forKey:kUDFileLoggingEnabledKey];
+  [Logger setFileLoggingEnabled:fileLoggingEnabled];
+}
+
++ (NSInteger)logFileSize
+{
+  uint64_t logFileSize = [Logger getLogFileSize];
+  return logFileSize;
+}
+
+@end