ios - ohne - iphone x alle apps schließen




Ermitteln Sie, ob das Gerät ein iPhone X ist (20)

Alternativ können Sie den ' DeviceKit -Pod DeviceKit . Nach der Installation müssen Sie nur noch Folgendes tun, um das Gerät zu überprüfen:

private static var hasNotchedDisplay: Bool {
    if let window = UIApplication.shared.keyWindow {
        return (window.compatibleSafeAreaInsets.top > 20.0 || window.compatibleSafeAreaInsets.left > 0.0 || window.compatibleSafeAreaInsets.right > 0.0)
    }

    return false
}

Meine iOS-App verwendet eine benutzerdefinierte Höhe für die UINavigationBar was auf dem neuen iPhone X zu Problemen führt.

Weiß jemand bereits, wie man programmgesteuert (in Objective-C) zuverlässig erkennt, ob eine App auf dem iPhone X ausgeführt wird?

BEARBEITEN:

Natürlich ist es möglich, die Größe des Bildschirms zu überprüfen, aber ich frage mich, ob es eine " TARGET_OS_IPHONE " Methode wie TARGET_OS_IPHONE , um iOS zu erkennen ...

if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPhone) {
    CGSize screenSize = [[UIScreen mainScreen] bounds].size;
    if (screenSize.height == 812)
        NSLog(@"iPhone X");
}

EDIT 2:

Ich denke nicht, dass meine Frage ein Duplikat der verknüpften Frage ist. Natürlich gibt es Methoden, um verschiedene Eigenschaften des aktuellen Geräts zu "messen" und anhand der Ergebnisse zu entscheiden, welches Gerät verwendet wird. Dies war jedoch nicht der eigentliche Punkt meiner Frage, wie ich in meiner ersten Ausgabe zu betonen versuchte.

Die eigentliche Frage ist: "Ist es möglich, direkt zu erkennen, ob das aktuelle Gerät ein iPhone X ist (z. B. durch eine SDK-Funktion) oder muss ich indirekte Messungen verwenden" ?

Nach den bisherigen Antworten gehe ich davon aus, dass die Antwort "Nein, es gibt keine direkten Methoden. Messungen sind der richtige Weg" lautet.


Es gibt mehrere Gründe, um zu wissen, was das Gerät ist.

  1. Sie können die Höhe (und Breite) des Geräts überprüfen. Dies ist nützlich für das Layout, aber normalerweise möchten Sie dies nicht, wenn Sie das genaue Gerät kennen möchten.

  2. Für Layoutzwecke können Sie auch verwenden UIView.safeAreaInsets .

  3. Wenn Sie den Gerätenamen anzeigen möchten, um ihn beispielsweise zu Diagnosezwecken in eine E-Mail aufzunehmen, nachdem Sie das Gerätemodell mit abgerufen haben sysctl () , können Sie den Namen wie folgt berechnen:

    $ curl http://appledevicenames.com/devices/iPhone10,6
    
    iPhone X

Für eine schnelle Lösung mag ich Folgendes:

let var:CGFloat = (UIDevice.current.userInterfaceIdiom == .phone && UIScreen.main.nativeBounds.height == 2436) ? <iPhoneX> : <AllOthers>

Ich habe Peter Kreinzs Code verwendet (weil er sauber war und das getan hat, was ich brauchte), aber dann habe ich festgestellt, dass er funktioniert, wenn sich das Gerät im Hochformat befindet (da die obere Polsterung offensichtlich oben liegt). Also habe ich eine Erweiterung erstellt, um alle Probleme zu lösen Orientierungen mit ihren jeweiligen Auffüllungen, ohne sich auf die Bildschirmgröße zu beziehen:

extension UIDevice {

