[ios] Add glyphs rasterization options (#517)

* add glyphs rasterization options

* fix issues

* fix issue

* fix issue

* Address some feedback

* Switch to closed enum, remove default

* Update tests

Co-authored-by: jmkiley <jordan.kiley@mapbox.com>

Author: Lloyd Sheng

platform/darwin/src/MGLMapSnapshotter.mm

@@ -14,7 +14,7 @@
 #import "MGLStyle_Private.h"
 #import "MGLAttributionInfo_Private.h"
 #import "MGLLoggingConfiguration_Private.h"
-#import "MGLRendererConfiguration.h"
+#import "MGLRendererConfiguration_Private.h"
 #import "MGLMapSnapshotter_Private.h"
 
 #if TARGET_OS_IPHONE || TARGET_OS_SIMULATOR
@@ -725,10 +725,9 @@ - (void)configureWithOptions:(MGLMapSnapshotOptions *)options {
                    .withAssetPath(NSBundle.mainBundle.resourceURL.path.UTF8String);
 
     // Create the snapshotter
-    mbgl::optional<std::string> localFontFamilyName = config.localFontFamilyName ? mbgl::optional<std::string>(std::string(config.localFontFamilyName.UTF8String)) : mbgl::nullopt;
     _delegateHost = std::make_unique<MGLMapSnapshotterDelegateHost>(self);
     _mbglMapSnapshotter = std::make_unique<mbgl::MapSnapshotter>(
-                                                                 size, pixelRatio, resourceOptions, *_delegateHost, localFontFamilyName);
+                                                                 size, pixelRatio, resourceOptions, *_delegateHost, config.glyphsRasterizationOptions);
 
     _mbglMapSnapshotter->setStyleURL(std::string(options.styleURL.absoluteString.UTF8String));
 

platform/darwin/src/MGLRendererConfiguration.h

@@ -3,6 +3,18 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
+/// Indicates how the map view load glyphs.
+typedef NS_CLOSED_ENUM(NSUInteger, MGLGlyphsRasterizationMode) {
+    /// The MGLGlyphsRasterizationMode was unset.
+    MGLGlyphsRasterizationModeNone,
+    /// Ideographs are rasterized locally, and they are not loaded from the server.
+    MGLGlyphsRasterizationModeIdeographsRasterizedLocally,
+    /// No glyphs are rasterized locally. All glyphs are loaded from the server.
+    MGLGlyphsRasterizationModeNoGlyphsRasterizedLocally,
+    /// All glyphs are rasterized locally. No glyphs are loaded from the server.
+    MGLGlyphsRasterizationModeAllGlyphsRasterizedLocally
+};
+
 /**
  The MGLRendererConfiguration object represents configuration values for the
  renderer.
@@ -51,6 +63,15 @@ MGL_EXPORT
 
 - (BOOL)perSourceCollisionsWithInfoDictionaryObject:(nullable id)infoDictionaryObject;
 
+/**
+ Indicates how the map view load glyphs.
+
+ Set `MGLGlyphsRasterizationOptions` in your containing app's Info.plist.
+ */
+@property (nonatomic, readonly) MGLGlyphsRasterizationMode glyphsRasterizationMode;
+
+- (MGLGlyphsRasterizationMode)glyphsRasterizationModeWithInfoDictionaryObject:(nullable id)infoDictionaryObject;
+
 @end
 
 NS_ASSUME_NONNULL_END

platform/darwin/src/MGLRendererConfiguration.m

@@ -0,0 +1,120 @@
+#import "MGLRendererConfiguration_Private.h"
+#import "MGLLoggingConfiguration_Private.h"
+
+#if TARGET_OS_IPHONE
+#import <UIKit/UIKit.h>
+#else
+#import <AppKit/AppKit.h>
+#endif
+
+static NSString * const MGLCollisionBehaviorPre4_0Key = @"MGLCollisionBehaviorPre4_0";
+static NSString * const MGLIdeographicFontFamilyNameKey = @"MGLIdeographicFontFamilyName";
+static NSString * const MGLGlyphsRasterizationModeKey = @"MGLGlyphsRasterizationMode";
+
+@implementation MGLRendererConfiguration
+
++ (instancetype)currentConfiguration {
+    return [[self alloc] init];
+}
+
+- (const float)scaleFactor {
+#if TARGET_OS_IPHONE
+    return [UIScreen instancesRespondToSelector:@selector(nativeScale)] ? [[UIScreen mainScreen] nativeScale] : [[UIScreen mainScreen] scale];
+#else
+    return [NSScreen mainScreen].backingScaleFactor;
+#endif
+}
+
+- (nullable NSString *)localFontFamilyName {
+    id infoDictionaryObject = [NSBundle.mainBundle objectForInfoDictionaryKey:MGLIdeographicFontFamilyNameKey];
+    return [self localFontFamilyNameWithInfoDictionaryObject:infoDictionaryObject];
+}
+
+- (nullable NSString *)localFontFamilyNameWithInfoDictionaryObject:(nullable id)infoDictionaryObject {
+    if ([infoDictionaryObject isKindOfClass:[NSNumber class]] && ![infoDictionaryObject boolValue]) {
+        // NO means don’t use local fonts.
+        return nil;
+    } else if ([infoDictionaryObject isKindOfClass:[NSString class]]) {
+        return infoDictionaryObject;
+    } else if ([infoDictionaryObject isKindOfClass:[NSArray class]]) {
+        // mbgl::LocalGlyphRasterizer::Impl accepts only a single string, but form a cascade list with one font on each line.
+        return [infoDictionaryObject componentsJoinedByString:@"\n"];
+    }
+    
+#if TARGET_OS_IPHONE
+    return [UIFont systemFontOfSize:0 weight:UIFontWeightRegular].familyName;
+#else
+    return [NSFont systemFontOfSize:0 weight:NSFontWeightRegular].familyName;
+#endif
+}
+
+- (BOOL)perSourceCollisions {
+    id infoDictionaryObject = [NSBundle.mainBundle objectForInfoDictionaryKey:MGLCollisionBehaviorPre4_0Key];
+    return [self perSourceCollisionsWithInfoDictionaryObject:infoDictionaryObject];
+}
+
+- (BOOL)perSourceCollisionsWithInfoDictionaryObject:(nullable id)infoDictionaryObject {
+    // Set the collision behaviour. A value set in `NSUserDefaults.standardUserDefaults`
+    // should override anything in the application's info.plist
+    if ([NSUserDefaults.standardUserDefaults objectForKey:MGLCollisionBehaviorPre4_0Key]) {
+        return [NSUserDefaults.standardUserDefaults boolForKey:MGLCollisionBehaviorPre4_0Key];
+    } else if ([infoDictionaryObject isKindOfClass:[NSNumber class]] || [infoDictionaryObject isKindOfClass:[NSString class]]) {
+        // Also support NSString to correspond with the behavior of `-[NSUserDefaults boolForKey:]`
+        return [infoDictionaryObject boolValue];
+    }
+    return NO;
+}
+
+- (MGLGlyphsRasterizationMode)glyphsRasterizationMode {
+    id infoDictionaryObject = [NSBundle.mainBundle objectForInfoDictionaryKey:MGLGlyphsRasterizationModeKey];
+    return [self glyphsRasterizationModeWithInfoDictionaryObject:infoDictionaryObject];
+}
+
+- (MGLGlyphsRasterizationMode)glyphsRasterizationModeWithInfoDictionaryObject:(id)infoDictionaryObject {
+    if (!infoDictionaryObject || ![infoDictionaryObject isKindOfClass:[NSString class]]) {
+        return MGLGlyphsRasterizationModeNone;
+    }
+    NSDictionary *nameOptionMap = @{@"MGLNoGlyphsRasterizedLocally":@(MGLGlyphsRasterizationModeNoGlyphsRasterizedLocally),
+                                    @"MGLIdeographsRasterizedLocally":@(MGLGlyphsRasterizationModeIdeographsRasterizedLocally),
+                                    @"MGLAllGlyphsRasterizedLocally":@(MGLGlyphsRasterizationModeAllGlyphsRasterizedLocally)};
+
+    return (MGLGlyphsRasterizationMode)[nameOptionMap[infoDictionaryObject] integerValue];
+}
+
+- (mbgl::GlyphsRasterizationOptions)glyphsRasterizationOptions {
+    return [self glyphsRasterizationOptionsWithLocalFontFamilyName:self.localFontFamilyName rasterizationMode:self.glyphsRasterizationMode];
+}
+
+- (mbgl::GlyphsRasterizationOptions)glyphsRasterizationOptionsWithLocalFontFamilyName:(nullable NSString *)fontFamilyName
+                                                                    rasterizationMode:(MGLGlyphsRasterizationMode)rasterizationMode {
+    mbgl::GlyphsRasterizationOptions options;
+    if (fontFamilyName == nil) {
+        if (rasterizationMode != MGLGlyphsRasterizationModeNoGlyphsRasterizedLocally && rasterizationMode != MGLGlyphsRasterizationModeNone) {
+            MGLLogWarning(@"The `MGLIdeographicFontFamilyName` is set to `NO`, this will make `MGLGlyphsRasterizationMode` always be `MGLNoGlyphsRasterizedLocally`.");
+        }
+        options.rasterizationMode = mbgl::GlyphsRasterizationMode::NoGlyphsRasterizedLocally;
+        return options;
+    }
+    
+    options.fontFamily = std::string(fontFamilyName.UTF8String);
+    switch (rasterizationMode) {
+        case MGLGlyphsRasterizationModeIdeographsRasterizedLocally:
+            options.rasterizationMode = mbgl::GlyphsRasterizationMode::IdeographsRasterizedLocally;
+            break;
+        case MGLGlyphsRasterizationModeNoGlyphsRasterizedLocally:
+            options.rasterizationMode = mbgl::GlyphsRasterizationMode::NoGlyphsRasterizedLocally;
+            break;
+        case MGLGlyphsRasterizationModeAllGlyphsRasterizedLocally:
+            options.rasterizationMode = mbgl::GlyphsRasterizationMode::AllGlyphsRasterizedLocally;
+            break;
+        case MGLGlyphsRasterizationModeNone:
+            MGLLogWarning(@"Falling back to MGLIdeographsRasterizedLocally because  MGLIdeographicFontFamilies are specified.")
+            options.rasterizationMode = mbgl::GlyphsRasterizationMode::NoGlyphsRasterizedLocally;
+            break;
+    }
+
+    return options;
+}
+
+
+@end

platform/darwin/src/MGLRendererConfiguration.mm

@@ -0,0 +1,16 @@
+#import "MGLRendererConfiguration.h"
+#include <mbgl/map/glyphs_rasterization_options.hpp>
+
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface MGLRendererConfiguration (Private)
+
+- (mbgl::GlyphsRasterizationOptions)glyphsRasterizationOptions;
+
+- (mbgl::GlyphsRasterizationOptions)glyphsRasterizationOptionsWithLocalFontFamilyName:(nullable NSString *)fontFamilyName
+                                                                    rasterizationMode:(MGLGlyphsRasterizationMode)rasterizationMode;
+
+@end
+
+NS_ASSUME_NONNULL_END

platform/darwin/src/MGLRendererConfiguration_Private.h

@@ -1,6 +1,6 @@
 #import <Mapbox/Mapbox.h>
 #import <XCTest/XCTest.h>
-#import "MGLRendererConfiguration.h"
+#import "MGLRendererConfiguration_Private.h"
 
 static NSString * const MGLRendererConfigurationTests_collisionBehaviorKey = @"MGLCollisionBehaviorPre4_0";
 
@@ -159,4 +159,95 @@ - (void)testSettingMGLIdeographicFontFamilyNameWithPlistValue {
     }
 }
 
