Tamaños de fuente diferentes de iOS dentro de la clase de tamaño único para diferentes dispositivos

En iOS 8, podemos diseñar un diseño de interfaz de usuario diferente para cada clase de tamaño. El problema al que me enfrento es que diseñé un diseño para Compact Width y Regular Height (clase de tamaño para todos los iPhones en vertical) pero quiero reducir el tamaño de fuente de las tags para dispositivos de 3,5 y 4 pulgadas (iPhone 4 y 5 ), luego relativamente más grande para dispositivos de 4.7 pulgadas (iPhone 6) y más grandes para 5.5 pulgadas (iPhone 6 Plus). He buscado, pero no he podido encontrar una solución para establecer diferentes tamaños de fuente para diferentes dispositivos dentro de la misma clase de tamaño.

Las Clases de diseño y tamaño automáticas no se dirigen a tamaños de pantalla específicos porque no están diseñados para eso. Apple no quiere que apunte a los dispositivos para ayudarlo a mantener mejor su código.

Supongamos que sale un nuevo modelo de iPhone; si está utilizando Diseño automático y Clases de tamaño, no tiene que arreglar todas las restricciones manualmente para hacer que su aplicación sea compatible con este dispositivo más nuevo. Sin embargo, aún puede establecer el tamaño de fuente de UILabel usando el siguiente código:

 if UIScreen.mainScreen().bounds.size.height == 480 { // iPhone 4 label.font = label.font.fontWithSize(20) } else if UIScreen.mainScreen().bounds.size.height == 568 { // IPhone 5 label.font = label.font.fontWithSize(20) } else if UIScreen.mainScreen().bounds.size.width == 375 { // iPhone 6 label.font = label.font.fontWithSize(20) } else if UIScreen.mainScreen().bounds.size.width == 414 { // iPhone 6+ label.font = label.font.fontWithSize(20) } else if UIScreen.mainScreen().bounds.size.width == 768 { // iPad label.font = label.font.fontWithSize(20) } 

Lo estoy manejando en un proyecto en Swift 3+ usando una clase UILabel Custom , la extensión UILabel y la extensión UIDevice como una solución genérica.

Extensión de UIDevice para obtener screenType :

 public extension UIDevice { var iPhone: Bool { return UIDevice().userInterfaceIdiom == .phone } enum ScreenType: String { case iPhone4 case iPhone5 case iPhone6 case iPhone6Plus case iPhoneX case Unknown } var screenType: ScreenType { guard iPhone else { return .Unknown} switch UIScreen.main.nativeBounds.height { case 960: return .iPhone4 case 1136: return .iPhone5 case 1334: return .iPhone6 case 2208: return .iPhone6Plus case 2436: return .iPhoneX default: return .Unknown } } } 

A continuación se muestra la extensión UILabel que usa screenType para ajustar el tamaño de la fuente. adjustsFontSizeToFitDevice método adjustsFontSizeToFitDevice podría agregarse en la clase personalizada de UILabel también, pero lo he puesto en la extensión UILabel para que sea accesible desde todos los tipos de instancias de UILabel.

La constante “2” utilizada en el método adjustsFontSizeToFitDevice se puede cambiar por cualquier número deseado. Mi lógica es considerar iPhone 6/7/8 como resolución predeterminada, y dar tamaño de fuente adecuado (en Storyboard ) a cada etiqueta para esa resolución. Luego, agrego 2 puntos para iPhone X y iPhone 6/7/8 Plus, mientras que resta 2 puntos para iPhone 4/5.

 extension UILabel { func adjustsFontSizeToFitDevice() { switch UIDevice().screenType { case .iPhone4, .iPhone5: font = font.withSize(font.pointSize - 2) break case .iPhone6Plus, .iPhoneX: font = font.withSize(font.pointSize + 2) break default: font = font.withSize(font.pointSize) } } } 

Finalmente, una clase personalizada de UILabel para aplicar el ajuste de fuente a todas las tags MyCustomLabel de MyCustomLabel .

 class MyCustomLabel: UILabel { // MARK: - Life Cycle Methods override func awakeFromNib() { super.awakeFromNib() adjustsFontSizeToFitDevice() } } 

Uso: en Storyboard , subclase todas las instancias de UILabel de MyCustomLabel cuyo tamaño de fuente debe ajustarse de acuerdo con el tamaño del dispositivo.

Puede lograr el efecto deseado de la siguiente manera.

Usage : lugar de usar 14 como tamaño de fuente , puede usar 14.fontSize , cambiará según el dispositivo, depende de su valor delta.

No es necesario agregar condiciones en cualquier lugar del código. Solo una vez como a continuación.

Uso: UIFont.font_medium(12.fontSize)

Extensión UIFont:

 extension UIFont { class func font_medium(_ size : CGFloat) -> UIFont { return UIFont(name: "EncodeSans-Medium", size: size)!; } } 

Extensión de UIDevice:

 extension UIDevice { enum DeviceTypes { case iPhone4_4s case iPhone5_5s case iPhone6_6s case iPhone6p_6ps case after_iPhone6p_6ps } static var deviceType : DeviceTypes { switch UIScreen.main.height { case 480.0: return .iPhone4_4s case 568.0: return .iPhone5_5s case 667.0: return .iPhone6_6s case 736.0: return .iPhone6p_6ps default: return .after_iPhone6p_6ps } } } 

Extensión int:

 extension Int{ var fontSize : CGFloat { var deltaSize : CGFloat = 0; switch (UIDevice.deviceType) { case .iPhone4_4s, .iPhone5_5s : deltaSize = -1; case .iPhone6_6s : deltaSize = 2; case .iPhone6p_6ps : deltaSize = 2; default: deltaSize = 0; } let selfValue = self; return CGFloat(selfValue) + deltaSize; } } 

Dos caminos:

1) Haga manualmente un método en el delegado de la aplicación, comparta su objeto y el método de llamada.

p.ej :

  var device = UIDevice.currentDevice().model if (device == "iPhone" || device == "iPhone Simulator" || device == "iPod touch") { labelboarder.frame = CGRectMake(0,self.usernameTF.frame.height-10, self.usernameTF.frame.width, 1) labelboarder1.frame = CGRectMake(0,self.usernameTF.frame.height-10, self.usernameTF.frame.width,1) } else { labelboarder.frame = CGRectMake(0,self.usernameTF.frame.height, 500, 1) labelboarder1.frame = CGRectMake(0,self.usernameTF.frame.height, 500,1) } 

2) En cada elemento de UI, vaya al inspector de atributos, declare una fuente.