    var isIphoneX: Bool {
        if #available(iOS 11.0, *), isIphone {
            if isLandscape {
                if let leftPadding = UIApplication.shared.keyWindow?.safeAreaInsets.left, leftPadding > 0 {
                    return true
                }
                if let rightPadding = UIApplication.shared.keyWindow?.safeAreaInsets.right, rightPadding > 0 {
                    return true
                }
            } else {
                if let topPadding = UIApplication.shared.keyWindow?.safeAreaInsets.top, topPadding > 0 {
                    return true
                }
                if let bottomPadding = UIApplication.shared.keyWindow?.safeAreaInsets.bottom, bottomPadding > 0 {
                    return true
                }
            }
        }
        return false
    }

    var isLandscape: Bool {
        return UIDeviceOrientationIsLandscape(orientation) || UIInterfaceOrientationIsLandscape(UIApplication.shared.statusBarOrientation)
    }

    var isPortrait: Bool {
        return UIDeviceOrientationIsPortrait(orientation) || UIInterfaceOrientationIsPortrait(UIApplication.shared.statusBarOrientation)
    }

    var isIphone: Bool {
        return self.userInterfaceIdiom == .phone
    }

    var isIpad: Bool {
        return self.userInterfaceIdiom == .pad
    }
}

Und auf Ihrer Anrufseite haben Sie nur:

let res = UIDevice.current.isIphoneX

Ich musste das gleiche Problem vor kurzem lösen. Und während diese Frage definitiv beantwortet ist ("Nein"), kann dies anderen helfen, die ein iPhone X-spezifisches Layoutverhalten benötigen.

Es hat mich nicht wirklich interessiert, ob das Gerät ein iPhone X ist. Es hat mich interessiert, ob das Gerät ein gekerbtes Display hat.

@objc public extension UIView {
    @objc public var compatibleSafeAreaInsets: UIEdgeInsets {
        if #available(iOS 11.0, *) {
            return safeAreaInsets
        } else {
            return .zero
        }
    }

    @objc public var compatibleSafeAreaLayoutGuide: UILayoutGuide {
        if #available(iOS 11.0, *) {
            return safeAreaLayoutGuide
        } else {
            return layoutMarginsGuide
        }
    }
}

Sie können auch eine hasOnScreenHomeIndicator Variable in die gleiche Richtung schreiben (obwohl Sie vielleicht den unteren sicheren Bereich überprüfen?).

Das oben UIView Genannte verwendet meine Erweiterung für den bequemen Zugriff auf die Einfügungen für den sicheren Bereich unter iOS 10 und früheren Versionen.

import DeviceKit
let device = Device()
if device == .iPhoneX {
  // place your code here
}

Ich verlasse mich auf die Höhe des Statusleistenrahmens, um festzustellen, ob es sich um ein iPhone X handelt:

if UIApplication.shared.statusBarFrame.height >= CGFloat(44) {
    // It is an iPhone X
}

Dies ist für die Anwendung un Porträt. Sie können die Größe auch anhand der Ausrichtung des Geräts überprüfen. Bei anderen iPhones ist die Statusleiste möglicherweise ausgeblendet, sodass die Rahmenhöhe gleich ist 0 . Auf dem iPhone X wird die Statusleiste niemals ausgeblendet.


Normalerweise benötigt der Programmierer es, um sich auf oben oder unten zu beschränken, daher können diese Methoden hilfreich sein

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
}

Vor dem iPhone X geben diese Methoden Folgendes zurück: 0

Für iPhone X: 44 und 34 entsprechend

Dann fügen Sie diese Extras einfach zu den oberen oder unteren Randbedingungen hinzu


Verwenden Sie NICHT die Pixelgröße des Bildschirms, wie andere Lösungen vorgeschlagen haben. Dies ist schlecht, da dies zu Fehlalarmen für zukünftige Geräte führen kann. funktioniert nicht, wenn UIWindow noch nicht gerendert ist (AppDelegate), funktioniert nicht in Querformat-Apps und kann im Simulator fehlschlagen, wenn die Skalierung festgelegt ist.