+- (void)testMGLGlyphsRasterizationModeWithPlistValue {
+    MGLRendererConfiguration *config = [[MGLRendererConfiguration alloc] init];
+
+    // `MGLGlyphsRasterizationMode` set to nil or not set.
+    {
+        MGLGlyphsRasterizationMode mode = [config glyphsRasterizationModeWithInfoDictionaryObject:nil];
+
+        XCTAssertEqual(mode, MGLGlyphsRasterizationModeNone, @"Glyphs rasterization mode should be `MGLGlyphsRasterizationModeNone` when it setting to nil or not set");
+    }
+
+    // `MGLGlyphsRasterizationMode` set to invalid value.
+    {
+        MGLGlyphsRasterizationMode mode = [config glyphsRasterizationModeWithInfoDictionaryObject:@"invalide option value"];
+
+        XCTAssertEqual(mode, MGLGlyphsRasterizationModeNone, @"Glyphs rasterization mode should be `MGLGlyphsRasterizationModeNone` when it setting to invalid value.");
+    }
+
+    // `MGLGlyphsRasterizationMode` set to "MGLNoGlyphsRasterizedLocally".
+    {
+        MGLGlyphsRasterizationMode mode = [config glyphsRasterizationModeWithInfoDictionaryObject:@"MGLNoGlyphsRasterizedLocally"];
+
+        XCTAssertEqual(mode, MGLGlyphsRasterizationModeNoGlyphsRasterizedLocally, @"Glyphs rasterization mode should be `MGLGlyphsRasterizationModeNoGlyphsRasterizedLocally`.");
+    }
+
+    // `MGLGlyphsRasterizationMode` set to "MGLGlyphsRasterizationModeIdeographsRasterizedLocally".
+    {
+        MGLGlyphsRasterizationMode mode = [config glyphsRasterizationModeWithInfoDictionaryObject:@"MGLIdeographsRasterizedLocally"];
+
+        XCTAssertEqual(mode, MGLGlyphsRasterizationModeIdeographsRasterizedLocally, @"Glyphs rasterization mode should be `MGLGlyphsRasterizationModeIdeographsRasterizedLocally`.");
+    }
+
+    // `MGLGlyphsRasterizationMode` set to "MGLAllGlyphsRasterizedLocally".
+    {
+        MGLGlyphsRasterizationMode mode = [config glyphsRasterizationModeWithInfoDictionaryObject:@"MGLAllGlyphsRasterizedLocally"];
+
+        XCTAssertEqual(mode, MGLGlyphsRasterizationModeAllGlyphsRasterizedLocally, @"Glyphs rasterization mode should be `MGLAllGlyphsRasterizedLocally`.");
+    }
+}
+
+- (void)testGlyphsRasterizationOptions {
+    MGLRendererConfiguration *config = [[MGLRendererConfiguration alloc] init];
+
+    // `MGLIdeographicFontFamilyName` unset, MGLGlyphsRasterizationMode set to AllGlyphsRasterizedLocally.
+    {
+        mbgl::GlyphsRasterizationOptions options = [config glyphsRasterizationOptionsWithLocalFontFamilyName:nil rasterizationMode:MGLGlyphsRasterizationModeAllGlyphsRasterizedLocally];
+
+        XCTAssertEqual(options.fontFamily, mbgl::nullopt, @"Font family name should be `nullptr`");
+        XCTAssertEqual(options.rasterizationMode, mbgl::GlyphsRasterizationMode::NoGlyphsRasterizedLocally, @"Glyphs rasterization mode should be `NoGlyphsRasterizedLocally`");
+    }
+    
+    // `MGLIdeographicFontFamilyName` unset, MGLGlyphsRasterizationMode set to NoGlyphsRasterizedLocally.
+    {
+        mbgl::GlyphsRasterizationOptions options = [config glyphsRasterizationOptionsWithLocalFontFamilyName:nil rasterizationMode:MGLGlyphsRasterizationModeNoGlyphsRasterizedLocally];
+
+        XCTAssertEqual(options.fontFamily, mbgl::nullopt, @"Font family name should be `nullptr`");
+        XCTAssertEqual(options.rasterizationMode, mbgl::GlyphsRasterizationMode::NoGlyphsRasterizedLocally, @"Glyphs rasterization mode should be `NoGlyphsRasterizedLocally`");
+    }
+    
+    // `MGLIdeographicFontFamilyName` set to "Ping Fang", MGLGlyphsRasterizationMode set to IdeographsRasterizedLocally.
+    {
+        mbgl::GlyphsRasterizationOptions options = [config glyphsRasterizationOptionsWithLocalFontFamilyName:@"Ping Fang" rasterizationMode:MGLGlyphsRasterizationModeIdeographsRasterizedLocally];
+
+        XCTAssertEqual(options.fontFamily, std::string(@"Ping Fang".UTF8String), @"Font family name should be `Ping Fang`");
+        XCTAssertEqual(options.rasterizationMode, mbgl::GlyphsRasterizationMode::IdeographsRasterizedLocally, @"Glyphs rasterization mode should be `IdeographsRasterizedLocally`");
+    }
+    
+    // `MGLIdeographicFontFamilyName` set to "Ping Fang", MGLGlyphsRasterizationMode set to NoGlyphsRasterizedLocally.
+    {
+        mbgl::GlyphsRasterizationOptions options = [config glyphsRasterizationOptionsWithLocalFontFamilyName:@"Ping Fang" rasterizationMode:MGLGlyphsRasterizationModeNoGlyphsRasterizedLocally];
+
+        XCTAssertEqual(options.fontFamily, std::string(@"Ping Fang".UTF8String), @"Font family name should be `Ping Fang`");
+        XCTAssertEqual(options.rasterizationMode, mbgl::GlyphsRasterizationMode::NoGlyphsRasterizedLocally, @"Glyphs rasterization mode should be `NoGlyphsRasterizedLocally`");
+    }
+    
+    // `MGLIdeographicFontFamilyName` set to "Ping Fang", MGLGlyphsRasterizationMode set to AllGlyphsRasterizedLocally.
+    {
+        mbgl::GlyphsRasterizationOptions options = [config glyphsRasterizationOptionsWithLocalFontFamilyName:@"Ping Fang" rasterizationMode:MGLGlyphsRasterizationModeAllGlyphsRasterizedLocally];
+
+        XCTAssertEqual(options.fontFamily, std::string(@"Ping Fang".UTF8String), @"Font family name should be `Ping Fang`");
+        XCTAssertEqual(options.rasterizationMode, mbgl::GlyphsRasterizationMode::AllGlyphsRasterizedLocally, @"Glyphs rasterization mode should be `AllGlyphsRasterizedLocally`");
+    }
+    
+    // `MGLIdeographicFontFamilyName` set to "Ping Fang", MGLGlyphsRasterizationMode unset.
+    {
+        mbgl::GlyphsRasterizationOptions options = [config glyphsRasterizationOptionsWithLocalFontFamilyName:@"Ping Fang" rasterizationMode:MGLGlyphsRasterizationModeNone];
+
+        XCTAssertEqual(options.fontFamily, std::string(@"Ping Fang".UTF8String), @"Font family name should be `Ping Fang`");
+        XCTAssertEqual(options.rasterizationMode, mbgl::GlyphsRasterizationMode::NoGlyphsRasterizedLocally, @"Glyphs rasterization mode should be `NoGlyphsRasterizedLocally`");
+    }
+}
+
 @end