(Hay un signo + visible a la izquierda del campo Tamaño de fuente. Haga clic en él, seleccione la clase de tamaño coincidente y declare el tamaño de fuente).

La segunda opción es conveniente para mí. Feliz Codificación!

En lugar de escribir código para cada etiqueta, amplíe su clase de etiqueta con su clase de etiqueta personalizada como se muestra a continuación y se escalará automáticamente en función del factor de escala de resolución del dispositivo:

 #define SCALE_FACTOR_H ( [UIScreen mainScreen].bounds.size.height / 568 ) CustomLabel.h #import  @interface CustomLabel : UILabel @end CustomLabel.m #import "CustomLabel.h" @implementation CustomLabel /* // Only override drawRect: if you perform custom drawing. // An empty implementation adversely affects performance during animation. - (void)drawRect:(CGRect)rect { // Drawing code } */ - (id)initWithCoder:(NSCoder *)aDecoder { if( (self = [super initWithCoder:aDecoder]) ){ [self layoutIfNeeded]; [self configurefont]; } return self; } - (void) configurefont { CGFloat newFontSize = (self.font.pointSize * SCALE_FACTOR_H); self.font = [UIFont fontWithName:self.font.fontName size:newFontSize]; } @end 

Crea así,

 #define VIEWHEIGHT ([[UIScreen mainScreen] bounds].size.height) #define VIEWWIDTH ([[UIScreen mainScreen] bounds].size.width) #define FONTNAME_LIGHT @"AppleSDGothicNeo-Regular" #define FONTNAME_BOLD @"AppleSDGothicNeo-Bold" #define LFONT_16 [UIFont fontWithName:FONTNAME_LIGHT size:16] 

después de eso, en el que desea cambiar la fuente de la etiqueta, podemos escribir una sencilla caja de conmutadores

 switch ((VIEWHEIGHT == 568)?1:((VIEWHEIGHT == 667)?2:3)) { case 1:{ boldFont = BFONT_16; } break; case 2:{ privacyFont = LFONT_18; boldFont = BFONT_18; } break; default:{ privacyFont = LFONT_20; boldFont = BFONT_20; } break; } 

Esa es la forma en que lo hice. Está escrito en Swift 4 🙂

 enum DeviceSize { case big, medium, small } protocol Fontadjustable { var devicetype: DeviceSize { get } func adjustFontSizeForDevice() } extension UILabel: Fontadjustable { var devicetype: DeviceSize { switch UIScreen.main.nativeBounds.height { case 1136: return .small case 1334: return .medium case 2208: return .big case 2436: return .big default: return .big } } func adjustFontSizeForDevice() { switch self.devicetype { case .small: self.font = font.withSize(font.pointSize) case .medium: self.font = font.withSize(font.pointSize + 5) case .big: self.font = font.withSize(font.pointSize + 10) } } } 

USO: myawesomeLabel.adjustFontSizeForDevice()