Ich habe stattdessen ein Makro für diesen Zweck erstellt, das sehr einfach zu verwenden ist und sich auf Hardware-Flags stützt, um die oben genannten Probleme zu vermeiden.

Bearbeiten: Aktualisiert, um iPhoneX, iPhone XS, iPhoneXR, iPhoneXS zu unterstützen

Benutzen:

if (IS_DEVICE_IPHONEX) {
    //do stuff
}

Ja wirklich.

Makro:

Kopieren Sie diese einfach und fügen Sie sie an einer beliebigen Stelle ein. Ich bevorzuge den unteren Rand meiner .h-Datei @end

#import <sys/utsname.h>

#if TARGET_IPHONE_SIMULATOR
#define IS_SIMULATOR YES
#else
#define IS_SIMULATOR NO
#endif

#define IS_DEVICE_IPHONEX (\
(^BOOL (void){\
NSString *__modelIdentifier;\
if (IS_SIMULATOR) {\
__modelIdentifier = NSProcessInfo.processInfo.environment[@"SIMULATOR_MODEL_IDENTIFIER"];\
} else {\
struct utsname __systemInfo;\
uname(&__systemInfo);\
__modelIdentifier = [NSString stringWithCString:__systemInfo.machine encoding:NSUTF8StringEncoding];\
}\
NSString *__iPhoneX_GSM_Identifier = @"iPhone10,6";\
NSString *__iPhoneX_CDMA_Identifier = @"iPhone10,3";\
NSString *__iPhoneXR_Identifier = @"iPhone11,8";\
NSString *__iPhoneXS_Identifier = @"iPhone11,2";\
NSString *__iPhoneXSMax_China_Identifier = @"iPhone11,6";\
NSString *__iPhoneXSMax_Other_Identifier = @"iPhone11,4";\
return ([__modelIdentifier isEqualToString:__iPhoneX_GSM_Identifier] || [__modelIdentifier isEqualToString:__iPhoneX_CDMA_Identifier] || [__modelIdentifier isEqualToString:__iPhoneXR_Identifier] || [__modelIdentifier isEqualToString:__iPhoneXS_Identifier] || [__modelIdentifier isEqualToString:__iPhoneXSMax_China_Identifier] || [__modelIdentifier isEqualToString:__iPhoneXSMax_Other_Identifier]);\
})()\
)

Alle Antworten, die die height sind aus einem Grund nur ein Teil der Geschichte. Wenn Sie dies überprüfen, wenn die Geräteorientierung landscapeLeft oder landscapeRight ist, schlägt die Überprüfung fehl, da die height mit der width vertauscht wird.

Deshalb sieht meine Lösung in Swift 4.0 so aus:

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
    }
}

Alle diese auf Dimensionen basierenden Antworten können auf zukünftigen Geräten zu Fehlverhalten führen. Sie werden heute funktionieren, aber was ist, wenn es nächstes Jahr ein iPhone gibt, das die gleiche Größe hat, aber die Kamera usw. unter dem Glas hat, sodass es keine "Kerbe" gibt? Wenn die einzige Möglichkeit darin besteht, die App zu aktualisieren, ist dies eine schlechte Lösung für Sie und Ihre Kunden.

Sie können auch die Hardware-Modell-Zeichenfolge wie "iPhone 10,1" überprüfen. Dies ist jedoch problematisch, da Apple manchmal unterschiedliche Modellnummern für verschiedene Netzbetreiber auf der ganzen Welt herausgibt.

Der richtige Ansatz ist, das obere Layout neu zu gestalten oder die Probleme mit der Höhe der benutzerdefinierten Navigationsleiste zu lösen (darauf würde ich mich konzentrieren). Wenn Sie sich jedoch dafür entscheiden, keines dieser Dinge zu tun, müssen Sie feststellen, dass alles, was Sie tun, ein Hack ist, damit dies heute funktioniert, und Sie müssen es irgendwann korrigieren, vielleicht mehrmals, um die Hacks zu behalten Arbeiten.


