sistema - emojis ios 10 para android descargar

Establecer una fuente predeterminada para toda la aplicación de iOS?

Question

Tengo una fuente personalizada que quiero usar para todo lo que muestre texto en mi aplicación, etiquetas, vistas de texto, etc.

¿Hay alguna manera de establecer la fuente predeterminada (las etiquetas de forma predeterminada usan SystemFont) para toda la aplicación?

Answer 1

Swift 4.1

Basándome en la respuesta de Fábio Oliveira ( https://.com/a/23042694/2082851 ), hago mi propio rápido 4.

En resumen, esta extensión intercambia las funciones predeterminadas init(coder:) , systemFont(ofSize:) , boldSystemFont(ofSize:) , italicSystemFont(ofSize:) con mis métodos personalizados.

Tenga en cuenta que no se implementa por completo, pero puede intercambiar más métodos en base a mi implementación.

import UIKit

struct AppFontName {
    static let regular = "CourierNewPSMT"
    static let bold = "CourierNewPS-BoldMT"
    static let italic = "CourierNewPS-ItalicMT"
}

extension UIFontDescriptor.AttributeName {
    static let nsctFontUIUsage = UIFontDescriptor.AttributeName(rawValue: "NSCTFontUIUsageAttribute")
}

extension UIFont {

    @objc class func mySystemFont(ofSize size: CGFloat) -> UIFont {
        return UIFont(name: AppFontName.regular, size: size)!
    }

    @objc class func myBoldSystemFont(ofSize size: CGFloat) -> UIFont {
        return UIFont(name: AppFontName.bold, size: size)!
    }

    @objc class func myItalicSystemFont(ofSize size: CGFloat) -> UIFont {
        return UIFont(name: AppFontName.italic, size: size)!
    }

    @objc convenience init(myCoder aDecoder: NSCoder) {
        guard
            let fontDescriptor = aDecoder.decodeObject(forKey: "UIFontDescriptor") as? UIFontDescriptor,
            let fontAttribute = fontDescriptor.fontAttributes[.nsctFontUIUsage] as? String else {
                self.init(myCoder: aDecoder)
                return
        }
        var fontName = ""
        switch fontAttribute {
        case "CTFontRegularUsage":
            fontName = AppFontName.regular
        case "CTFontEmphasizedUsage", "CTFontBoldUsage":
            fontName = AppFontName.bold
        case "CTFontObliqueUsage":
            fontName = AppFontName.italic
        default:
            fontName = AppFontName.regular
        }
        self.init(name: fontName, size: fontDescriptor.pointSize)!
    }

    class func overrideInitialize() {
        guard self == UIFont.self else { return }

        if let systemFontMethod = class_getClassMethod(self, #selector(systemFont(ofSize:))),
            let mySystemFontMethod = class_getClassMethod(self, #selector(mySystemFont(ofSize:))) {
            method_exchangeImplementations(systemFontMethod, mySystemFontMethod)
        }

        if let boldSystemFontMethod = class_getClassMethod(self, #selector(boldSystemFont(ofSize:))),
            let myBoldSystemFontMethod = class_getClassMethod(self, #selector(myBoldSystemFont(ofSize:))) {
            method_exchangeImplementations(boldSystemFontMethod, myBoldSystemFontMethod)
        }

        if let italicSystemFontMethod = class_getClassMethod(self, #selector(italicSystemFont(ofSize:))),
            let myItalicSystemFontMethod = class_getClassMethod(self, #selector(myItalicSystemFont(ofSize:))) {
            method_exchangeImplementations(italicSystemFontMethod, myItalicSystemFontMethod)
        }

        if let initCoderMethod = class_getInstanceMethod(self, #selector(UIFontDescriptor.init(coder:))), // Trick to get over the lack of UIFont.init(coder:))
            let myInitCoderMethod = class_getInstanceMethod(self, #selector(UIFont.init(myCoder:))) {
            method_exchangeImplementations(initCoderMethod, myInitCoderMethod)
        }
    }
}


class AppDelegate: UIResponder, UIApplicationDelegate {
    // Avoid warning of Swift
    // Method ''initialize()'' defines Objective-C class method ''initialize'', which is not guaranteed to be invoked by Swift and will be disallowed in future versions
    override init() {
        super.init()
        UIFont.overrideInitialize()
    }
    ...
}

Answer 2

Desarrollado a partir de la respuesta de Hugues BR pero utilizando el método swizzling He llegado a una solución que está cambiando con éxito todas las fuentes a una fuente deseada en mi aplicación.

Un enfoque con Dynamic Type debería ser lo que debe buscar en iOS 7. La siguiente solución no utiliza Dynamic Type.

Notas:

• el código siguiente, en su estado presentado, nunca se sometió a la aprobación de Apple;
• hay una versión más corta que pasó la presentación de Apple, es decir, sin el - initWithCoder: anulación. Sin embargo, eso no cubrirá todos los casos;
• el siguiente código está presente en una clase que utilizo para configurar el estilo de mi aplicación que está incluido en mi clase de AppDelegate y que está disponible en todas partes y para todas las instancias de UIFont;
• Estoy usando Zapfino aquí solo para hacer los cambios mucho más visibles;
• cualquier mejora que pueda encontrar en este código es bienvenida.

Esta solución usa dos métodos diferentes para lograr el resultado final. El primero es anular los métodos de clase UIFont + systemFontWithSize: y similares con los que usan mis alternativas (aquí uso "Zapfino" para no dejar dudas de que el reemplazo fue exitoso).

El otro método es anular el método initWithCoder en UIFont para reemplazar cualquier aparición de CTFontRegularUsage y similar por mis alternativas. Este último método fue necesario porque descubrí que los objetos UILabel codificados en archivos NIB no comprueban los métodos + systemFontWithSize: para obtener su fuente del sistema y, en su lugar, los codifican como objetos UICTFontDescriptor . Intenté anular - awakeAfterUsingCoder: pero de alguna manera recibía un llamado para cada objeto codificado en mi guión gráfico y causaba bloqueos. Anulación - awakeFromNib no me permitió leer el objeto NSCoder .

#import <objc/runtime.h>

NSString *const FORegularFontName = @"Zapfino";
NSString *const FOBoldFontName = @"Zapfino";
NSString *const FOItalicFontName = @"Zapfino";

#pragma mark - UIFont category
@implementation UIFont (CustomFonts)

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wobjc-protocol-method-implementation"
+ (void)replaceClassSelector:(SEL)originalSelector withSelector:(SEL)modifiedSelector {
    Method originalMethod = class_getClassMethod(self, originalSelector);
    Method modifiedMethod = class_getClassMethod(self, modifiedSelector);
    method_exchangeImplementations(originalMethod, modifiedMethod);
}

+ (void)replaceInstanceSelector:(SEL)originalSelector withSelector:(SEL)modifiedSelector {
    Method originalDecoderMethod = class_getInstanceMethod(self, originalSelector);
    Method modifiedDecoderMethod = class_getInstanceMethod(self, modifiedSelector);
    method_exchangeImplementations(originalDecoderMethod, modifiedDecoderMethod);
}

+ (UIFont *)regularFontWithSize:(CGFloat)size
{
    return [UIFont fontWithName:FORegularFontName size:size];
}

+ (UIFont *)boldFontWithSize:(CGFloat)size
{
    return [UIFont fontWithName:FOBoldFontName size:size];
}

+ (UIFont *)italicFontOfSize:(CGFloat)fontSize
{
    return [UIFont fontWithName:FOItalicFontName size:fontSize];
}

- (id)initCustomWithCoder:(NSCoder *)aDecoder {
    BOOL result = [aDecoder containsValueForKey:@"UIFontDescriptor"];

    if (result) {
        UIFontDescriptor *descriptor = [aDecoder decodeObjectForKey:@"UIFontDescriptor"];

        NSString *fontName;
        if ([descriptor.fontAttributes[@"NSCTFontUIUsageAttribute"] isEqualToString:@"CTFontRegularUsage"]) {
            fontName = FORegularFontName;
        }
        else if ([descriptor.fontAttributes[@"NSCTFontUIUsageAttribute"] isEqualToString:@"CTFontEmphasizedUsage"]) {
            fontName = FOBoldFontName;
        }
        else if ([descriptor.fontAttributes[@"NSCTFontUIUsageAttribute"] isEqualToString:@"CTFontObliqueUsage"]) {
            fontName = FOItalicFontName;
        }
        else {
            fontName = descriptor.fontAttributes[@"NSFontNameAttribute"];
        }

        return [UIFont fontWithName:fontName size:descriptor.pointSize];
    }

    self = [self initCustomWithCoder:aDecoder];

    return self;
}

+ (void)load
{
    [self replaceClassSelector:@selector(systemFontOfSize:) withSelector:@selector(regularFontWithSize:)];
    [self replaceClassSelector:@selector(boldSystemFontOfSize:) withSelector:@selector(boldFontWithSize:)];
    [self replaceClassSelector:@selector(italicSystemFontOfSize:) withSelector:@selector(italicFontOfSize:)];

    [self replaceInstanceSelector:@selector(initWithCoder:) withSelector:@selector(initCustomWithCoder:)];
}
#pragma clang diagnostic pop

@end

Answer 3

El tipo de fuente siempre se establece en código y punta / guión gráfico.

Para el código, al igual que Hugues BR dijo , hacerlo en categoría puede resolver el problema.

Para el plumín / guión gráfico, podemos usar el método Swizzling awakeFromNib para cambiar el tipo de letra, ya que el elemento UI del plumín / guión gráfico siempre lo llama antes de mostrarlo en la pantalla.

Supongo que sabes Aspects . Es una biblioteca para la programación de AOP, basada en el Método Swizzling. Creamos una categoría para UILabel, UIButton, UITextView para implementarlo.

UILabel:

#import "UILabel+OverrideBaseFont.h"
#import "Aspects.h"

@implementation UILabel (OverrideBaseFont)

+ (void)load {
    [[self class]aspect_hookSelector:@selector(awakeFromNib) withOptions:AspectPositionAfter usingBlock:^(id<AspectInfo> aspectInfo) {
        UILabel* instance = [aspectInfo instance];
        UIFont* font = [UIFont fontWithName:@"HelveticaNeue-light" size:instance.font.pointSize];
        instance.font = font;
    }error:nil];
}

@end

UIButton:

#import "UIButton+OverrideBaseFont.h"
#import "Aspects.h"

@implementation UIButton (OverrideBaseFont)

+ (void)load {
    [[self class]aspect_hookSelector:@selector(awakeFromNib) withOptions:AspectPositionAfter usingBlock:^(id<AspectInfo> aspectInfo) {
        UIButton* instance = [aspectInfo instance];
        UILabel* label = instance.titleLabel;
        UIFont* font = [UIFont fontWithName:@"HelveticaNeue-light" size:label.font.pointSize];
        instance.titleLabel.font = font;
    }error:nil];
}

@end

UITextField:

#import "UITextField+OverrideBaseFont.h"
#import "Aspects.h"

@implementation UITextField (OverrideBaseFont)

+ (void)load {
    [[self class]aspect_hookSelector:@selector(awakeFromNib) withOptions:AspectPositionAfter usingBlock:^(id<AspectInfo> aspectInfo) {
        UITextField* instance = [aspectInfo instance];
        UIFont* font = [UIFont fontWithName:@"HelveticaNeue-light" size:instance.font.pointSize];
        instance.font = font;
    }error:nil];
}

@end

UITextView:

#import "UITextView+OverrideBaseFont.h"
#import "Aspects.h"

@implementation UITextView (OverrideBaseFont)

+ (void)load {
    [[self class]aspect_hookSelector:@selector(awakeFromNib) withOptions:AspectPositionAfter usingBlock:^(id<AspectInfo> aspectInfo) {
        UITextView* instance = [aspectInfo instance];
        UIFont* font = [UIFont fontWithName:@"HelveticaNeue-light" size:instance.font.pointSize];
        instance.font = font;
    }error:nil];
}

@end

Eso es todo, puede cambiar HelveticaNeue-light a una macro con el nombre de su fuente.

Answer 4

Estoy usando este tipo de clase de letra rápidamente. Usando la clase de extensión de fuente.

enum FontName: String {

  case regular      = "Roboto-Regular"

}

//MARK: - Set Font Size
enum FontSize: CGFloat {
    case size = 10

}
extension UIFont {

    //MARK: - Bold Font
  class var regularFont10: UIFont {
        return UIFont(name: FontName.regular.rawValue, size:FontSize.size.rawValue )!
    }
}

Answer 5

Hemos logrado lo mismo en Swift -Xcode 7.2 usando Parent View Controller y Child view controller (Herencia).

Archivo - Nuevo - Clase Cocoa Touch - ParentViewController.

    import UIKit
    import Foundation

    class ParentViewController: UIViewController {

        var appUIColor:UIColor = UIColor.redColor()
        var appFont:UIFont = UIFont(name: "Copperplate", size: 20)!

        override func viewDidLoad() {
            super.viewDidLoad()
        }
        func addStatusBar()
        {
            let view = UIView(frame:
                CGRect(x: 0.0, y: 0.0, width: UIScreen.mainScreen().bounds.size.width, height: 20.0)
            )
            view.backgroundColor = appUIColor
            self.view.addSubview(view)
        }
    }    

Cree controladores de vista secundarios y asócielos con un StoryBoard VC, agregue un textLabel.

    import UIKit

    class FontTestController: ParentViewController {
        @IBOutlet var testLabel: UILabel!

        override func viewDidLoad() {
            super.viewDidLoad()
            testLabel.font =  appFont
            testLabel.textColor = appUIColor
        }

O bien, cree una clase UILabel personalizada (método de subclasificación) y asocie las etiquetas requeridas.

import Foundation
import UIKit

class CustomFontLabel: UILabel {
    required init(coder aDecoder: NSCoder) {
        super.init(coder: aDecoder)!
        backgroundColor = ParentViewController().appUIColor
        font = ParentViewController().appFont
        textColor = UIColor.blackColor()
    }
}

Nota: La fuente y el color declarados en Parent VC se implementan en CustomFontLabel. La ventaja es que podemos alterar las propiedades de uilabel / any view all together en algunos cambios simples en Parent VC.

2) ''para'' colocar UIView en bucle para vistas secundarias. Funciona solo en un VC particular.

    override func viewWillLayoutSubviews() {
            for view in self.view.subviews  {
                if view.isKindOfClass(UITextField) {
                UITextField.appearance().font =  UIFont(name: "Copperplate", size: 20)
                }
                if view.isKindOfClass(UILabel) {
                    UILabel.appearance().font =  UIFont(name: "Copperplate", size: 20)    
                }               
            }       
        }

Answer 6

Lo publiqué como una nueva respuesta y no como un comentario porque no tengo suficiente reputación.

COMENTARIOS PARA SWIFT 3.0 Y ADVERTENCIA SWIFT

Puede eliminar el mensaje de advertencia en línea:

let initCoderMethod = class_getInstanceMethod(self, Selector("initWithCoder:"))

Sustituyéndolo por:

let initCoderMethod = class_getInstanceMethod(self, #selector(UIFontDescriptor.init(coder:)))

Answer 7

Ninguna de estas soluciones funciona universalmente en toda la aplicación. Una de las cosas que encontré para ayudar a administrar las fuentes en Xcode es abrir el Guión gráfico como código fuente (guión-clic en el guión gráfico en el navegador de archivos> "Abrir como"> "Fuente"), y luego hacer un buscar y reemplazar.

Answer 8

Para completar la respuesta de Sandy Chapman , esta es una solución en Objective-C (coloque esta categoría en cualquier lugar donde desee cambiar UILabel ):

@implementation UILabel (SubstituteFontName)
- (void)setSubstituteFontName:(NSString *)name UI_APPEARANCE_SELECTOR {
    self.font = [UIFont fontWithName:name size:self.font.pointSize];
}
@end

Luego, puede cambiar Apperance con:

[[UILabel appearance] setSubstituteFontName:@"SourceSansPro-Light"];

Answer 9

Parece ser posible en iOS 5 utilizando el proxy UIAppearance.

 [[UILabel appearance] setFont:[UIFont fontWithName:@"YourFontName" size:17.0]];

Eso configurará la fuente para que sea la que sea tu fuente personalizada para todos los UILabels en tu aplicación. Tendrá que repetirlo para cada control (UIButton, UILabel, etc.).

Recuerde que deberá poner el valor de UIAppFonts en su info.plist e incluir el nombre de la fuente que está incluyendo.

Answer 10

Probablemente no, usted probablemente tendrá el conjunto de la fuente en su control, pero puede hacer que el proceso sea más fácil al centralizar de dónde obtiene los tipos de fuente, por ejemplo, que la aplicación delegada o alguna otra clase común tenga un método que devuelva el fuente, y cualquier cosa que necesite establecer la fuente puede llamar a ese método, que ayudará en caso de que necesite cambiar su fuente, la cambiaría en un lugar y no en cualquier lugar donde configure las fuentes ... Otra alternativa puede ser crear subclases de sus elementos de interfaz de usuario que establecerán automáticamente la fuente, pero eso podría ser excesivo ...

Answer 11

Si está utilizando Swift, puede crear una extensión UILabel:

extension UILabel {

    var substituteFontName : String {
        get { return self.font.fontName }
        set { self.font = UIFont(name: newValue, size: self.font.pointSize) }
    }

}

Y luego, donde haces tu aproximación de apariencia:

UILabel.appearance().substituteFontName = applicationFont

Existe un código Objective-C equivalente que usa UI_APPEARANCE_SELECTOR en una propiedad con el nombre substituteFontName .

Adición

Para el caso en el que desee establecer fuentes en negrita y regulares por separado:

extension UILabel {

    var substituteFontName : String {
        get { return self.font.fontName }
        set { 
            if self.font.fontName.range(of:"Medium") == nil { 
                self.font = UIFont(name: newValue, size: self.font.pointSize)
            }
        }
    }

    var substituteFontNameBold : String {
        get { return self.font.fontName }
        set { 
            if self.font.fontName.range(of:"Medium") != nil { 
                self.font = UIFont(name: newValue, size: self.font.pointSize)
            }
        }
    }
}

Luego, para sus proxis de UIAppearance:

UILabel.appearance().substituteFontName = applicationFont
UILabel.appearance().substituteFontNameBold = applicationFontBold

Nota: si descubre que la sustitución en negrita no funciona, es posible que el nombre de fuente predeterminado no contenga "Medio". Cambie esa cadena por otra coincidencia según sea necesario (gracias a Mason en los comentarios a continuación).

Answer 12

También hay otra solución que será anular systemFont.

Solo crea una categoría

UIFont + SystemFontOverride.h

#import <UIKit/UIKit.h>

@interface UIFont (SystemFontOverride)
@end

UIFont + SystemFontOverride.m

@implementation UIFont (SystemFontOverride)

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wobjc-protocol-method-implementation"

+ (UIFont *)boldSystemFontOfSize:(CGFloat)fontSize {
    return [UIFont fontWithName:@"fontName" size:fontSize];
}

+ (UIFont *)systemFontOfSize:(CGFloat)fontSize {
    return [UIFont fontWithName:@"fontName" size:fontSize];
}

#pragma clang diagnostic pop

@end

Esto reemplazará la implementación predeterminada y la mayoría de UIControls usan systemFont.

Answer 13

NUI es una alternativa al proxy UIAppearance. Le permite controlar la fuente (y muchos otros atributos) de una gran cantidad de tipos de elementos de la interfaz de usuario en toda la aplicación, simplemente modificando una hoja de estilos, que puede reutilizarse en múltiples aplicaciones.

Después de agregar una clase NUILabel a sus etiquetas, puede controlar fácilmente su fuente en la hoja de estilos:

LabelFontName    String    Helvetica

Si tiene etiquetas con diferentes tamaños de fuente, puede controlar sus tamaños usando las etiquetas NUI Label, LargeLabel y SmallLabel, o incluso crear rápidamente sus propias clases.

Answer 14

Para Swift 4

Todas las respuestas anteriores son correctas, pero lo he hecho de una manera diferente, según el tamaño del dispositivo . Aquí, en la clase ATFontManager, he creado el tamaño de fuente predeterminado que se define en la parte superior de la clase como defaultFontSize , este es el tamaño de fuente de iphone plus y puede cambiar de acuerdo con sus requisitos.

     class ATFontManager: UIFont{

    class func setFont( _ iPhone7PlusFontSize: CGFloat? = nil,andFontName fontN : String = FontName.HelveticaNeue) -> UIFont{

        let defaultFontSize : CGFloat = 16

        switch ATDeviceDetector().screenType {

        case .iPhone4:
            if let fontSize = iPhone7PlusFontSize{
                return UIFont(name: fontN, size: fontSize - 3)!
            }
            return UIFont(name: fontN, size: defaultFontSize - 6)!

        case .iPhone5:
            if let fontSize = iPhone7PlusFontSize{
                return UIFont(name: fontN, size: fontSize - 2)!
            }
            return UIFont(name: fontN, size: defaultFontSize - 3)!

        case .iPhone6AndIphone7:
            if let fontSize = iPhone7PlusFontSize{
                return UIFont(name: fontN, size: fontSize - 1)!
            }
            return UIFont(name: fontN, size: defaultFontSize - 1)!

        case .iPhone6PAndIPhone7P:

            return UIFont(name: fontN, size: iPhone7PlusFontSize ?? defaultFontSize)!
        case .iPhoneX:

            return UIFont(name: fontN, size: iPhone7PlusFontSize ?? defaultFontSize)!

        case .iPhoneOrIPadSmallSizeUnknown:

            return UIFont(name: fontN, size: iPhone7PlusFontSize ?? defaultFontSize)!

        case .iPadMini:
            if let fontSize = iPhone7PlusFontSize{
                return UIFont(name: fontN, size: fontSize + 4)!
            }
            return UIFont(name: fontN, size: defaultFontSize + 4)!

        case .iPadPro10Inch:
            if let fontSize = iPhone7PlusFontSize{
                return UIFont(name: fontN, size: fontSize + 5)!
            }
            return UIFont(name: fontN, size: defaultFontSize + 5)!

        case .iPadPro:
            if let fontSize = iPhone7PlusFontSize{
                return UIFont(name: fontN, size: fontSize + 6)!
            }
            return UIFont(name: fontN, size: defaultFontSize + 6)!

        case .iPadUnknown:

            return UIFont(name: fontN, size: defaultFontSize + 3)!

        default:

            return UIFont(name: fontN, size: iPhone7PlusFontSize ?? 15)!
        }
    }
}

He agregado cierto nombre de fuente, para más información puede agregar el nombre y tipo de fuente aquí.

   enum FontName : String {
        case HelveticaNeue = "HelveticaNeue"
        case HelveticaNeueUltraLight = "HelveticaNeue-UltraLight"
        case HelveticaNeueBold = "HelveticaNeue-Bold"
        case HelveticaNeueBoldItalic = "HelveticaNeue-BoldItalic"
        case HelveticaNeueMedium = "HelveticaNeue-Medium"
        case AvenirBlack = "Avenir-Black"
        case ArialBoldMT = "Arial-BoldMT"
        case HoeflerTextBlack = "HoeflerText-Black"
        case AMCAPEternal = "AMCAPEternal"
    }

Esta clase se refiere al detector de dispositivo para proporcionar el tamaño de letra apropiado según el dispositivo.

class ATDeviceDetector {

    var iPhone: Bool {

        return UIDevice().userInterfaceIdiom == .phone
    }

    var ipad : Bool{

        return UIDevice().userInterfaceIdiom == .pad
    }

    let isRetina = UIScreen.main.scale >= 2.0


    enum ScreenType: String {

        case iPhone4
        case iPhone5
        case iPhone6AndIphone7
        case iPhone6PAndIPhone7P
        case iPhoneX

        case iPadMini
        case iPadPro
        case iPadPro10Inch

        case iPhoneOrIPadSmallSizeUnknown
        case iPadUnknown
        case unknown
    }


    struct ScreenSize{

        static let SCREEN_WIDTH         = UIScreen.main.bounds.size.width
        static let SCREEN_HEIGHT        = UIScreen.main.bounds.size.height
        static let SCREEN_MAX_LENGTH    = max(ScreenSize.SCREEN_WIDTH,ScreenSize.SCREEN_HEIGHT)
        static let SCREEN_MIN_LENGTH    = min(ScreenSize.SCREEN_WIDTH,ScreenSize.SCREEN_HEIGHT)
    }


    var screenType: ScreenType {

        switch ScreenSize.SCREEN_MAX_LENGTH {

        case 0..<568.0:
            return .iPhone4
        case 568.0:
            return .iPhone5
        case 667.0:
            return .iPhone6AndIphone7
        case 736.0:
            return .iPhone6PAndIPhone7P
        case 812.0:
            return .iPhoneX
        case 568.0..<812.0:
            return .iPhoneOrIPadSmallSizeUnknown
        case 1112.0:
            return .iPadPro10Inch
        case 1024.0:
            return .iPadMini
        case 1366.0:
            return .iPadPro
        case 812.0..<1366.0:
            return .iPadUnknown
        default:
            return .unknown
        }
    }
}

Cómo utilizar. Espero que ayude

//for default 
label.font = ATFontManager.setFont()

//if you want to provide as your demand. Here **iPhone7PlusFontSize** variable is denoted as font size for *iphone 7plus and iphone 6 plus*, and it **ATFontManager** class automatically handle.
label.font = ATFontManager.setFont(iPhone7PlusFontSize: 15, andFontName: FontName.HelveticaNeue.rawValue)