src/MDFRobotoFontLoader.m - external/github.com/material-foundation/material-roboto-font-loader-ios - Git at Google

 /*
  Copyright 2015-present Google Inc.. All Rights Reserved.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
  */

 #import "MDFRobotoFontLoader.h"

 #import "MaterialFontDiskLoader.h"

 NSString *const MDFRobotoRegularFontName = @"Roboto-Regular";
 NSString *const MDFRobotoRegularItalicFontName = @"Roboto-Italic";
 NSString *const MDFRobotoBoldFontName = @"Roboto-Bold";
 NSString *const MDFRobotoBoldItalicFontName = @"Roboto-BoldItalic";
 NSString *const MDFRobotoMediumFontName = @"Roboto-Medium";
 NSString *const MDFRobotoMediumItalicFontName = @"Roboto-MediumItalic";
 NSString *const MDFRobotoLightFontName = @"Roboto-Light";
 NSString *const MDFRobotoLightItalicFontName = @"Roboto-LightItalic";

 NSString *const MDFRobotoRegularFontFilename = @"Roboto-Regular.ttf";
 NSString *const MDFRobotoRegularItalicFontFilename = @"Roboto-Italic.ttf";
 NSString *const MDFRobotoBoldFontFilename = @"Roboto-Bold.ttf";
 NSString *const MDFRobotoBoldItalicFontFilename = @"Roboto-BoldItalic.ttf";
 NSString *const MDFRobotoMediumFontFilename = @"Roboto-Medium.ttf";
 NSString *const MDFRobotoMediumItalicFontFilename = @"Roboto-MediumItalic.ttf";
 NSString *const MDFRobotoLightFontFilename = @"Roboto-Light.ttf";
 NSString *const MDFRobotoLightItalicFontFilename = @"Roboto-LightItalic.ttf";

 NSString *const MDFRobotoBundle = @"MaterialRobotoFontLoader.bundle";


 @interface MDFRobotoFontLoader ()
 @property(nonatomic, strong) MDFFontDiskLoader *lightFontLoader;
 @property(nonatomic, strong) MDFFontDiskLoader *regularFontLoader;
 @property(nonatomic, strong) MDFFontDiskLoader *mediumFontLoader;
 @property(nonatomic, strong) MDFFontDiskLoader *boldFontLoader;

 @property(nonatomic, strong) MDFFontDiskLoader *lightItalicFontLoader;
 @property(nonatomic, strong) MDFFontDiskLoader *italicFontLoader;
 @property(nonatomic, strong) MDFFontDiskLoader *mediumItalicFontLoader;
 @property(nonatomic, strong) MDFFontDiskLoader *boldItalicFontLoader;

 @property(nonatomic, strong) NSBundle *baseBundle;
 @property(nonatomic, strong) NSString *bundleFileName;

 @property(nonatomic, assign) BOOL disableSanityChecks;

 @end

 @implementation MDFRobotoFontLoader

 + (MDFRobotoFontLoader *)sharedInstance {
   static id sharedInstance = nil;
   static dispatch_once_t onceToken;
   dispatch_once(&onceToken, ^{
     sharedInstance = [[self alloc] initInternal];
   });
   return sharedInstance;
 }

 + (NSBundle *)baseBundle {
   static NSBundle *bundle = nil;
   static dispatch_once_t onceToken;
   dispatch_once(&onceToken, ^{
     // We may not be included by the main bundle, but rather by an embedded framework, so figure out
     // to which bundle our code is compiled, and use that as the starting point for bundle loading.
     bundle = [NSBundle bundleForClass:[self class]];
   });

   return bundle;
 }

 - (instancetype)initInternal {
   self = [super init];
   if (self) {
     _baseBundle = [MDFRobotoFontLoader baseBundle];
     _bundleFileName = MDFRobotoBundle;
   }
   return self;
 }

 - (NSString *)description {
   NSMutableString *description = [super.description mutableCopy];
   [description appendString:@" (\n"];
   NSNull *null = [NSNull null];
   NSDictionary *selectors = @{
     NSStringFromSelector(@selector(lightFontLoader)) : _lightFontLoader ?: null,
     NSStringFromSelector(@selector(regularFontLoader)) : _regularFontLoader ?: null,
     NSStringFromSelector(@selector(mediumFontLoader)) : _mediumFontLoader ?: null,
     NSStringFromSelector(@selector(boldFontLoader)) : _boldFontLoader ?: null,
     NSStringFromSelector(@selector(lightItalicFontLoader)) : _lightItalicFontLoader ?: null,
     NSStringFromSelector(@selector(italicFontLoader)) : _italicFontLoader ?: null,
     NSStringFromSelector(@selector(mediumItalicFontLoader)) : _mediumItalicFontLoader ?: null,
     NSStringFromSelector(@selector(boldItalicFontLoader)) : _boldItalicFontLoader ?: null,
   };
   for (NSString *selectorName in selectors) {
     MDFFontDiskLoader *loader = [selectors objectForKey:selectorName];
     if ([loader isEqual:[NSNull null]]) {
       continue;
     }
     [description appendFormat:@"%@: %@\n", selectorName, loader];
   }

   [description appendString:@")\n"];
   return description;
 }

 #pragma mark - Private

 - (void)setBundleFileName:(NSString *)bundleFileName {
   if ([bundleFileName isEqualToString:_bundleFileName]) {
     return;
   }
   if (bundleFileName) {
     _bundleFileName = bundleFileName;
   } else {
     _bundleFileName = MDFRobotoBundle;
   }
   [self resetFontLoaders];
 }

 - (void)setBaseBundle:(NSBundle *)baseBundle {
   if ([baseBundle isEqual:_baseBundle]) {
     return;
   }
   if (baseBundle) {
     _baseBundle = baseBundle;
   } else {
     _baseBundle = [MDFRobotoFontLoader baseBundle];
   }
   [self resetFontLoaders];
 }

 - (void)resetFontLoaders {
   _regularFontLoader = nil;
   _lightFontLoader = nil;
   _mediumFontLoader = nil;
   _boldFontLoader = nil;
   _italicFontLoader = nil;
   _lightItalicFontLoader = nil;
   _mediumItalicFontLoader = nil;
   _boldItalicFontLoader = nil;
 }

 - (MDFFontDiskLoader *)regularFontLoader {
   @synchronized(self) {
     if (!_regularFontLoader) {
       _regularFontLoader = [[MDFFontDiskLoader alloc] initWithFontName:MDFRobotoRegularFontName
                                                               filename:MDFRobotoRegularFontFilename
                                                         bundleFileName:_bundleFileName
                                                             baseBundle:_baseBundle];
     }
     return _regularFontLoader;
   }
 }

 - (MDFFontDiskLoader *)mediumFontLoader {
   @synchronized(self) {
     if (!_mediumFontLoader) {
       _mediumFontLoader = [[MDFFontDiskLoader alloc] initWithFontName:MDFRobotoMediumFontName
                                                              filename:MDFRobotoMediumFontFilename
                                                        bundleFileName:_bundleFileName
                                                            baseBundle:_baseBundle];
     }
     return _mediumFontLoader;
   }
 }

 - (MDFFontDiskLoader *)lightFontLoader {
   @synchronized(self) {
     if (!_lightFontLoader) {
       _lightFontLoader = [[MDFFontDiskLoader alloc] initWithFontName:MDFRobotoLightFontName
                                                             filename:MDFRobotoLightFontFilename
                                                       bundleFileName:_bundleFileName
                                                           baseBundle:_baseBundle];
     }
     return _lightFontLoader;
   }
 }

 - (MDFFontDiskLoader *)boldFontLoader {
   @synchronized(self) {
     if (!_boldFontLoader) {
       _boldFontLoader = [[MDFFontDiskLoader alloc] initWithFontName:MDFRobotoBoldFontName
                                                            filename:MDFRobotoBoldFontFilename
                                                      bundleFileName:_bundleFileName
                                                          baseBundle:_baseBundle];
     }
     return _boldFontLoader;
   }
 }

 - (MDFFontDiskLoader *)italicFontLoader {
   @synchronized(self) {
     if (!_italicFontLoader) {
       _italicFontLoader =
           [[MDFFontDiskLoader alloc] initWithFontName:MDFRobotoRegularItalicFontName
                                              filename:MDFRobotoRegularItalicFontFilename
                                        bundleFileName:_bundleFileName
                                            baseBundle:_baseBundle];
     }
     return _italicFontLoader;
   }
 }

 - (MDFFontDiskLoader *)lightItalicFontLoader {
   @synchronized(self) {
     if (!_lightItalicFontLoader) {
       _lightItalicFontLoader =
           [[MDFFontDiskLoader alloc] initWithFontName:MDFRobotoLightItalicFontName
                                              filename:MDFRobotoLightItalicFontFilename
                                        bundleFileName:_bundleFileName
                                            baseBundle:_baseBundle];
     }
     return _lightItalicFontLoader;
   }
 }

 - (MDFFontDiskLoader *)mediumItalicFontLoader {
   @synchronized(self) {
     if (!_mediumItalicFontLoader) {
       _mediumItalicFontLoader =
           [[MDFFontDiskLoader alloc] initWithFontName:MDFRobotoMediumItalicFontName
                                              filename:MDFRobotoMediumItalicFontFilename
                                        bundleFileName:_bundleFileName
                                            baseBundle:_baseBundle];
     }
     return _mediumItalicFontLoader;
   }
 }

 - (MDFFontDiskLoader *)boldItalicFontLoader {
   @synchronized(self) {
     if (!_boldItalicFontLoader) {
       _boldItalicFontLoader =
           [[MDFFontDiskLoader alloc] initWithFontName:MDFRobotoBoldItalicFontName
                                              filename:MDFRobotoBoldItalicFontFilename
                                        bundleFileName:_bundleFileName
                                            baseBundle:_baseBundle];
     }
     return _boldItalicFontLoader;
   }
 }

 #pragma mark - Public

 - (UIFont *)regularFontOfSize:(CGFloat)fontSize {
   MDFFontDiskLoader *fontLoader = self.regularFontLoader;
   UIFont *font = [fontLoader fontOfSize:fontSize];
   NSAssert(_disableSanityChecks || font, @"Font %@ not found in location: %@.", fontLoader.fontName,
            fontLoader.fontURL);
   if (!font) {
     font = [UIFont systemFontOfSize:fontSize];
   }
   return font;
 }

 - (UIFont *)mediumFontOfSize:(CGFloat)fontSize {
   MDFFontDiskLoader *fontLoader = self.mediumFontLoader;
   UIFont *font = [fontLoader fontOfSize:fontSize];
   NSAssert(_disableSanityChecks || font, @"Font %@ not found in location: %@.", fontLoader.fontName,
            fontLoader.fontURL);
   if (!font) {
     font = [UIFont boldSystemFontOfSize:fontSize];
   }
   return font;
 }

 - (UIFont *)lightFontOfSize:(CGFloat)fontSize {
   MDFFontDiskLoader *fontLoader = self.lightFontLoader;
   UIFont *font = [fontLoader fontOfSize:fontSize];
   NSAssert(_disableSanityChecks || font, @"Font %@ not found in location: %@.", fontLoader.fontName,
            fontLoader.fontURL);
   if (!font) {
     font = [UIFont systemFontOfSize:fontSize];
   }
   return font;
 }

 - (UIFont *)boldFontOfSize:(CGFloat)fontSize {
   MDFFontDiskLoader *fontLoader = self.boldFontLoader;
   UIFont *font = [fontLoader fontOfSize:fontSize];
   NSAssert(_disableSanityChecks || font, @"Font %@ not found in location: %@.", fontLoader.fontName,
            fontLoader.fontURL);
   if (!font) {
     font = [UIFont boldSystemFontOfSize:fontSize];
   }
   return font;
 }

 - (UIFont *)italicFontOfSize:(CGFloat)fontSize {
   MDFFontDiskLoader *fontLoader = self.italicFontLoader;
   UIFont *font = [fontLoader fontOfSize:fontSize];
   NSAssert(_disableSanityChecks || font, @"Font %@ not found in location: %@.", fontLoader.fontName,
            fontLoader.fontURL);
   if (!font) {
     font = [UIFont italicSystemFontOfSize:fontSize];
   }
   return font;
 }

 - (UIFont *)lightItalicFontOfSize:(CGFloat)fontSize {
   MDFFontDiskLoader *fontLoader = self.lightItalicFontLoader;
   UIFont *font = [fontLoader fontOfSize:fontSize];
   NSAssert(_disableSanityChecks || font, @"Font %@ not found in location: %@.", fontLoader.fontName,
            fontLoader.fontURL);
   if (!font) {
     font = [UIFont italicSystemFontOfSize:fontSize];
   }
   return font;
 }

 - (UIFont *)mediumItalicFontOfSize:(CGFloat)fontSize {
   MDFFontDiskLoader *fontLoader = self.mediumItalicFontLoader;
   UIFont *font = [fontLoader fontOfSize:fontSize];
   NSAssert(_disableSanityChecks || font, @"Font %@ not found in location: %@.", fontLoader.fontName,
            fontLoader.fontURL);
   if (!font) {
     font = [UIFont italicSystemFontOfSize:fontSize];
   }
   return font;
 }

 - (UIFont *)boldItalicFontOfSize:(CGFloat)fontSize {
   MDFFontDiskLoader *fontLoader = self.boldItalicFontLoader;
   UIFont *font = [fontLoader fontOfSize:fontSize];
   NSAssert(_disableSanityChecks || font, @"Font %@ not found in location: %@.", fontLoader.fontName,
            fontLoader.fontURL);
   if (!font) {
     font = [UIFont italicSystemFontOfSize:fontSize];
   }
   return font;
 }

 + (BOOL)isItalicFontName:(nonnull NSString *)fontName {
   return [fontName isEqual:MDFRobotoRegularItalicFontName] ||
   [fontName isEqual:MDFRobotoBoldItalicFontName] ||
   [fontName isEqual:MDFRobotoMediumItalicFontName] ||
   [fontName isEqual:MDFRobotoLightItalicFontName];
 }

 + (BOOL)isBoldFontName:(nonnull NSString *)fontName {
   return [fontName isEqualToString:MDFRobotoMediumFontName] ||
   [fontName isEqualToString:MDFRobotoBoldFontName] ||
   [fontName isEqualToString:MDFRobotoMediumItalicFontName] ||
   [fontName isEqualToString:MDFRobotoBoldItalicFontName];
 }

 - (UIFont *)boldFontFromFont:(UIFont *)font {
   NSString *fontName = font.fontName;
   CGFloat fontSize = font.pointSize;
   if ([[self class] isBoldFontName:fontName]) {
     return font;
   } else if ([fontName isEqual:MDFRobotoRegularFontName]) {
     return [self mediumFontOfSize:fontSize];
   } else if ([fontName isEqual:MDFRobotoRegularItalicFontName]) {
     return [self mediumItalicFontOfSize:fontSize];
   } else if ([fontName isEqual:MDFRobotoLightFontName]) {
     return [self mediumFontOfSize:fontSize];
   } else if ([fontName isEqual:MDFRobotoLightItalicFontName]) {
     return [self mediumItalicFontOfSize:fontSize];
   }
   return [UIFont boldSystemFontOfSize:fontSize];
 }

 - (UIFont *)italicFontFromFont:(UIFont *)font {
   NSString *fontName = font.fontName;
   CGFloat fontSize = font.pointSize;
   if ([[self class] isItalicFontName:fontName]) {
     return font;
   } else if ([fontName isEqual:MDFRobotoRegularFontName]) {
     return [self italicFontOfSize:fontSize];
   } else if ([fontName isEqual:MDFRobotoBoldFontName]) {
     return [self boldItalicFontOfSize:fontSize];
   } else if ([fontName isEqual:MDFRobotoMediumFontName]) {
     return [self mediumItalicFontOfSize:fontSize];
   } else if ([fontName isEqual:MDFRobotoLightFontName]) {
     return [self lightItalicFontOfSize:fontSize];
   }
   return [UIFont italicSystemFontOfSize:fontSize];
 }

 + (UIFont *)boldFontFromFont:(UIFont *)font {
   return [[self sharedInstance] boldFontFromFont:font];
 }

 + (UIFont *)italicFontFromFont:(UIFont *)font {
   return [[self sharedInstance] italicFontFromFont:font];
 }

 - (BOOL)isLargeForContrastRatios:(UIFont *)font {
   if (font.pointSize >= 18) {
     return YES;
   }
   if (font.pointSize < 14) {
     return NO;
   }

   UIFontDescriptor *fontDescriptor = font.fontDescriptor;
   if ((fontDescriptor.symbolicTraits & UIFontDescriptorTraitBold) == UIFontDescriptorTraitBold) {
     return YES;
   }

   // We treat medium as large for MDC accesibility when larger than 14
   if ([font.fontName rangeOfString:@"medium" options:NSCaseInsensitiveSearch].location != NSNotFound) {
     return YES;
   }

   return NO;
 }

 @end
	/*
	Copyright 2015-present Google Inc.. All Rights Reserved.

	Licensed under the Apache License, Version 2.0 (the "License");
	you may not use this file except in compliance with the License.
	You may obtain a copy of the License at

	http://www.apache.org/licenses/LICENSE-2.0

	Unless required by applicable law or agreed to in writing, software
	distributed under the License is distributed on an "AS IS" BASIS,
	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	See the License for the specific language governing permissions and
	limitations under the License.
	*/

	#import "MDFRobotoFontLoader.h"

	#import "MaterialFontDiskLoader.h"

	NSString *const MDFRobotoRegularFontName = @"Roboto-Regular";
	NSString *const MDFRobotoRegularItalicFontName = @"Roboto-Italic";
	NSString *const MDFRobotoBoldFontName = @"Roboto-Bold";
	NSString *const MDFRobotoBoldItalicFontName = @"Roboto-BoldItalic";
	NSString *const MDFRobotoMediumFontName = @"Roboto-Medium";
	NSString *const MDFRobotoMediumItalicFontName = @"Roboto-MediumItalic";
	NSString *const MDFRobotoLightFontName = @"Roboto-Light";
	NSString *const MDFRobotoLightItalicFontName = @"Roboto-LightItalic";

	NSString *const MDFRobotoRegularFontFilename = @"Roboto-Regular.ttf";
	NSString *const MDFRobotoRegularItalicFontFilename = @"Roboto-Italic.ttf";
	NSString *const MDFRobotoBoldFontFilename = @"Roboto-Bold.ttf";
	NSString *const MDFRobotoBoldItalicFontFilename = @"Roboto-BoldItalic.ttf";
	NSString *const MDFRobotoMediumFontFilename = @"Roboto-Medium.ttf";
	NSString *const MDFRobotoMediumItalicFontFilename = @"Roboto-MediumItalic.ttf";
	NSString *const MDFRobotoLightFontFilename = @"Roboto-Light.ttf";
	NSString *const MDFRobotoLightItalicFontFilename = @"Roboto-LightItalic.ttf";

	NSString *const MDFRobotoBundle = @"MaterialRobotoFontLoader.bundle";


	@interface MDFRobotoFontLoader ()
	@property(nonatomic, strong) MDFFontDiskLoader *lightFontLoader;
	@property(nonatomic, strong) MDFFontDiskLoader *regularFontLoader;
	@property(nonatomic, strong) MDFFontDiskLoader *mediumFontLoader;
	@property(nonatomic, strong) MDFFontDiskLoader *boldFontLoader;

	@property(nonatomic, strong) MDFFontDiskLoader *lightItalicFontLoader;
	@property(nonatomic, strong) MDFFontDiskLoader *italicFontLoader;
	@property(nonatomic, strong) MDFFontDiskLoader *mediumItalicFontLoader;
	@property(nonatomic, strong) MDFFontDiskLoader *boldItalicFontLoader;

	@property(nonatomic, strong) NSBundle *baseBundle;
	@property(nonatomic, strong) NSString *bundleFileName;

	@property(nonatomic, assign) BOOL disableSanityChecks;

	@end

	@implementation MDFRobotoFontLoader

	+ (MDFRobotoFontLoader *)sharedInstance {
	static id sharedInstance = nil;
	static dispatch_once_t onceToken;
	dispatch_once(&onceToken, ^{
	sharedInstance = [[self alloc] initInternal];
	});
	return sharedInstance;
	}

	+ (NSBundle *)baseBundle {
	static NSBundle *bundle = nil;
	static dispatch_once_t onceToken;
	dispatch_once(&onceToken, ^{
	// We may not be included by the main bundle, but rather by an embedded framework, so figure out
	// to which bundle our code is compiled, and use that as the starting point for bundle loading.
	bundle = [NSBundle bundleForClass:[self class]];
	});

	return bundle;
	}

	- (instancetype)initInternal {
	self = [super init];
	if (self) {
	_baseBundle = [MDFRobotoFontLoader baseBundle];
	_bundleFileName = MDFRobotoBundle;
	}
	return self;
	}

	- (NSString *)description {
	NSMutableString *description = [super.description mutableCopy];
	[description appendString:@" (\n"];
	NSNull *null = [NSNull null];
	NSDictionary *selectors = @{
	NSStringFromSelector(@selector(lightFontLoader)) : _lightFontLoader ?: null,
	NSStringFromSelector(@selector(regularFontLoader)) : _regularFontLoader ?: null,
	NSStringFromSelector(@selector(mediumFontLoader)) : _mediumFontLoader ?: null,
	NSStringFromSelector(@selector(boldFontLoader)) : _boldFontLoader ?: null,
	NSStringFromSelector(@selector(lightItalicFontLoader)) : _lightItalicFontLoader ?: null,
	NSStringFromSelector(@selector(italicFontLoader)) : _italicFontLoader ?: null,
	NSStringFromSelector(@selector(mediumItalicFontLoader)) : _mediumItalicFontLoader ?: null,
	NSStringFromSelector(@selector(boldItalicFontLoader)) : _boldItalicFontLoader ?: null,
	};
	for (NSString *selectorName in selectors) {
	MDFFontDiskLoader *loader = [selectors objectForKey:selectorName];
	if ([loader isEqual:[NSNull null]]) {
	continue;
	}
	[description appendFormat:@"%@: %@\n", selectorName, loader];
	}

	[description appendString:@")\n"];
	return description;
	}

	#pragma mark - Private

	- (void)setBundleFileName:(NSString *)bundleFileName {
	if ([bundleFileName isEqualToString:_bundleFileName]) {
	return;
	}
	if (bundleFileName) {
	_bundleFileName = bundleFileName;
	} else {
	_bundleFileName = MDFRobotoBundle;
	}
	[self resetFontLoaders];
	}

	- (void)setBaseBundle:(NSBundle *)baseBundle {
	if ([baseBundle isEqual:_baseBundle]) {
	return;
	}
	if (baseBundle) {
	_baseBundle = baseBundle;
	} else {
	_baseBundle = [MDFRobotoFontLoader baseBundle];
	}
	[self resetFontLoaders];
	}

	- (void)resetFontLoaders {
	_regularFontLoader = nil;
	_lightFontLoader = nil;
	_mediumFontLoader = nil;
	_boldFontLoader = nil;
	_italicFontLoader = nil;
	_lightItalicFontLoader = nil;
	_mediumItalicFontLoader = nil;
	_boldItalicFontLoader = nil;
	}

	- (MDFFontDiskLoader *)regularFontLoader {
	@synchronized(self) {
	if (!_regularFontLoader) {
	_regularFontLoader = [[MDFFontDiskLoader alloc] initWithFontName:MDFRobotoRegularFontName
	filename:MDFRobotoRegularFontFilename
	bundleFileName:_bundleFileName
	baseBundle:_baseBundle];
	}
	return _regularFontLoader;
	}
	}

	- (MDFFontDiskLoader *)mediumFontLoader {
	@synchronized(self) {
	if (!_mediumFontLoader) {
	_mediumFontLoader = [[MDFFontDiskLoader alloc] initWithFontName:MDFRobotoMediumFontName
	filename:MDFRobotoMediumFontFilename
	bundleFileName:_bundleFileName
	baseBundle:_baseBundle];
	}
	return _mediumFontLoader;
	}
	}

	- (MDFFontDiskLoader *)lightFontLoader {
	@synchronized(self) {
	if (!_lightFontLoader) {
	_lightFontLoader = [[MDFFontDiskLoader alloc] initWithFontName:MDFRobotoLightFontName
	filename:MDFRobotoLightFontFilename
	bundleFileName:_bundleFileName
	baseBundle:_baseBundle];
	}
	return _lightFontLoader;
	}
	}

	- (MDFFontDiskLoader *)boldFontLoader {
	@synchronized(self) {
	if (!_boldFontLoader) {
	_boldFontLoader = [[MDFFontDiskLoader alloc] initWithFontName:MDFRobotoBoldFontName
	filename:MDFRobotoBoldFontFilename
	bundleFileName:_bundleFileName
	baseBundle:_baseBundle];
	}
	return _boldFontLoader;
	}
	}

	- (MDFFontDiskLoader *)italicFontLoader {
	@synchronized(self) {
	if (!_italicFontLoader) {
	_italicFontLoader =
	[[MDFFontDiskLoader alloc] initWithFontName:MDFRobotoRegularItalicFontName
	filename:MDFRobotoRegularItalicFontFilename
	bundleFileName:_bundleFileName
	baseBundle:_baseBundle];
	}
	return _italicFontLoader;
	}
	}

	- (MDFFontDiskLoader *)lightItalicFontLoader {
	@synchronized(self) {
	if (!_lightItalicFontLoader) {
	_lightItalicFontLoader =
	[[MDFFontDiskLoader alloc] initWithFontName:MDFRobotoLightItalicFontName
	filename:MDFRobotoLightItalicFontFilename
	bundleFileName:_bundleFileName
	baseBundle:_baseBundle];
	}
	return _lightItalicFontLoader;
	}
	}

	- (MDFFontDiskLoader *)mediumItalicFontLoader {
	@synchronized(self) {
	if (!_mediumItalicFontLoader) {
	_mediumItalicFontLoader =
	[[MDFFontDiskLoader alloc] initWithFontName:MDFRobotoMediumItalicFontName
	filename:MDFRobotoMediumItalicFontFilename
	bundleFileName:_bundleFileName
	baseBundle:_baseBundle];
	}
	return _mediumItalicFontLoader;
	}
	}

	- (MDFFontDiskLoader *)boldItalicFontLoader {
	@synchronized(self) {
	if (!_boldItalicFontLoader) {
	_boldItalicFontLoader =
	[[MDFFontDiskLoader alloc] initWithFontName:MDFRobotoBoldItalicFontName
	filename:MDFRobotoBoldItalicFontFilename
	bundleFileName:_bundleFileName
	baseBundle:_baseBundle];
	}
	return _boldItalicFontLoader;
	}
	}

	#pragma mark - Public

	- (UIFont *)regularFontOfSize:(CGFloat)fontSize {
	MDFFontDiskLoader *fontLoader = self.regularFontLoader;
	UIFont *font = [fontLoader fontOfSize:fontSize];
	NSAssert(_disableSanityChecks \|\| font, @"Font %@ not found in location: %@.", fontLoader.fontName,
	fontLoader.fontURL);
	if (!font) {
	font = [UIFont systemFontOfSize:fontSize];
	}
	return font;
	}

	- (UIFont *)mediumFontOfSize:(CGFloat)fontSize {
	MDFFontDiskLoader *fontLoader = self.mediumFontLoader;
	UIFont *font = [fontLoader fontOfSize:fontSize];
	NSAssert(_disableSanityChecks \|\| font, @"Font %@ not found in location: %@.", fontLoader.fontName,
	fontLoader.fontURL);
	if (!font) {
	font = [UIFont boldSystemFontOfSize:fontSize];
	}
	return font;
	}

	- (UIFont *)lightFontOfSize:(CGFloat)fontSize {
	MDFFontDiskLoader *fontLoader = self.lightFontLoader;
	UIFont *font = [fontLoader fontOfSize:fontSize];
	NSAssert(_disableSanityChecks \|\| font, @"Font %@ not found in location: %@.", fontLoader.fontName,
	fontLoader.fontURL);
	if (!font) {
	font = [UIFont systemFontOfSize:fontSize];
	}
	return font;
	}

	- (UIFont *)boldFontOfSize:(CGFloat)fontSize {
	MDFFontDiskLoader *fontLoader = self.boldFontLoader;
	UIFont *font = [fontLoader fontOfSize:fontSize];
	NSAssert(_disableSanityChecks \|\| font, @"Font %@ not found in location: %@.", fontLoader.fontName,
	fontLoader.fontURL);
	if (!font) {
	font = [UIFont boldSystemFontOfSize:fontSize];
	}
	return font;
	}

	- (UIFont *)italicFontOfSize:(CGFloat)fontSize {
	MDFFontDiskLoader *fontLoader = self.italicFontLoader;
	UIFont *font = [fontLoader fontOfSize:fontSize];
	NSAssert(_disableSanityChecks \|\| font, @"Font %@ not found in location: %@.", fontLoader.fontName,
	fontLoader.fontURL);
	if (!font) {
	font = [UIFont italicSystemFontOfSize:fontSize];
	}
	return font;
	}

	- (UIFont *)lightItalicFontOfSize:(CGFloat)fontSize {
	MDFFontDiskLoader *fontLoader = self.lightItalicFontLoader;
	UIFont *font = [fontLoader fontOfSize:fontSize];
	NSAssert(_disableSanityChecks \|\| font, @"Font %@ not found in location: %@.", fontLoader.fontName,
	fontLoader.fontURL);
	if (!font) {
	font = [UIFont italicSystemFontOfSize:fontSize];
	}
	return font;
	}

	- (UIFont *)mediumItalicFontOfSize:(CGFloat)fontSize {
	MDFFontDiskLoader *fontLoader = self.mediumItalicFontLoader;
	UIFont *font = [fontLoader fontOfSize:fontSize];
	NSAssert(_disableSanityChecks \|\| font, @"Font %@ not found in location: %@.", fontLoader.fontName,
	fontLoader.fontURL);
	if (!font) {
	font = [UIFont italicSystemFontOfSize:fontSize];
	}
	return font;
	}

	- (UIFont *)boldItalicFontOfSize:(CGFloat)fontSize {
	MDFFontDiskLoader *fontLoader = self.boldItalicFontLoader;
	UIFont *font = [fontLoader fontOfSize:fontSize];
	NSAssert(_disableSanityChecks \|\| font, @"Font %@ not found in location: %@.", fontLoader.fontName,
	fontLoader.fontURL);
	if (!font) {
	font = [UIFont italicSystemFontOfSize:fontSize];
	}
	return font;
	}

	+ (BOOL)isItalicFontName:(nonnull NSString *)fontName {
	return [fontName isEqual:MDFRobotoRegularItalicFontName] \|\|
	[fontName isEqual:MDFRobotoBoldItalicFontName] \|\|
	[fontName isEqual:MDFRobotoMediumItalicFontName] \|\|
	[fontName isEqual:MDFRobotoLightItalicFontName];
	}

	+ (BOOL)isBoldFontName:(nonnull NSString *)fontName {
	return [fontName isEqualToString:MDFRobotoMediumFontName] \|\|
	[fontName isEqualToString:MDFRobotoBoldFontName] \|\|
	[fontName isEqualToString:MDFRobotoMediumItalicFontName] \|\|
	[fontName isEqualToString:MDFRobotoBoldItalicFontName];
	}

	- (UIFont )boldFontFromFont:(UIFont )font {
	NSString *fontName = font.fontName;
	CGFloat fontSize = font.pointSize;
	if ([[self class] isBoldFontName:fontName]) {
	return font;
	} else if ([fontName isEqual:MDFRobotoRegularFontName]) {
	return [self mediumFontOfSize:fontSize];
	} else if ([fontName isEqual:MDFRobotoRegularItalicFontName]) {
	return [self mediumItalicFontOfSize:fontSize];
	} else if ([fontName isEqual:MDFRobotoLightFontName]) {
	return [self mediumFontOfSize:fontSize];
	} else if ([fontName isEqual:MDFRobotoLightItalicFontName]) {
	return [self mediumItalicFontOfSize:fontSize];
	}
	return [UIFont boldSystemFontOfSize:fontSize];
	}

	- (UIFont )italicFontFromFont:(UIFont )font {
	NSString *fontName = font.fontName;
	CGFloat fontSize = font.pointSize;
	if ([[self class] isItalicFontName:fontName]) {
	return font;
	} else if ([fontName isEqual:MDFRobotoRegularFontName]) {
	return [self italicFontOfSize:fontSize];
	} else if ([fontName isEqual:MDFRobotoBoldFontName]) {
	return [self boldItalicFontOfSize:fontSize];
	} else if ([fontName isEqual:MDFRobotoMediumFontName]) {
	return [self mediumItalicFontOfSize:fontSize];
	} else if ([fontName isEqual:MDFRobotoLightFontName]) {
	return [self lightItalicFontOfSize:fontSize];
	}
	return [UIFont italicSystemFontOfSize:fontSize];
	}

	+ (UIFont )boldFontFromFont:(UIFont )font {
	return [[self sharedInstance] boldFontFromFont:font];
	}

	+ (UIFont )italicFontFromFont:(UIFont )font {
	return [[self sharedInstance] italicFontFromFont:font];
	}

	- (BOOL)isLargeForContrastRatios:(UIFont *)font {
	if (font.pointSize >= 18) {
	return YES;
	}
	if (font.pointSize < 14) {
	return NO;
	}

	UIFontDescriptor *fontDescriptor = font.fontDescriptor;
	if ((fontDescriptor.symbolicTraits & UIFontDescriptorTraitBold) == UIFontDescriptorTraitBold) {
	return YES;
	}

	// We treat medium as large for MDC accesibility when larger than 14
	if ([font.fontName rangeOfString:@"medium" options:NSCaseInsensitiveSearch].location != NSNotFound) {
	return YES;
	}

	return NO;
	}

	@end