Aufgrund Ihrer Frage lautet die Antwort nein. Es gibt keine direkten Methoden. Weitere Informationen erhalten Sie hier:

und

Die Höhe des iPhone X beträgt 2436 px

Vom Gerätebildschirm aus Größen und Auflösungen :

In den Bildschirmgrößen und -ausrichtungen des Geräts :

Swift 3 und später :

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")

        case 2688:
            print("iPhone XS Max")

        case 1792:
            print("iPhone XR")

        default:
            print("Unknown")
        }
    }

Ziel-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:
            printf("iPhone X, XS");
            break;

        case 2688:
            printf("iPhone XS Max");
            break;

        case 1792:
            printf("iPhone XR");
            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");
    } else if ((UIScreen.MainScreen.Bounds.Height * UIScreen.MainScreen.Scale) == 2688) {
        Console.WriteLine("iPhone XS Max");
    } else if ((UIScreen.MainScreen.Bounds.Height * UIScreen.MainScreen.Scale) == 1792) {
        Console.WriteLine("iPhone XR");
    } else {
        Console.WriteLine("Unknown");
    }
}

Basierend auf ihre frage wie folgt:

Oder verwenden Sie screenSize.height als float 812.0f nicht 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");
    }

Weitere Informationen finden Sie in den Richtlinien für die Benutzeroberfläche von iOS auf der folgenden Seite:

Swift :

Mit topNotch :

var hasTopNotch: Bool {
    if #available(iOS 11.0,  *) {
        return UIApplication.shared.delegate?.window??.safeAreaInsets.top ?? 0 > 20
    }

    return false
}

Ziel-C :

- (BOOL)hasTopNotch {
    if (@available(iOS 11.0, *)) {
        return [[[UIApplication sharedApplication] delegate] window].safeAreaInsets.top > 20.0;
    }

    return  NO;
}

UPDATE :

Verwenden Sie nicht die userInterfaceIdiom Eigenschaft, um den Gerätetyp zu identifizieren, wie in der Dokumentation für userInterfaceIdiom erläutert wird:

Für universelle Anwendungen können Sie diese Eigenschaft verwenden, um das Verhalten Ihrer Anwendung für einen bestimmten Gerätetyp anzupassen. Zum Beispiel haben iPhone- und iPad-Geräte unterschiedliche Bildschirmgrößen, sodass Sie je nach Typ des aktuellen Geräts möglicherweise unterschiedliche Ansichten und Steuerelemente erstellen möchten.

Das heißt, diese Eigenschaft wird nur zum Identifizieren des Ansichtsstils der ausgeführten App verwendet. Die iPhone-App (nicht die Universal-App) kann jedoch über den App Store auf dem iPad installiert werden. In diesem Fall gibt das userInterfaceIdiom auch das UIUserInterfaceIdiomPhone .

Der richtige Weg ist, den Computernamen über uname . Überprüfen Sie die folgenden Details:


Eine weitere Möglichkeit, die unter iOS 11 und iOS 12 funktioniert, da das iPhone X das einzige mit einer Kerbe oben und einem Einschub von 44 ist. Das ist, was ich hier wirklich feststelle:

Ziel 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
}

Wenn Sie sich im Querformat befinden, müssen Sie möglicherweise auch den linken und rechten Sicherheitsbereich überprüfen.

Edit: _window ist das UIWindow des AppDelegate, in dem diese Prüfung in der Anwendung didFinishLaunchingWithOptions durchgeführt wird.

Antwort für iOS 12 aktualisiert, um zu prüfen, ob top> 24 statt top> 0 ist.

Bearbeiten: Im Simulator können Sie zu Hardware wechseln und die Statusleiste für eingehende Anrufe umschalten. Dies zeigt mir, dass sich die Höhe der Statusleiste auf dem iPhone X unter iOS 11 oder iPhone XS iOS 12 bei einem Anruf nicht ändert. Alles, was sich ändert, ist das Zeitsymbol, das in beiden Fällen einen grünen Hintergrund erhält. Hier ist ein Schnappschuss:


