IOS app utilizează o înălțime personalizat pentru UINavigationBar
ceea ce duce la unele probleme pe noul iPhone X.
Are cineva deja știu cum să de încredere detecta programatic (în Objective-C) dacă o aplicație funcționează pe iPhone-ul X?
EDIT:
Desigur verificarea dimensiunea ecranului este posibil, cu toate acestea, mă întreb dacă există o "a construi în" metodă ca TARGET_OS_IPHONE
pentru a detecta iOS...
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPhone) {
CGSize screenSize = [[UIScreen mainScreen] bounds].size;
if (screenSize.height == 812)
NSLog(@"iPhone X");
}
EDIT 2:
Nu cred că întrebarea mea este un duplicat al legată de întrebare. Desigur, există metode de a "măsura" proprietăți diferite de dispozitivul curent și de a folosi rezultatele pentru a decide care este utilizat dispozitivul. Cu toate acestea, acest lucru nu a fost punctul real de întrebarea mea, așa cum am încercat să subliniem în primul meu edit.
Întrebarea reală este: "Este posibil pentru a detecta în mod direct dacă dispozitivul curent este un iPhone X (de exemplu printr-un SDK caracteristică) sau trebuie să utilizeze măsurători indirecte"?
Prin răspunsurile date până acum, presupun că răspunsul este "Nu, nu există nici metode directe. Măsurătorile sunt mod de a merge".
Bazat pe intrebarea ta, raspunsul este nu. Nu există metode directe. Pentru mai multe informații puteți obține informații aici:
și
IPhone X înălțime este 2436 px
De Dispozitiv de Dimensiuni de Ecran și rezoluții:
De Dispozitiv Dimensiunile de Ecran și Orientări:
Swift 3 și mai târziu:
if UIDevice().userInterfaceIdiom == .phone {
switch UIScreen.main.nativeBounds.height {
case 1136:
print("iPhone 5 or 5S or 5C")
case 1334:
print("iPhone 6/6S/7/8")
case 1920, 2208:
print("iPhone 6+/6S+/7+/8+")
case 2436:
print("iPhone X/XS/11 Pro")
case 2688:
print("iPhone XS Max/11 Pro Max")
case 1792:
print("iPhone XR/ 11 ")
default:
print("Unknown")
}
}
Obiectiv-C:
if([[UIDevice currentDevice] userInterfaceIdiom] == UIUserInterfaceIdiomPhone) {
switch ((int)[[UIScreen mainScreen] nativeBounds].size.height) {
case 1136:
printf("iPhone 5 or 5S or 5C");
break;
case 1334:
printf("iPhone 6/6S/7/8");
break;
case 1920, 2208:
printf("iPhone 6+/6S+/7+/8+");
break;
case 2436:
print("iPhone X/XS/11 Pro");
break;
case 2688:
print("iPhone XS Max/11 Pro Max");
break;
case 1792:
print("iPhone XR/ 11 ");
break;
default:
printf("Unknown");
break;
}
}
Xamarin.iOS:
if (UIDevice.CurrentDevice.UserInterfaceIdiom == UIUserInterfaceIdiom.Phone) {
if ((UIScreen.MainScreen.Bounds.Height * UIScreen.MainScreen.Scale) == 1136) {
Console.WriteLine("iPhone 5 or 5S or 5C");
} else if ((UIScreen.MainScreen.Bounds.Height * UIScreen.MainScreen.Scale) == 1334) {
Console.WriteLine("iPhone 6/6S/7/8");
} else if ((UIScreen.MainScreen.Bounds.Height * UIScreen.MainScreen.Scale) == 1920 || (UIScreen.MainScreen.Bounds.Height * UIScreen.MainScreen.Scale) == 2208) {
Console.WriteLine("iPhone 6+/6S+/7+/8+");
} else if ((UIScreen.MainScreen.Bounds.Height * UIScreen.MainScreen.Scale) == 2436) {
Console.WriteLine("iPhone X, XS, 11 Pro");
} else if ((UIScreen.MainScreen.Bounds.Height * UIScreen.MainScreen.Scale) == 2688) {
Console.WriteLine("iPhone XS Max, 11 Pro Max");
} else if ((UIScreen.MainScreen.Bounds.Height * UIScreen.MainScreen.Scale) == 1792) {
Console.WriteLine("iPhone XR, 11");
} else {
Console.WriteLine("Unknown");
}
}
Bazat pe întrebarea dumneavoastră după cum urmează:
Sau de a folosi rezolutie.înălțimea
ca plutesc 812.0 f
nu int 812
.
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPhone) {
CGSize screenSize = [[UIScreen mainScreen] bounds].size;
// 812.0 on iPhone X, XS
// 896.0 on iPhone XS Max, XR.
if (screenSize.height >= 812.0f)
NSLog(@"iPhone X");
}
Pentru mai multe informații, puteți consulta următoarea pagină în iOS Human Interface guidelines:
Rapid:
Detecta cu excelent
:
Dacă cineva în vedere utilizarea notch pentru a detecta iPhoneX, minte ca pe "peisaj" același pentru toate iphone-urile.
var hasTopNotch: Bool {
if #available(iOS 11.0, *) {
return UIApplication.shared.delegate?.window??.safeAreaInsets.top ?? 0 > 20
}
return false
}
Obiectiv-C:
- (BOOL)hasTopNotch {
if (@available(iOS 11.0, *)) {
return [[[UIApplication sharedApplication] delegate] window].safeAreaInsets.top > 20.0;
}
return NO;
}
UPDATE:
Nu utilizați `userInterfaceIdiom de proprietate pentru a identifica tipul de dispozitiv, ca documentația pentru userInterfaceIdiom explică:
Pentru aplicații universale, puteți folosi această proprietate pentru a adapta comportamentul cererea dumneavoastră pentru un anumit tip de dispozitiv. De exemplu, iPhone și iPad dispozitive au dimensiuni diferite de ecran, astfel încât ați putea dori pentru a crea puncte de vedere diferite și de control în funcție de tipul de dispozitiv de curent.
Asta este, această proprietate este doar folosit pentru a identifica aplicația care rulează's a vizualiza stil. Cu toate acestea, aplicația iPhone (nu universal) ar putea fi instalat în dispozitivul iPad prin intermediul App store, în acest caz, userInterfaceIdiom
va reveni `UIUserInterfaceIdiomPhone, de asemenea.
Modul corect este de a obtine masina de nume via uname
. Verificați următoarele pentru detalii:
O altă posibilitate, care funcționează pe iOS 11 și iOS 12 pentru iPhone X este singurul cu o crestătură în partea de sus și un medalion de 44. Asta este ceea ce eu sunt cu adevărat detectarea aici:
Obiectiv-C:
BOOL iPhoneX = NO;
if (@available(iOS 11.0, *)) {
UIWindow *mainWindow = [[[UIApplication sharedApplication] delegate] window];
if (mainWindow.safeAreaInsets.top > 24.0) {
iPhoneX = YES;
}
}
Swift 4:
/// Has safe area
///
/// with notch: 44.0 on iPhone X, XS, XS Max, XR.
///
/// without notch: 20.0 on iPhone 8 on iOS 12+.
///
static var hasSafeArea: Bool {
guard #available(iOS 11.0, *), let topPadding = UIApplication.shared.keyWindow?.safeAreaInsets.top, topPadding > 24 else {
return false
}
return true
}
Și, desigur, s-ar putea nevoie pentru a verifica stânga și la dreapta în zona de siguranță introduceri dacă sunteți în orientarea peisaj.
Edit: _window este UIWindow de AppDelegate, în cazul în care această verificare se face în aplicare didFinishLaunchingWithOptions.
Răspuns actualizat pentru iOS 12 pentru a verifica dacă partea de sus > 24 mai degrabă decât de sus > 0.
Edit: În simulator puteți merge la Hardware, Comutare În apel Bara de Stare. Faci asta îmi arată că bara de stare înălțime nu se schimba pe iPhone X pe iOS 11 sau iPhone XS iOS 12 atunci când angajat într-un apel. Toate se schimbă în pictograma de timp, care devine un fundal verde, în ambele cazuri. Aici's-o clipă:
Trebuie să efectuați diferite detectii de iPhone X, în funcție de nevoile reale.
class var hasTopNotch: Bool {
if #available(iOS 11.0, tvOS 11.0, *) {
// with notch: 44.0 on iPhone X, XS, XS Max, XR.
// without notch: 24.0 on iPad Pro 12.9" 3rd generation, 20.0 on iPhone 8 on iOS 12+.
return UIApplication.shared.delegate?.window??.safeAreaInsets.top ?? 0 > 24
}
return false
}
class var hasBottomSafeAreaInsets: Bool {
if #available(iOS 11.0, tvOS 11.0, *) {
// with home indicator: 34.0 on iPhone X, XS, XS Max, XR.
// with home indicator: 20.0 on iPad Pro 12.9" 3rd generation.
return UIApplication.shared.delegate?.window??.safeAreaInsets.bottom ?? 0 > 0
}
return false
}
class var isIphoneXOrBigger: Bool {
// 812.0 on iPhone X, XS.
// 896.0 on iPhone XS Max, XR.
return UIScreen.main.bounds.height >= 812
}
Notă: în cele din urmă se amestecă cu UIDevice.curent.userInterfaceIdiom == .telefon` Notă: această metodă necesită să aveți un fișier launchscreen rezumat sau buna LaunchImages
class var isIphoneXOrLonger: Bool {
// 812.0 / 375.0 on iPhone X, XS.
// 896.0 / 414.0 on iPhone XS Max, XR.
return UIScreen.main.bounds.height / UIScreen.main.bounds.width >= 896.0 / 414.0
}
Notă: această metodă necesită să aveți un fișier launchscreen rezumat sau buna LaunchImages
Obține mașină de identificare și compara-l la documentate valori:
class var isIphoneX: Bool {
var size = 0
sysctlbyname("hw.machine", nil, &size, nil, 0)
var machine = [CChar](repeating: 0, count: size)
sysctlbyname("hw.machine", &machine, &size, nil, 0)
let model = String(cString: machine)
return model == "iPhone10,3" || model == "iPhone10,6"
}
Pentru a include simulator ca un valabile iPhone X în google analytics:
class var isIphoneX: Bool {
let model: String
if TARGET_OS_SIMULATOR != 0 {
model = ProcessInfo.processInfo.environment["SIMULATOR_MODEL_IDENTIFIER"] ?? ""
} else {
var size = 0
sysctlbyname("hw.machine", nil, &size, nil, 0)
var machine = [CChar](repeating: 0, count: size)
sysctlbyname("hw.machine", &machine, &size, nil, 0)
model = String(cString: machine)
}
return model == "iPhone10,3" || model == "iPhone10,6"
}
Pentru a include iPhone XS, XS Max și XR, pur și simplu uita-te pentru modele incepand cu "iPhone11,":
return model == "iPhone10,3" || model == "iPhone10,6" || model.starts(with: "iPhone11,")
import LocalAuthentication
/// will fail if user denies canEvaluatePolicy(_:error:)
class var canUseFaceID: Bool {
if #available(iOS 11.0, *) {
return LAContext().biometryType == .typeFaceID
}
return false
}
Puteți face ca asta să detecteze iPhone X dispozitiv în funcție de dimensiune.
Rapid
if UIDevice().userInterfaceIdiom == .phone && UIScreen.main.nativeBounds.height == 2436 {
//iPhone X
}
Obiectiv - C
if ([UIDevice currentDevice].userInterfaceIdiom == UIUserInterfaceIdiomPhone && UIScreen.mainScreen.nativeBounds.size.height == 2436) {
//iPhone X
}
Dar,
Acest lucru nu este suficient de drum. Dacă Apple a anuntat iPhone-ul următor cu aceeași dimensiune de iPhone X. deci cel mai bun mod este de a utiliza Hardware șir pentru a detecta dispozitivul.
Pentru mai nou dispozitiv Hardware șir este ca mai jos.
iPhone 8 - iPhone10,1 sau iPhone 10,4
iPhone 8 Plus - iPhone10,2 sau iPhone 10,5
iPhone X - iPhone10,3 sau iPhone10,6
Check out modelul de dispozitiv / mașină de numele, NU utilizați punct/număr de pixeli în cod direct, l's codul de greu și lipsită de sens pentru hardware-ul dispozitivului.
#import <sys/utsname.h>
NSString* deviceName()
{
struct utsname systemInfo;
uname(&systemInfo);
return [NSString stringWithCString:systemInfo.machine
encoding:NSUTF8StringEncoding];
}
Rezultatul:
@"iPhone10,3" on iPhone X (CDMA)
@"iPhone10,6" on iPhone X (GSM)
Consultați acest răspuns.
Plin de implementare a codului:
#import <sys/utsname.h>
NSString * GetDeviceModel(void)
{
static dispatch_once_t onceToken;
static NSString *strModelID = nil;
dispatch_once(&onceToken, ^{
#if TARGET_IPHONE_SIMULATOR
strModelID = NSProcessInfo.processInfo.environment[@"SIMULATOR_MODEL_IDENTIFIER"];
#else
struct utsname systemInfo;
uname(&systemInfo);
strModelID = [NSString stringWithCString:systemInfo.machine encoding:NSUTF8StringEncoding];
#endif
});
return strModelID;
}
// See the `Hardware strings` in https://en.wikipedia.org/wiki/List_of_iOS_devices
BOOL IsiPhoneX(void)
{
NSString *strModelID = GetDeviceModel();
return [strModelID isEqualToString:@"iPhone10,3"] || [strModelID isEqualToString:@"iPhone10,6"];
}
BOOL IsNotchiPhone(void)
{
NSString *strModelID = GetDeviceModel();
return [strModelID isEqualToString:@"iPhone10,3"] || [strModelID isEqualToString:@"iPhone10,6"] || // iPhone X
[strModelID isEqualToString:@"iPhone11,2"] || [strModelID isEqualToString:@"iPhone11,4"] || [strModelID isEqualToString:@"iPhone11,6"] || // iPhone XS (Max)
[strModelID isEqualToString:@"iPhone11,8"] // iPhone XR
[strModelID isEqualToString:@"iPhone12,1"] || [strModelID isEqualToString:@"iPhone12,3"] || [strModelID isEqualToString:@"iPhone12,5"]; // iPhone 11 (Pro (Max))
}
#define IS_IPHONE (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPhone)
#define IS_IPHONE_4 (IS_IPHONE && [[UIScreen mainScreen] bounds].size.height == 480.0)
#define IS_IPHONE_5 (IS_IPHONE && [[UIScreen mainScreen] bounds].size.height == 568.0)
#define IS_IPHONE_6 (IS_IPHONE && [[UIScreen mainScreen] bounds].size.height == 667.0)
#define IS_IPHONE_6PLUS (IS_IPHONE && [[UIScreen mainScreen] nativeScale] == 3.0f)
#define IS_IPHONE_6_PLUS (IS_IPHONE && [[UIScreen mainScreen] bounds].size.height == 736.0)
#define IS_IPHONE_X (IS_IPHONE && [[UIScreen mainScreen] bounds].size.height == 812.0)
#define IS_IPHONE_XS (IS_IPHONE && [[UIScreen mainScreen] bounds].size.height == 812.0)
#define IS_IPHONE_X_MAX (IS_IPHONE && [[UIScreen mainScreen] bounds].size.height == 896.0)
#define IS_RETINA ([[UIScreen mainScreen] scale] >= 2.0) // 3.0 for iPhone X, 2.0 for others
#define IS_IPAD_DEVICE [(NSString*)[UIDevice currentDevice].model hasPrefix:@"iPad"]
Notă:- Fii atent, acesta funcționează bine doar pentru orientare portret
După ce se uită la toate răspunsurile aceasta este ceea ce am ajuns să fac:
extension UIDevice {
static var isIphoneX: Bool {
var modelIdentifier = ""
if isSimulator {
modelIdentifier = ProcessInfo.processInfo.environment["SIMULATOR_MODEL_IDENTIFIER"] ?? ""
} else {
var size = 0
sysctlbyname("hw.machine", nil, &size, nil, 0)
var machine = [CChar](repeating: 0, count: size)
sysctlbyname("hw.machine", &machine, &size, nil, 0)
modelIdentifier = String(cString: machine)
}
return modelIdentifier == "iPhone10,3" || modelIdentifier == "iPhone10,6"
}
static var isSimulator: Bool {
return TARGET_OS_SIMULATOR != 0
}
}
if UIDevice.isIphoneX {
// is iPhoneX
} else {
// is not iPhoneX
}
Pre Swift 4.1 puteți verifica dacă aplicația se execută pe un simulator astfel:
TARGET_OS_SIMULATOR != 0
De la Swift 4.1 și mai departe puteți verifica dacă aplicația se execută pe un simulator folosind mediu Țintă platforma condiție:
#if targetEnvironment(simulator)
return true
#else
return false
#endif
(cea mai veche metodă va funcționa în continuare, dar această nouă metodă este mai future proof)
Toate aceste răspunsuri bazate pe dimensiunile sunt predispuse la un comportament incorect pe dispozitivele viitoare. Ei'll de lucru astăzi, dar dacă nu's un iPhone de anul viitor, care's de aceeași mărime, dar are camera foto, etc. sub geam deci nu's nu "crestătură?" în Cazul în care singura opțiune este de a actualiza aplicația, apoi se's un biet soluție pentru tine și clienții dumneavoastră.
Puteți verifica, de asemenea, modelul de hardware șir, cum ar fi "iPhone10,1", dar's problematică pentru că, uneori, Apple lanseaza diferite numere de model pentru diferiți operatori din întreaga lume.
Abordarea corectă este de a restructura sus layout-ul, sau de a rezolva problemele pe care le're cu obiceiul de navigare bar inaltime (ca's ceea ce am'd se concentreze pe). Dar, dacă vă decideți să nu pentru a face oricare dintre aceste lucruri, își dau seama că orice ai're face este un hack pentru a obține acest lucru azi, iar tu'll nevoie pentru a corecta la un moment dat, probabil, de mai multe ori, pentru a menține hacks de lucru.
SWIFT 4+ Răspuns
iPhone X, XR, XS, XSMAX:
Notă: aveți Nevoie de dispozitiv real pentru testare
let deviceType = UIDevice.current.modelName
switch deviceType {
case "iPhone10,3", "iPhone10,6":
print("iPhoneX")
case "iPhone11,2":
print("iPhone XS")
case "iPhone11,4":
print("iPhone XS Max")
case "iPhone11,6":
print("iPhone XS Max China")
case "iPhone11,8":
print("iPhone XR")
default:
break
}
extension UIDevice {
var modelName: String {
var systemInfo = utsname()
uname(&systemInfo)
let machineMirror = Mirror(reflecting: systemInfo.machine)
let identifier = machineMirror.children.reduce("") { identifier, element in
guard let value = element.value as? Int8, value != 0 else { return identifier }
return identifier + String(UnicodeScalar(UInt8(value)))
}
return identifier
}
}
Da, este posibil. Download UIDevice-Hardware extensie (sau instala prin intermediul CocoaPod 'UIDevice-Hardware') si apoi utilizați:
NSString* modelID = [[[UIDevice currentDevice] modelIdentifier];
BOOL isIphoneX = [modelID isEqualToString:@"iPhone10,3"] || [modelID isEqualToString:@"iPhone10,6"];
Rețineți că asta nu't munca în Simulator, doar pe dispozitiv real.
SWIFT 4/5 reutilizabile extensie cu iPhone 11 suport
public extension UIDevice {
public enum `Type` {
case iPad
case iPhone_unknown
case iPhone_5_5S_5C
case iPhone_6_6S_7_8
case iPhone_6_6S_7_8_PLUS
case iPhone_X_Xs
case iPhone_Xs_11_Pro_Max
case iPhone_Xr_11
case iPhone_11_Pro
}
public var hasHomeButton: Bool {
switch type {
case .iPhone_X_Xs, .iPhone_Xr_11, .iPhone_Xs_11_Pro_Max, .iPhone_11_Pro:
return false
default:
return true
}
}
public var type: Type {
if userInterfaceIdiom == .phone {
switch UIScreen.main.nativeBounds.height {
case 1136: return .iPhone_5_5S_5C
case 1334: return .iPhone_6_6S_7_8
case 1920, 2208: return .iPhone_6_6S_7_8_PLUS
case 2436: return .iPhone_X_Xs
case 2688: return .iPhone_Xs_11_Pro_Max
case 1792: return .iPhone_Xr_11
case 2426: return .iPhone_11_Pro
default: return .iPhone_unknown
}
}
return .iPad
}
}
Știu că's doar un Rapid soluție, dar ar putea ajuta cineva.
Am globals.swift în fiecare proiect și unul din lucrurile care-mi add este DeviceType
a detecta cu ușurință de utilizator's echipament:
struct ScreenSize {
static let width = UIScreen.main.bounds.size.width
static let height = UIScreen.main.bounds.size.height
static let frame = CGRect(x: 0, y: 0, width: ScreenSize.width, height: ScreenSize.height)
static let maxWH = max(ScreenSize.width, ScreenSize.height)
}
struct DeviceType {
static let iPhone4orLess = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.maxWH < 568.0
static let iPhone5orSE = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.maxWH == 568.0
static let iPhone678 = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.maxWH == 667.0
static let iPhone678p = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.maxWH == 736.0
static let iPhoneX = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.maxWH == 812.0
static let iPhoneXRMax = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.maxWH == 896.0
static var hasNotch: Bool {
return iPhoneX || iPhoneXRMax
}
}
Apoi să-l folosească:
if DeviceType.hasNotch {
print("This executes on all phones with a notch")
}
if DeviceType.iPhone678 {
print("This executes on iPhones 6, 7 and 8")
}
Dacă utilizați LaunchImage
în proiectul dumneavoastră, asigurați-vă că pentru a adăuga imagini pentru toate dispozitivele acceptate (cum ar fi XS Max, XR) pentru că `UIScreen.principal.limitele câștigat't se întoarcă valoare corespunzătoare, fără alea.
Toate răspunsurile care se folosesc de "înălțime" sunt doar jumătate din poveste pentru un singur motiv. Daca're de gând să verifice astfel că, atunci când orientarea aparatului este landscapeLeft " sau "landscapeRight
verificarea va eșua, pentru că "înălțimea" este schimbat cu "lățime".
Ca's de ce soluția mea se pare ca aceasta în Swift 4.0:
extension UIScreen {
///
static var isPhoneX: Bool {
let screenSize = UIScreen.main.bounds.size
let width = screenSize.width
let height = screenSize.height
return min(width, height) == 375 && max(width, height) == 812
}
}
struct ScreenSize {
static let width = UIScreen.main.bounds.size.width
static let height = UIScreen.main.bounds.size.height
static let maxLength = max(ScreenSize.width, ScreenSize.height)
static let minLength = min(ScreenSize.width, ScreenSize.height)
static let frame = CGRect(x: 0, y: 0, width: ScreenSize.width, height: ScreenSize.height)
}
struct DeviceType {
static let iPhone4orLess = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.maxLength < 568.0
static let iPhone5orSE = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.maxLength == 568.0
static let iPhone678 = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.maxLength == 667.0
static let iPhone678p = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.maxLength == 736.0
static let iPhoneX = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.maxLength == 812.0
static let IS_IPAD = UIDevice.current.userInterfaceIdiom == .pad && ScreenSize.maxLength == 1024.0
static let IS_IPAD_PRO = UIDevice.current.userInterfaceIdiom == .pad && ScreenSize.maxLength == 1366.0
}
Tu nu ar trebui să presupunem că singurul dispozitiv pe care Apple lanseaza cu un alt UINavigationBar înălțime va fi iPhone X. Încerca să rezolve această problemă folosind un mai generic soluție. Dacă doriți ca bara să fie întotdeauna 20px mai mare decât a default înălțime, codul ar trebui să adăugați 20px la înălțimea de bar, în loc de setarea 64px (44px + 20px).
Swift 3 + 4:
fără a avea nevoie de orice dispozitiv dimensiune pixel valoare
//UIApplication+SafeArea.swift
extension UIApplication {
static var isDeviceWithSafeArea:Bool {
if #available(iOS 11.0, *) {
if let topPadding = shared.keyWindow?.safeAreaInsets.bottom,
topPadding > 0 {
return true
}
}
return false
}
}
Exemplu:
if UIApplication.isDeviceWithSafeArea {
//e.g. change the frame size height of your UITabBar
}
- (BOOL)isIphoneX {
if (@available(iOS 11.0, *)) {
UIWindow *window = UIApplication.sharedApplication.keyWindow;
CGFloat topPadding = window.safeAreaInsets.top;
if(topPadding>0) {
return YES;
}
else {
return NO;
}
}
else {
return NO;
}
}
De obicei, Programator are nevoie de ea pentru constrângere la partea de sus sau de jos, astfel încât aceste metode pot ajuta
static func extraTop() -> CGFloat {
var top: CGFloat = 0
if #available(iOS 11.0, *) {
if let t = UIApplication.shared.keyWindow?.safeAreaInsets.top {
top = t
}
}
return top
}
static func extraBottom() -> CGFloat {
var bottom: CGFloat = 0
if #available(iOS 11.0, *) {
if let b = UIApplication.shared.keyWindow?.safeAreaInsets.bottom {
bottom = b
}
}
return bottom
}
Înainte de iPhone X aceste metode de schimb: 0
Pentru iPhone X: 44 și 34 în mod corespunzător
Apoi, trebuie doar să adăugați aceste extra pentru partea de sus sau de jos constrângeri