Ja, es ist möglich. Laden Sie die UIDevice-Hardware-Erweiterung herunter (oder installieren Sie sie über CocoaPod 'UIDevice-Hardware') und verwenden Sie dann:

NSString* modelID = [[[UIDevice currentDevice] modelIdentifier];
BOOL isIphoneX = [modelID isEqualToString:@"iPhone10,3"] || [modelID isEqualToString:@"iPhone10,6"];

Beachten Sie, dass dies im Simulator nur auf dem tatsächlichen Gerät funktioniert.


Laut der Antwort von @ saswanb ist dies eine Swift 4-Version:

var iphoneX = false
if #available(iOS 11.0, *) {
    if ((UIApplication.shared.keyWindow?.safeAreaInsets.top)! > CGFloat(0.0)) {
        iphoneX = true
    }
}

Sie müssen das iPhone X je nach tatsächlichem Bedarf unterschiedlich erkennen.

für den Umgang mit der Spitzenklasse (Statusleiste, Navigationsleiste) usw.

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
}

für den Umgang mit der unteren Home-Anzeige (Tab-Leiste) usw.

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
}

für Hintergrundgröße, Vollbildfunktionen usw.

class var isIphoneXOrBigger: Bool {
    // 812.0 on iPhone X, XS.
    // 896.0 on iPhone XS Max, XR.
    return UIScreen.main.bounds.height >= 812
}

Hinweis: Mischen Sie es eventuell mit UIDevice.current.userInterfaceIdiom == .phone
Hinweis: Für diese Methode ist ein LaunchScreen-Storyboard oder geeignete LaunchImages erforderlich

für Hintergrundverhältnis, Bildlauffunktionen usw.

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
}

Hinweis: Für diese Methode ist ein LaunchScreen-Storyboard oder geeignete LaunchImages erforderlich

für Analysen, Statistiken, Tracking usw.

Holen Sie sich die Maschinenkennung und vergleichen Sie sie mit dokumentierten Werten:

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"
}

So nehmen Sie den Simulator als gültiges iPhone X in Ihre Analyse auf:

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"
}

Um iPhone XS, XS Max und XR einzuschließen, suchen Sie einfach nach Modellen, die mit "iPhone11" beginnen:

return model == "iPhone10,3" || model == "iPhone10,6" || model.starts(with: "iPhone11,")

für faceID Unterstützung

import LocalAuthentication
/// will fail if user denies canEvaluatePolicy(_:error:)
class var canUseFaceID: Bool {
    if #available(iOS 11.0, *) {
        return LAContext().biometryType == .typeFaceID
    }
    return false
}

Sie sollten nicht davon ausgehen, dass das iPhone X das einzige Gerät ist, das Apple mit einer anderen UINavigationBar-Höhe herausgibt. Versuchen Sie, dieses Problem mit einer allgemeineren Lösung zu lösen. Wenn Sie möchten, dass die Leiste immer 20 Pixel größer ist als die Standardhöhe, sollte Ihr Code der Höhe der Leiste 20 Pixel hinzufügen, anstatt sie auf 64 Pixel (44 Pixel + 20 Pixel) zu setzen.


Swift 3 + 4:

ohne dass ein Pixelwert für die Gerätegröße benötigt wird

//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
    }
}

Beispiel:

if UIApplication.isDeviceWithSafeArea {
     //e.g. change the frame size height of your UITabBar
}

SWIFT 4+ Antwort

iPhone X, XR, XS, XSMAX:

Hinweis: Benötigen Sie ein echtes Gerät für den Test

Reference

 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
    }
}

#define IS_IPHONE (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPhone)
#define IS_IPHONE_X (IS_IPHONE && [[UIScreen mainScreen] bounds].size.height == 812.0f)

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
}




iphone-x