¿Cómo determinar el modelo actual de iPhone / dispositivo?

¿Hay alguna forma de obtener el nombre del modelo del dispositivo (iPhone 4S, iPhone 5, iPhone 5S, etc.) en Swift?

Sé que hay una propiedad llamada UIDevice.currentDevice().model pero solo devuelve el tipo de dispositivo (iPod touch, iPhone, iPad, iPhone Simulator, etc.).

También sé que se puede hacer fácilmente en Objective-C con este método:

 #import  struct utsname systemInfo; uname(&systemInfo); NSString* deviceModel = [NSString stringWithCString:systemInfo.machine encoding:NSUTF8StringEncoding]; 

Pero estoy desarrollando mi aplicación para iPhone en Swift, ¿alguien podría ayudarme con la forma equivalente de resolver esto en Swift?

Hice esta extensión “pura Swift” en UIDevice .

Esta versión funciona en Swift 2 o superior. Si usa una versión anterior, use una versión anterior de mi respuesta .

Si está buscando una solución más elegante, puede usar mi DeviceKit μ-framework publicado en GitHub (también disponible a través de CocoaPods, Carthage y Swift Package Manager).

Aquí está el código:

 import UIKit public extension UIDevice { static let 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))) } func mapToDevice(identifier: String) -> String { // swiftlint:disable:this cyclomatic_complexity #if os(iOS) switch identifier { case "iPod5,1": return "iPod Touch 5" case "iPod7,1": return "iPod Touch 6" case "iPhone3,1", "iPhone3,2", "iPhone3,3": return "iPhone 4" case "iPhone4,1": return "iPhone 4s" case "iPhone5,1", "iPhone5,2": return "iPhone 5" case "iPhone5,3", "iPhone5,4": return "iPhone 5c" case "iPhone6,1", "iPhone6,2": return "iPhone 5s" case "iPhone7,2": return "iPhone 6" case "iPhone7,1": return "iPhone 6 Plus" case "iPhone8,1": return "iPhone 6s" case "iPhone8,2": return "iPhone 6s Plus" case "iPhone9,1", "iPhone9,3": return "iPhone 7" case "iPhone9,2", "iPhone9,4": return "iPhone 7 Plus" case "iPhone8,4": return "iPhone SE" case "iPhone10,1", "iPhone10,4": return "iPhone 8" case "iPhone10,2", "iPhone10,5": return "iPhone 8 Plus" case "iPhone10,3", "iPhone10,6": return "iPhone X" case "iPad2,1", "iPad2,2", "iPad2,3", "iPad2,4":return "iPad 2" case "iPad3,1", "iPad3,2", "iPad3,3": return "iPad 3" case "iPad3,4", "iPad3,5", "iPad3,6": return "iPad 4" case "iPad4,1", "iPad4,2", "iPad4,3": return "iPad Air" case "iPad5,3", "iPad5,4": return "iPad Air 2" case "iPad6,11", "iPad6,12": return "iPad 5" case "iPad7,5", "iPad7,6": return "iPad 6" case "iPad2,5", "iPad2,6", "iPad2,7": return "iPad Mini" case "iPad4,4", "iPad4,5", "iPad4,6": return "iPad Mini 2" case "iPad4,7", "iPad4,8", "iPad4,9": return "iPad Mini 3" case "iPad5,1", "iPad5,2": return "iPad Mini 4" case "iPad6,3", "iPad6,4": return "iPad Pro 9.7 Inch" case "iPad6,7", "iPad6,8": return "iPad Pro 12.9 Inch" case "iPad7,1", "iPad7,2": return "iPad Pro 12.9 Inch 2. Generation" case "iPad7,3", "iPad7,4": return "iPad Pro 10.5 Inch" case "AppleTV5,3": return "Apple TV" case "AppleTV6,2": return "Apple TV 4K" case "AudioAccessory1,1": return "HomePod" case "i386", "x86_64": return "Simulator \(mapToDevice(identifier: ProcessInfo().environment["SIMULATOR_MODEL_IDENTIFIER"] ?? "iOS"))" default: return identifier } #elseif os(tvOS) switch identifier { case "AppleTV5,3": return "Apple TV 4" case "AppleTV6,2": return "Apple TV 4K" case "i386", "x86_64": return "Simulator \(mapToDevice(identifier: ProcessInfo().environment["SIMULATOR_MODEL_IDENTIFIER"] ?? "tvOS"))" default: return identifier } #endif } return mapToDevice(identifier: identifier) }() } 

Lo llamas así:

 let modelName = UIDevice.modelName 

Para dispositivos reales, por ejemplo, devuelve “iPad Pro 9.7 pulgadas”, para simuladores devuelve “Simulador” + identificador de simulador, por ejemplo, “Simulator iPad Pro 9.7 pulgadas”

Este ejemplo de Swift 3.0 devuelve el modelo de dispositivo actual como una constante enum (para evitar comparaciones directas con los literales de cadena). El valor en bruto de la enumeración es una String contiene el nombre del dispositivo iOS legible por humanos. Como es Swift, la lista de dispositivos reconocidos solo incluye modelos lo suficientemente recientes como para admitir versiones de iOS que incluyen Swift. El siguiente ejemplo de uso utiliza la implementación al final de esta respuesta:

  switch UIDevice().type { case .iPhone5: print("No TouchID sensor") case .iPhone5S: fallthrough case .iPhone6: fallthrough case .iPhone6plus: fallthrough case .iPad_Pro9_7: fallthrough case .iPad_Pro12_9: fallthrough case .iPhone7: fallthrough case .iPhone7plus: print("Put your thumb on the " + UIDevice().type.rawValue + " TouchID sensor") case .unrecognized: print("Device model unrecognized"); default: print(UIDevice().type.rawValue + " not supported by this app"); } 

Su aplicación debe mantenerse actualizada para las nuevas versiones de dispositivos y también cuando Apple agrega nuevos modelos para la misma familia de dispositivos. Por ejemplo, iPhone3,1 iPhone3,2 iPhone3,4 son todos “iPhone 4”. Evite escribir código que no tenga en cuenta los nuevos modelos, por lo que sus algoritmos no inesperadamente no pueden configurar o responder a un nuevo dispositivo. Puede consultar esta lista actualizada de los modelos de dispositivos iOS para actualizar su aplicación en momentos estratégicos.

iOS incluye interfaces independientes del dispositivo para detectar capacidades de hardware y parámetros como el tamaño de la pantalla. Las interfaces generalizadas que proporciona Apple suelen ser los mecanismos más seguros y mejor compatibles para adaptar dinámicamente el comportamiento de una aplicación a hardware diferente. Sin embargo, el siguiente código puede ser útil para creación de prototipos, depuración, pruebas o cualquier código de tiempo que necesite dirigirse a una familia específica de dispositivos. Esta técnica también puede ser útil para describir el dispositivo actual por su nombre común / públicamente reconocido.

Swift 3

 // 1. Declare outside class definition (or in its own file). // 2. UIKit must be included in file where this code is added. // 3. Extends UIDevice class, thus is available anywhere in app. // // Usage example: // // if UIDevice().type == .simulator { // print("You're running on the simulator... boring!") // } else { // print("Wow! Running on a \(UIDevice().type.rawValue)") // } import UIKit public enum Model : String { case simulator = "simulator/sandbox", iPod1 = "iPod 1", iPod2 = "iPod 2", iPod3 = "iPod 3", iPod4 = "iPod 4", iPod5 = "iPod 5", iPad2 = "iPad 2", iPad3 = "iPad 3", iPad4 = "iPad 4", iPhone4 = "iPhone 4", iPhone4S = "iPhone 4S", iPhone5 = "iPhone 5", iPhone5S = "iPhone 5S", iPhone5C = "iPhone 5C", iPadMini1 = "iPad Mini 1", iPadMini2 = "iPad Mini 2", iPadMini3 = "iPad Mini 3", iPadAir1 = "iPad Air 1", iPadAir2 = "iPad Air 2", iPadPro9_7 = "iPad Pro 9.7\"", iPadPro9_7_cell = "iPad Pro 9.7\" cellular", iPadPro10_5 = "iPad Pro 10.5\"", iPadPro10_5_cell = "iPad Pro 10.5\" cellular", iPadPro12_9 = "iPad Pro 12.9\"", iPadPro12_9_cell = "iPad Pro 12.9\" cellular", iPhone6 = "iPhone 6", iPhone6plus = "iPhone 6 Plus", iPhone6S = "iPhone 6S", iPhone6Splus = "iPhone 6S Plus", iPhoneSE = "iPhone SE", iPhone7 = "iPhone 7", iPhone7plus = "iPhone 7 Plus", iPhone8 = "iPhone 8", iPhone8plus = "iPhone 8 Plus", iPhoneX = "iPhone X", unrecognized = "?unrecognized?" } public extension UIDevice { public var type: Model { var systemInfo = utsname() uname(&systemInfo) let modelCode = withUnsafePointer(to: &systemInfo.machine) { $0.withMemoryRebound(to: CChar.self, capacity: 1) { ptr in String.init(validatingUTF8: ptr) } } var modelMap : [ String : Model ] = [ "i386" : .simulator, "x86_64" : .simulator, "iPod1,1" : .iPod1, "iPod2,1" : .iPod2, "iPod3,1" : .iPod3, "iPod4,1" : .iPod4, "iPod5,1" : .iPod5, "iPad2,1" : .iPad2, "iPad2,2" : .iPad2, "iPad2,3" : .iPad2, "iPad2,4" : .iPad2, "iPad2,5" : .iPadMini1, "iPad2,6" : .iPadMini1, "iPad2,7" : .iPadMini1, "iPhone3,1" : .iPhone4, "iPhone3,2" : .iPhone4, "iPhone3,3" : .iPhone4, "iPhone4,1" : .iPhone4S, "iPhone5,1" : .iPhone5, "iPhone5,2" : .iPhone5, "iPhone5,3" : .iPhone5C, "iPhone5,4" : .iPhone5C, "iPad3,1" : .iPad3, "iPad3,2" : .iPad3, "iPad3,3" : .iPad3, "iPad3,4" : .iPad4, "iPad3,5" : .iPad4, "iPad3,6" : .iPad4, "iPhone6,1" : .iPhone5S, "iPhone6,2" : .iPhone5S, "iPad4,1" : .iPadAir1, "iPad4,2" : .iPadAir2, "iPad4,4" : .iPadMini2, "iPad4,5" : .iPadMini2, "iPad4,6" : .iPadMini2, "iPad4,7" : .iPadMini3, "iPad4,8" : .iPadMini3, "iPad4,9" : .iPadMini3, "iPad6,3" : .iPadPro9_7, "iPad6,11" : .iPadPro9_7, "iPad6,4" : .iPadPro9_7_cell, "iPad6,12" : .iPadPro9_7_cell, "iPad6,7" : .iPadPro12_9, "iPad6,8" : .iPadPro12_9_cell, "iPad7,3" : .iPadPro10_5, "iPad7,4" : .iPadPro10_5_cell, "iPhone7,1" : .iPhone6plus, "iPhone7,2" : .iPhone6, "iPhone8,1" : .iPhone6S, "iPhone8,2" : .iPhone6Splus, "iPhone8,4" : .iPhoneSE, "iPhone9,1" : .iPhone7, "iPhone9,2" : .iPhone7plus, "iPhone9,3" : .iPhone7, "iPhone9,4" : .iPhone7plus, "iPhone10,1" : .iPhone8, "iPhone10,2" : .iPhone8plus, "iPhone10,3" : .iPhoneX, "iPhone10,6" : .iPhoneX ] if let model = modelMap[String.init(validatingUTF8: modelCode!)!] { return model } return Model.unrecognized } } 

Otra alternativa más / simple (referencia de identificador de modelo que se encuentra en https://www.theiphonewiki.com/wiki/Models ):

Respuesta actualizada para Swift 3/4, incluido el recorte de cuerdas y la compatibilidad con simuladores:

 func modelIdentifier() -> String { if let simulatorModelIdentifier = ProcessInfo().environment["SIMULATOR_MODEL_IDENTIFIER"] { return simulatorModelIdentifier } var sysinfo = utsname() uname(&sysinfo) // ignore return value return String(bytes: Data(bytes: &sysinfo.machine, count: Int(_SYS_NAMELEN)), encoding: .ascii)!.trimmingCharacters(in: .controlCharacters) } 

Respuesta original para Swift 2:

 func modelIdentifier() -> String { var sysinfo = utsname() uname(&sysinfo) // ignore return value return NSString(bytes: &sysinfo.machine, length: Int(_SYS_NAMELEN), encoding: NSASCIIStringEncoding)! as String } 

Swift 4 ambos dispositivo / simulador

y nuevo iPhone 8 , iPhone 8 plus , iPhone X , iPad 2018 , iPad 10.5 pulgadas y iPad Pro 2ª generación

(publicación actualizada este verano agosto de 2018)

PD (Este método detecta también el modelo correcto si es un simulador y el modelo de dispositivo simulador utilizado …):

 public enum Model : String { case simulator = "simulator/sandbox", //iPod iPod1 = "iPod 1", iPod2 = "iPod 2", iPod3 = "iPod 3", iPod4 = "iPod 4", iPod5 = "iPod 5", //iPad iPad2 = "iPad 2", iPad3 = "iPad 3", iPad4 = "iPad 4", iPadAir = "iPad Air ", iPadAir2 = "iPad Air 2", iPad5 = "iPad 5", //aka iPad 2017 iPad6 = "iPad 6", //aka iPad 2018 //iPad mini iPadMini = "iPad Mini", iPadMini2 = "iPad Mini 2", iPadMini3 = "iPad Mini 3", iPadMini4 = "iPad Mini 4", //iPad pro iPadPro9_7 = "iPad Pro 9.7\"", iPadPro10_5 = "iPad Pro 10.5\"", iPadPro12_9 = "iPad Pro 12.9\"", iPadPro2_12_9 = "iPad Pro 2 12.9\"", //iPhone iPhone4 = "iPhone 4", iPhone4S = "iPhone 4S", iPhone5 = "iPhone 5", iPhone5S = "iPhone 5S", iPhone5C = "iPhone 5C", iPhone6 = "iPhone 6", iPhone6plus = "iPhone 6 Plus", iPhone6S = "iPhone 6S", iPhone6Splus = "iPhone 6S Plus", iPhoneSE = "iPhone SE", iPhone7 = "iPhone 7", iPhone7plus = "iPhone 7 Plus", iPhone8 = "iPhone 8", iPhone8plus = "iPhone 8 Plus", iPhoneX = "iPhone X", //Apple TV AppleTV = "Apple TV", AppleTV_4K = "Apple TV 4K", unrecognized = "?unrecognized?" } // #-#-#-#-#-#-#-#-#-#-#-#-#-#-# //MARK: UIDevice extensions // #-#-#-#-#-#-#-#-#-#-#-#-#-#-# public extension UIDevice { public var type: Model { var systemInfo = utsname() uname(&systemInfo) let modelCode = withUnsafePointer(to: &systemInfo.machine) { $0.withMemoryRebound(to: CChar.self, capacity: 1) { ptr in String.init(validatingUTF8: ptr) } } var modelMap : [ String : Model ] = [ "i386" : .simulator, "x86_64" : .simulator, //iPod "iPod1,1" : .iPod1, "iPod2,1" : .iPod2, "iPod3,1" : .iPod3, "iPod4,1" : .iPod4, "iPod5,1" : .iPod5, //iPad "iPad2,1" : .iPad2, "iPad2,2" : .iPad2, "iPad2,3" : .iPad2, "iPad2,4" : .iPad2, "iPad3,1" : .iPad3, "iPad3,2" : .iPad3, "iPad3,3" : .iPad3, "iPad3,4" : .iPad4, "iPad3,5" : .iPad4, "iPad3,6" : .iPad4, "iPad4,1" : .iPadAir, "iPad4,2" : .iPadAir, "iPad4,3" : .iPadAir, "iPad5,3" : .iPadAir2, "iPad5,4" : .iPadAir2, "iPad6,11" : .iPad5, //aka iPad 2017 "iPad6,12" : .iPad5, "iPad7,5" : .iPad6, //aka iPad 2018 "iPad7,6" : .iPad6, //iPad mini "iPad2,5" : .iPadMini, "iPad2,6" : .iPadMini, "iPad2,7" : .iPadMini, "iPad4,4" : .iPadMini2, "iPad4,5" : .iPadMini2, "iPad4,6" : .iPadMini2, "iPad4,7" : .iPadMini3, "iPad4,8" : .iPadMini3, "iPad4,9" : .iPadMini3, "iPad5,1" : .iPadMini4, "iPad5,2" : .iPadMini4, //iPad pro "iPad6,3" : .iPadPro9_7, "iPad6,4" : .iPadPro9_7, "iPad7,3" : .iPadPro10_5, "iPad7,4" : .iPadPro10_5, "iPad6,7" : .iPadPro12_9, "iPad6,8" : .iPadPro12_9, "iPad7,1" : .iPadPro2_12_9, "iPad7,2" : .iPadPro2_12_9, //iPhone "iPhone3,1" : .iPhone4, "iPhone3,2" : .iPhone4, "iPhone3,3" : .iPhone4, "iPhone4,1" : .iPhone4S, "iPhone5,1" : .iPhone5, "iPhone5,2" : .iPhone5, "iPhone5,3" : .iPhone5C, "iPhone5,4" : .iPhone5C, "iPhone6,1" : .iPhone5S, "iPhone6,2" : .iPhone5S, "iPhone7,1" : .iPhone6plus, "iPhone7,2" : .iPhone6, "iPhone8,1" : .iPhone6S, "iPhone8,2" : .iPhone6Splus, "iPhone8,4" : .iPhoneSE, "iPhone9,1" : .iPhone7, "iPhone9,3" : .iPhone7, "iPhone9,2" : .iPhone7plus, "iPhone9,4" : .iPhone7plus, "iPhone10,1" : .iPhone8, "iPhone10,4" : .iPhone8, "iPhone10,2" : .iPhone8plus, "iPhone10,5" : .iPhone8plus, "iPhone10,3" : .iPhoneX, "iPhone10,6" : .iPhoneX, //AppleTV "AppleTV5,3" : .AppleTV, "AppleTV6,2" : .AppleTV_4K ] if let model = modelMap[String.init(validatingUTF8: modelCode!)!] { if model == .simulator { if let simModelCode = ProcessInfo().environment["SIMULATOR_MODEL_IDENTIFIER"] { if let simModel = modelMap[String.init(validatingUTF8: simModelCode)!] { return simModel } } } return model } return Model.unrecognized } } 

Uso : obtienes tu modelo simplemente con:

 let deviceType = UIDevice().type 

o imprime la cadena exacta con:

 print("\(UIDevice().type.rawvalue)") 

Salida:

 iPhone X 

Otro ejemplo :

 var myDefaultFontSize:CGFloat = 26.0 switch UIDevice().type { case .iPhoneSE,.iPhone5,.iPhone5S: print("default value") case .iPhone6,.iPhone7,.iPhone8,.iPhone6S, .iPhoneX : myDefaultFontSize += 4 default:break } 

Tanto para el dispositivo como para los simuladores, cree un nuevo archivo rápido con el nombre UIDevice.swift

Agrega el código a continuación

 import UIKit public extension UIDevice { var modelName: String { #if (arch(i386) || arch(x86_64)) && os(iOS) let DEVICE_IS_SIMULATOR = true #else let DEVICE_IS_SIMULATOR = false #endif var machineString : String = "" if DEVICE_IS_SIMULATOR == true { if let dir = NSProcessInfo().environment["SIMULATOR_MODEL_IDENTIFIER"] { machineString = dir } } else { var systemInfo = utsname() uname(&systemInfo) let machineMirror = Mirror(reflecting: systemInfo.machine) machineString = machineMirror.children.reduce("") { identifier, element in guard let value = element.value as? Int8 where value != 0 else { return identifier } return identifier + String(UnicodeScalar(UInt8(value))) } } switch machineString { case "iPod5,1": return "iPod Touch 5" case "iPod7,1": return "iPod Touch 6" case "iPhone3,1", "iPhone3,2", "iPhone3,3": return "iPhone 4" case "iPhone4,1": return "iPhone 4s" case "iPhone5,1", "iPhone5,2": return "iPhone 5" case "iPhone5,3", "iPhone5,4": return "iPhone 5c" case "iPhone6,1", "iPhone6,2": return "iPhone 5s" case "iPhone7,2": return "iPhone 6" case "iPhone7,1": return "iPhone 6 Plus" case "iPhone8,1": return "iPhone 6s" case "iPhone8,2": return "iPhone 6s Plus" case "iPad2,1", "iPad2,2", "iPad2,3", "iPad2,4":return "iPad 2" case "iPad3,1", "iPad3,2", "iPad3,3": return "iPad 3" case "iPad3,4", "iPad3,5", "iPad3,6": return "iPad 4" case "iPad4,1", "iPad4,2", "iPad4,3": return "iPad Air" case "iPad5,3", "iPad5,4": return "iPad Air 2" case "iPad2,5", "iPad2,6", "iPad2,7": return "iPad Mini" case "iPad4,4", "iPad4,5", "iPad4,6": return "iPad Mini 2" case "iPad4,7", "iPad4,8", "iPad4,9": return "iPad Mini 3" case "iPad5,1", "iPad5,2": return "iPad Mini 4" case "iPad6,7", "iPad6,8": return "iPad Pro" case "AppleTV5,3": return "Apple TV" default: return machineString } } } 

Luego en su controlador de vista,

  let deviceType = UIDevice.currentDevice().modelName if deviceType.lowercaseString.rangeOfString("iphone 4") != nil { print("iPhone 4 or iphone 4s") } else if deviceType.lowercaseString.rangeOfString("iphone 5") != nil { print("iPhone 5 or iphone 5s or iphone 5c") } else if deviceType.lowercaseString.rangeOfString("iphone 6") != nil { print("iPhone 6 Series") } 

Tratar con las estructuras c es doloroso a la ligera. Especialmente si tienen algún tipo de matrices c. Aquí está mi solución: Continuar usando object-c. Simplemente crea una clase Object-c del contenedor que hace este trabajo y luego usa esa clase rápidamente. Aquí hay una clase de muestra que hace exactamente esto:

 @interface DeviceInfo : NSObject + (NSString *)model; @end #import "DeviceInfo.h" #import  @implementation DeviceInfo + (NSString *)model { struct utsname systemInfo; uname(&systemInfo); return [NSString stringWithCString: systemInfo.machine encoding: NSUTF8StringEncoding]; } @end 

En el lado rápido:

 let deviceModel = DeviceInfo.model() 

En Swift 3.0, he descubierto esta solución para obtener el nombre modal del dispositivo.

 public 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))) } switch identifier { case "iPod5,1": return "iPod Touch 5" case "iPod7,1": return "iPod Touch 6" case "iPhone3,1", "iPhone3,2", "iPhone3,3": return "iPhone 4" case "iPhone4,1": return "iPhone 4s" case "iPhone5,1", "iPhone5,2": return "iPhone 5" case "iPhone5,3", "iPhone5,4": return "iPhone 5c" case "iPhone6,1", "iPhone6,2": return "iPhone 5s" case "iPhone7,2": return "iPhone 6" case "iPhone7,1": return "iPhone 6 Plus" case "iPhone8,1": return "iPhone 6s" case "iPhone8,2": return "iPhone 6s Plus" case "iPad2,1", "iPad2,2", "iPad2,3", "iPad2,4": return "iPad 2" case "iPad3,1", "iPad3,2", "iPad3,3": return "iPad 3" case "iPad3,4", "iPad3,5", "iPad3,6": return "iPad 4" case "iPad4,1", "iPad4,2", "iPad4,3": return "iPad Air" case "iPad5,3", "iPad5,4": return "iPad Air 2" case "iPad2,5", "iPad2,6", "iPad2,7": return "iPad Mini" case "iPad4,4", "iPad4,5", "iPad4,6": return "iPad Mini 2" case "iPad4,7", "iPad4,8", "iPad4,9": return "iPad Mini 3" case "iPad5,1", "iPad5,2": return "iPad Mini 4" case "iPad6,7", "iPad6,8": return "iPad Pro" case "AppleTV5,3": return "Apple TV" case "i386", "x86_64": return "Simulator" default: return identifier } } 

}

Usando esta extensión necesita escribir esto para obtener el nombre modal del dispositivo en swift 3.0.

 //Getting Device modal name let modelName = UIDevice.current.modelName print(modelName) 

Que esto te ayude Gracias.

Implementé una biblioteca súper liviana para detectar el dispositivo usado en función de algunas de las respuestas dadas: https://github.com/schickling/Device.swift

Se puede instalar a través de Cartago y se puede usar así:

 import Device let deviceType = UIDevice.currentDevice().deviceType switch deviceType { case .IPhone6: print("Do stuff for iPhone6") case .IPadMini: print("Do stuff for iPad mini") default: print("Check other available cases of DeviceType") } 

Descubrí que muchas de estas respuestas usan cadenas. Decidí cambiar la respuesta de @HAS para usar una enumeración:

 public enum Devices: String { case IPodTouch5 case IPodTouch6 case IPhone4 case IPhone4S case IPhone5 case IPhone5C case IPhone5S case IPhone6 case IPhone6Plus case IPhone6S case IPhone6SPlus case IPhone7 case IPhone7Plus case IPhoneSE case IPad2 case IPad3 case IPad4 case IPadAir case IPadAir2 case IPadMini case IPadMini2 case IPadMini3 case IPadMini4 case IPadPro case AppleTV case Simulator case Other } public extension UIDevice { public var modelName: Devices { 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))) } switch identifier { case "iPod5,1": return Devices.IPodTouch5 case "iPod7,1": return Devices.IPodTouch6 case "iPhone3,1", "iPhone3,2", "iPhone3,3": return Devices.IPhone4 case "iPhone4,1": return Devices.IPhone4S case "iPhone5,1", "iPhone5,2": return Devices.IPhone5 case "iPhone5,3", "iPhone5,4": return Devices.IPhone5C case "iPhone6,1", "iPhone6,2": return Devices.IPhone5S case "iPhone7,2": return Devices.IPhone6 case "iPhone7,1": return Devices.IPhone6Plus case "iPhone8,1": return Devices.IPhone6S case "iPhone8,2": return Devices.IPhone6SPlus case "iPhone9,1", "iPhone9,3": return Devices.IPhone7 case "iPhone9,2", "iPhone9,4": return Devices.IPhone7Plus case "iPhone8,4": return Devices.IPhoneSE case "iPad2,1", "iPad2,2", "iPad2,3", "iPad2,4":return Devices.IPad2 case "iPad3,1", "iPad3,2", "iPad3,3": return Devices.IPad3 case "iPad3,4", "iPad3,5", "iPad3,6": return Devices.IPad4 case "iPad4,1", "iPad4,2", "iPad4,3": return Devices.IPadAir case "iPad5,3", "iPad5,4": return Devices.IPadAir2 case "iPad2,5", "iPad2,6", "iPad2,7": return Devices.IPadMini case "iPad4,4", "iPad4,5", "iPad4,6": return Devices.IPadMini2 case "iPad4,7", "iPad4,8", "iPad4,9": return Devices.IPadMini3 case "iPad5,1", "iPad5,2": return Devices.IPadMini4 case "iPad6,3", "iPad6,4", "iPad6,7", "iPad6,8":return Devices.IPadPro case "AppleTV5,3": return Devices.AppleTV case "i386", "x86_64": return Devices.Simulator default: return Devices.Other } } } 

¡Hay algunos problemas con la respuesta aceptada cuando usa Swift 3! Esta respuesta (inspirada en NAZIK) funciona con Swift 3 y los nuevos modelos de iPhone:

 import UIKit public extension UIDevice { var modelName: String { #if (arch(i386) || arch(x86_64)) && os(iOS) let DEVICE_IS_SIMULATOR = true #else let DEVICE_IS_SIMULATOR = false #endif var machineString = String() if DEVICE_IS_SIMULATOR == true { if let dir = ProcessInfo().environment["SIMULATOR_MODEL_IDENTIFIER"] { machineString = dir } } else { var systemInfo = utsname() uname(&systemInfo) let machineMirror = Mirror(reflecting: systemInfo.machine) machineString = machineMirror.children.reduce("") { identifier, element in guard let value = element.value as? Int8 , value != 0 else { return identifier } return identifier + String(UnicodeScalar(UInt8(value))) } } switch machineString { case "iPod4,1": return "iPod Touch 4G" case "iPod5,1": return "iPod Touch 5G" case "iPod7,1": return "iPod Touch 6G" case "iPhone3,1", "iPhone3,2", "iPhone3,3": return "iPhone 4" case "iPhone4,1": return "iPhone 4s" case "iPhone5,1", "iPhone5,2": return "iPhone 5" case "iPhone5,3", "iPhone5,4": return "iPhone 5c" case "iPhone6,1", "iPhone6,2": return "iPhone 5s" case "iPhone7,2": return "iPhone 6" case "iPhone7,1": return "iPhone 6 Plus" case "iPhone8,1": return "iPhone 6s" case "iPhone8,2": return "iPhone 6s Plus" case "iPhone8,4": return "iPhone SE" case "iPhone9,1", "iPhone9,3": return "iPhone 7" case "iPhone9,2", "iPhone 9,4": return "iPhone 7 Plus" case "iPad2,1", "iPad2,2", "iPad2,3", "iPad2,4":return "iPad 2" case "iPad3,1", "iPad3,2", "iPad3,3": return "iPad 3" case "iPad3,4", "iPad3,5", "iPad3,6": return "iPad 4" case "iPad4,1", "iPad4,2", "iPad4,3": return "iPad Air" case "iPad5,3", "iPad5,4": return "iPad Air 2" case "iPad2,5", "iPad2,6", "iPad2,7": return "iPad Mini" case "iPad4,4", "iPad4,5", "iPad4,6": return "iPad Mini 2" case "iPad4,7", "iPad4,8", "iPad4,9": return "iPad Mini 3" case "iPad5,1", "iPad5,2": return "iPad Mini 4" case "iPad6,3", "iPad6,4": return "iPad Pro (9.7 inch)" case "iPad6,7", "iPad6,8": return "iPad Pro (12.9 inch)" case "AppleTV5,3": return "Apple TV" default: return machineString } } } 

He hecho otra extensión de muestra en UIDevice para incluir la base del identificador del modelo del simulador en la respuesta de @ HAS:

 public extension UIDevice { /// pares the deveice name as the standard name var modelName: String { #if (arch(i386) || arch(x86_64)) && os(iOS) let identifier = ProcessInfo().environment["SIMULATOR_MODEL_IDENTIFIER"]! #else 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))) } #endif switch identifier { case "iPod5,1": return "iPod Touch 5" case "iPod7,1": return "iPod Touch 6" case "iPhone3,1", "iPhone3,2", "iPhone3,3": return "iPhone 4" case "iPhone4,1": return "iPhone 4s" case "iPhone5,1", "iPhone5,2": return "iPhone 5" case "iPhone5,3", "iPhone5,4": return "iPhone 5c" case "iPhone6,1", "iPhone6,2": return "iPhone 5s" case "iPhone7,2": return "iPhone 6" case "iPhone7,1": return "iPhone 6 Plus" case "iPhone8,1": return "iPhone 6s" case "iPhone8,2": return "iPhone 6s Plus" case "iPhone9,1", "iPhone9,3": return "iPhone 7" case "iPhone9,2", "iPhone9,4": return "iPhone 7 Plus" case "iPhone8,4": return "iPhone SE" case "iPhone10,1", "iPhone10,4": return "iPhone 8" case "iPhone10,2", "iPhone10,5": return "iPhone 8 Plus" case "iPhone10,3", "iPhone10,6": return "iPhone X" case "iPad2,1", "iPad2,2", "iPad2,3", "iPad2,4":return "iPad 2" case "iPad3,1", "iPad3,2", "iPad3,3": return "iPad 3" case "iPad3,4", "iPad3,5", "iPad3,6": return "iPad 4" case "iPad4,1", "iPad4,2", "iPad4,3": return "iPad Air" case "iPad5,3", "iPad5,4": return "iPad Air 2" case "iPad6,11", "iPad6,12": return "iPad 5" case "iPad2,5", "iPad2,6", "iPad2,7": return "iPad Mini" case "iPad4,4", "iPad4,5", "iPad4,6": return "iPad Mini 2" case "iPad4,7", "iPad4,8", "iPad4,9": return "iPad Mini 3" case "iPad5,1", "iPad5,2": return "iPad Mini 4" case "iPad6,3", "iPad6,4": return "iPad Pro 9.7 Inch" case "iPad6,7", "iPad6,8": return "iPad Pro 12.9 Inch" case "iPad7,1", "iPad7,2": return "iPad Pro 12.9 Inch 2. Generation" case "iPad7,3", "iPad7,4": return "iPad Pro 10.5 Inch" case "AppleTV5,3": return "Apple TV" case "AppleTV6,2": return "Apple TV 4K" case "AudioAccessory1,1": return "HomePod" default: return identifier } } } 

Swift 4.1 version:

 public extension UIDevice { /// pares the deveice name as the standard name var modelName: String { #if targetEnvironment(simulator) let identifier = ProcessInfo().environment["SIMULATOR_MODEL_IDENTIFIER"]! #else 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))) } #endif switch identifier { case "iPod5,1": return "iPod Touch 5" case "iPod7,1": return "iPod Touch 6" case "iPhone3,1", "iPhone3,2", "iPhone3,3": return "iPhone 4" case "iPhone4,1": return "iPhone 4s" case "iPhone5,1", "iPhone5,2": return "iPhone 5" case "iPhone5,3", "iPhone5,4": return "iPhone 5c" case "iPhone6,1", "iPhone6,2": return "iPhone 5s" case "iPhone7,2": return "iPhone 6" case "iPhone7,1": return "iPhone 6 Plus" case "iPhone8,1": return "iPhone 6s" case "iPhone8,2": return "iPhone 6s Plus" case "iPhone9,1", "iPhone9,3": return "iPhone 7" case "iPhone9,2", "iPhone9,4": return "iPhone 7 Plus" case "iPhone8,4": return "iPhone SE" case "iPhone10,1", "iPhone10,4": return "iPhone 8" case "iPhone10,2", "iPhone10,5": return "iPhone 8 Plus" case "iPhone10,3", "iPhone10,6": return "iPhone X" case "iPad2,1", "iPad2,2", "iPad2,3", "iPad2,4":return "iPad 2" case "iPad3,1", "iPad3,2", "iPad3,3": return "iPad 3" case "iPad3,4", "iPad3,5", "iPad3,6": return "iPad 4" case "iPad4,1", "iPad4,2", "iPad4,3": return "iPad Air" case "iPad5,3", "iPad5,4": return "iPad Air 2" case "iPad6,11", "iPad6,12": return "iPad 5" case "iPad2,5", "iPad2,6", "iPad2,7": return "iPad Mini" case "iPad4,4", "iPad4,5", "iPad4,6": return "iPad Mini 2" case "iPad4,7", "iPad4,8", "iPad4,9": return "iPad Mini 3" case "iPad5,1", "iPad5,2": return "iPad Mini 4" case "iPad6,3", "iPad6,4": return "iPad Pro 9.7 Inch" case "iPad6,7", "iPad6,8": return "iPad Pro 12.9 Inch" case "iPad7,1", "iPad7,2": return "iPad Pro 12.9 Inch 2. Generation" case "iPad7,3", "iPad7,4": return "iPad Pro 10.5 Inch" case "AppleTV5,3": return "Apple TV" case "AppleTV6,2": return "Apple TV 4K" case "AudioAccessory1,1": return "HomePod" default: return identifier } } } 

It’s working fine with Swift3.2 above:

 let modelName = UIDevice.current.modelName 
 var platform: String? { var systemInfo = utsname() uname(&systemInfo) return withUnsafeMutablePointer(&systemInfo.machine) { ptr in String.fromCString(UnsafePointer(ptr)) } } 

Using Swift 3 (Xcode 8.3)

  func deviceName() -> String { var systemInfo = utsname() uname(&systemInfo) let str = withUnsafePointer(to: &systemInfo.machine.0) { ptr in return String(cString: ptr) } return str } 

Note: According to official dev forum answer, it is safe to use tuples in this way. Memory alignment for the big Int8 tuple will be the same as if it were a big Int8 array. ie: contiguous and not-padded.

In Swift 3 it’d be

  UIDevice.current.model 

Here an modification without force unwrap and Swift 3.0:

 import Foundation import UIKit public enum Model : String { case simulator = "simulator/sandbox", iPod1 = "iPod 1", iPod2 = "iPod 2", iPod3 = "iPod 3", iPod4 = "iPod 4", iPod5 = "iPod 5", iPad2 = "iPad 2", iPad3 = "iPad 3", iPad4 = "iPad 4", iPhone4 = "iPhone 4", iPhone4S = "iPhone 4S", iPhone5 = "iPhone 5", iPhone5S = "iPhone 5S", iPhone5C = "iPhone 5C", iPadMini1 = "iPad Mini 1", iPadMini2 = "iPad Mini 2", iPadMini3 = "iPad Mini 3", iPadAir1 = "iPad Air 1", iPadAir2 = "iPad Air 2", iPhone6 = "iPhone 6", iPhone6plus = "iPhone 6 Plus", iPhone6S = "iPhone 6S", iPhone6Splus = "iPhone 6S Plus", iPhoneSE = "iPhone SE", iPhone7 = "iPhone 7", iPhone7plus = "iPhone 7 Plus", unrecognized = "?unrecognized?" } public extension UIDevice { public var type: Model { var systemInfo = utsname() uname(&systemInfo) let modelCode = withUnsafePointer(to: &systemInfo.machine) { $0.withMemoryRebound(to: CChar.self, capacity: 1) { ptr in String.init(validatingUTF8: ptr) } } var modelMap : [ String : Model ] = [ "i386" : .simulator, "x86_64" : .simulator, "iPod1,1" : .iPod1, "iPod2,1" : .iPod2, "iPod3,1" : .iPod3, "iPod4,1" : .iPod4, "iPod5,1" : .iPod5, "iPad2,1" : .iPad2, "iPad2,2" : .iPad2, "iPad2,3" : .iPad2, "iPad2,4" : .iPad2, "iPad2,5" : .iPadMini1, "iPad2,6" : .iPadMini1, "iPad2,7" : .iPadMini1, "iPhone3,1" : .iPhone4, "iPhone3,2" : .iPhone4, "iPhone3,3" : .iPhone4, "iPhone4,1" : .iPhone4S, "iPhone5,1" : .iPhone5, "iPhone5,2" : .iPhone5, "iPhone5,3" : .iPhone5C, "iPhone5,4" : .iPhone5C, "iPad3,1" : .iPad3, "iPad3,2" : .iPad3, "iPad3,3" : .iPad3, "iPad3,4" : .iPad4, "iPad3,5" : .iPad4, "iPad3,6" : .iPad4, "iPhone6,1" : .iPhone5S, "iPhone6,2" : .iPhone5S, "iPad4,1" : .iPadAir1, "iPad4,2" : .iPadAir2, "iPad4,4" : .iPadMini2, "iPad4,5" : .iPadMini2, "iPad4,6" : .iPadMini2, "iPad4,7" : .iPadMini3, "iPad4,8" : .iPadMini3, "iPad4,9" : .iPadMini3, "iPhone7,1" : .iPhone6plus, "iPhone7,2" : .iPhone6, "iPhone8,1" : .iPhone6S, "iPhone8,2" : .iPhone6Splus, "iPhone8,4" : .iPhoneSE, "iPhone9,1" : .iPhone7, "iPhone9,2" : .iPhone7plus, "iPhone9,3" : .iPhone7, "iPhone9,4" : .iPhone7plus, ] guard let safeModelCode = modelCode else { return Model.unrecognized } guard let modelString = String.init(validatingUTF8: safeModelCode) else { return Model.unrecognized } guard let model = modelMap[modelString] else { return Model.unrecognized } return model } } 

Swift 3.0 or higher

 import UIKit class ViewController: UIViewController { let device = UIDevice.current override func viewDidLoad() { super.viewDidLoad() let model = device.model print(model) // eg "iPhone" let modelName = device.modelName print(modelName) // eg "iPhone 6" /* see the extension */ let deviceName = device.name print(deviceName) // eg "My iPhone" let systemName = device.systemName print(systemName) // eg "iOS" let systemVersion = device.systemVersion print(systemVersion) // eg "10.3.2" if let identifierForVendor = device.identifierForVendor { print(identifierForVendor) // eg "E1X2XX34-5X6X-7890-123X-XXX456C78901" } } } 

and add the following extension

 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))) } switch identifier { case "iPod5,1": return "iPod Touch 5" case "iPod7,1": return "iPod Touch 6" case "iPhone3,1", "iPhone3,2", "iPhone3,3": return "iPhone 4" case "iPhone4,1": return "iPhone 4s" case "iPhone5,1", "iPhone5,2": return "iPhone 5" case "iPhone5,3", "iPhone5,4": return "iPhone 5c" case "iPhone6,1", "iPhone6,2": return "iPhone 5s" case "iPhone7,2": return "iPhone 6" case "iPhone7,1": return "iPhone 6 Plus" case "iPhone8,1": return "iPhone 6s" case "iPhone8,2": return "iPhone 6s Plus" case "iPhone9,1", "iPhone9,3": return "iPhone 7" case "iPhone9,2", "iPhone9,4": return "iPhone 7 Plus" case "iPhone8,4": return "iPhone SE" case "iPad2,1", "iPad2,2", "iPad2,3", "iPad2,4":return "iPad 2" case "iPad3,1", "iPad3,2", "iPad3,3": return "iPad 3" case "iPad3,4", "iPad3,5", "iPad3,6": return "iPad 4" case "iPad4,1", "iPad4,2", "iPad4,3": return "iPad Air" case "iPad5,3", "iPad5,4": return "iPad Air 2" case "iPad6,11", "iPad6,12": return "iPad 5" case "iPad2,5", "iPad2,6", "iPad2,7": return "iPad Mini" case "iPad4,4", "iPad4,5", "iPad4,6": return "iPad Mini 2" case "iPad4,7", "iPad4,8", "iPad4,9": return "iPad Mini 3" case "iPad5,1", "iPad5,2": return "iPad Mini 4" case "iPad6,3", "iPad6,4": return "iPad Pro 9.7 Inch" case "iPad6,7", "iPad6,8": return "iPad Pro 12.9 Inch" case "iPad7,1", "iPad7,2": return "iPad Pro 12.9 Inch 2. Generation" case "iPad7,3", "iPad7,4": return "iPad Pro 10.5 Inch" case "AppleTV5,3": return "Apple TV" case "i386", "x86_64": return "Simulator" default: return identifier } } } 

Below is the code for getting the hardware string, but you need to compare these hardware string to know which device it is. I have created a class for that contains almost all the device strings(we’re keeping string upto date with new devices). It’s easy to use please check

Swift : GitHub/DeviceGuru

Objective-C : GitHub/DeviceUtil

 public func hardwareString() -> String { var name: [Int32] = [CTL_HW, HW_MACHINE] var size: Int = 2 sysctl(&name, 2, nil, &size, &name, 0) var hw_machine = [CChar](count: Int(size), repeatedValue: 0) sysctl(&name, 2, &hw_machine, &size, &name, 0) let hardware: String = String.fromCString(hw_machine)! return hardware } 

SWIFT 3.1

my two cents for simply calling utsname:

  func platform() -> String { var systemInfo = utsname() uname(&systemInfo) let size = Int(_SYS_NAMELEN) // is 32, but posix AND its init is 256.... let s = withUnsafeMutablePointer(to: &systemInfo.machine) {p in p.withMemoryRebound(to: CChar.self, capacity: size, {p2 in return String(cString: p2) }) } return s } 

as other did, but a bit cleaner about all the intricacy of C/Swift and back. )

Returns values such as “x86_64”

My simple solution grouped by device and support new devices iPhone 8 and iPhone X in Swift 3 :

 public 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))) } switch identifier { case "iPhone3,1", "iPhone3,2", "iPhone3,3", "iPhone4,1": return "iPhone 4" case "iPhone5,1", "iPhone5,2", "iPhone5,3", "iPhone5,4", "iPhone6,1", "iPhone6,2", "iPhone8,4": return "iPhone 5" case "iPhone7,2", "iPhone8,1", "iPhone9,1", "iPhone9,3", "iPhone10,1", "iPhone10,4": return "iPhone 6,7,8" case "iPhone7,1", "iPhone8,2", "iPhone9,2", "iPhone9,4", "iPhone10,2", "iPhone10,5": return "iPhone Plus" case "iPhone10,3", "iPhone10,6": return "iPhone X" case "i386", "x86_64": return "Simulator" default: return identifier } } } 

Y use:

 switch UIDevice.current.modelName { case "iPhone 4": case "iPhone 5": case "iPhone 6,7,8": case "iPhone Plus": case "iPhone X": case "Simulator": default: } 

If you do not want to keep updating your code everytime Apple adds a new model to a device family, use the method below returning you the model code only.

 func platform() -> String { var systemInfo = utsname() uname(&systemInfo) let modelCode = withUnsafeMutablePointer(&systemInfo.machine) { ptr in String.fromCString(UnsafePointer(ptr)) } return String.fromCString(modelCode!)! } 
 extension UIDevice { public static let hardwareModel: String = { var path = [CTL_HW, HW_MACHINE] var n = 0 sysctl(&path, 2, nil, &n, nil, 0) var a: [UInt8] = .init(repeating: 0, count: n) sysctl(&path, 2, &a, &n, nil, 0) return .init(cString: a) }() } UIDevice.hardwareModel // → iPhone9,3 

Using a Swift ‘switch-case’:

 func platformString() -> String { var devSpec: String switch platform() { case "iPhone1,2": devSpec = "iPhone 3G" case "iPhone2,1": devSpec = "iPhone 3GS" case "iPhone3,1": devSpec = "iPhone 4" case "iPhone3,3": devSpec = "Verizon iPhone 4" case "iPhone4,1": devSpec = "iPhone 4S" case "iPhone5,1": devSpec = "iPhone 5 (GSM)" case "iPhone5,2": devSpec = "iPhone 5 (GSM+CDMA)" case "iPhone5,3": devSpec = "iPhone 5c (GSM)" case "iPhone5,4": devSpec = "iPhone 5c (GSM+CDMA)" case "iPhone6,1": devSpec = "iPhone 5s (GSM)" case "iPhone6,2": devSpec = "iPhone 5s (GSM+CDMA)" case "iPhone7,1": devSpec = "iPhone 6 Plus" case "iPhone7,2": devSpec = "iPhone 6" case "iPod1,1": devSpec = "iPod Touch 1G" case "iPod2,1": devSpec = "iPod Touch 2G" case "iPod3,1": devSpec = "iPod Touch 3G" case "iPod4,1": devSpec = "iPod Touch 4G" case "iPod5,1": devSpec = "iPod Touch 5G" case "iPad1,1": devSpec = "iPad" case "iPad2,1": devSpec = "iPad 2 (WiFi)" case "iPad2,2": devSpec = "iPad 2 (GSM)" case "iPad2,3": devSpec = "iPad 2 (CDMA)" case "iPad2,4": devSpec = "iPad 2 (WiFi)" case "iPad2,5": devSpec = "iPad Mini (WiFi)" case "iPad2,6": devSpec = "iPad Mini (GSM)" case "iPad2,7": devSpec = "iPad Mini (GSM+CDMA)" case "iPad3,1": devSpec = "iPad 3 (WiFi)" case "iPad3,2": devSpec = "iPad 3 (GSM+CDMA)" case "iPad3,3": devSpec = "iPad 3 (GSM)" case "iPad3,4": devSpec = "iPad 4 (WiFi)" case "iPad3,5": devSpec = "iPad 4 (GSM)" case "iPad3,6": devSpec = "iPad 4 (GSM+CDMA)" case "iPad4,1": devSpec = "iPad Air (WiFi)" case "iPad4,2": devSpec = "iPad Air (Cellular)" case "iPad4,4": devSpec = "iPad mini 2G (WiFi)" case "iPad4,5": devSpec = "iPad mini 2G (Cellular)" case "iPad4,7": devSpec = "iPad mini 3 (WiFi)" case "iPad4,8": devSpec = "iPad mini 3 (Cellular)" case "iPad4,9": devSpec = "iPad mini 3 (China Model)" case "iPad5,3": devSpec = "iPad Air 2 (WiFi)" case "iPad5,4": devSpec = "iPad Air 2 (Cellular)" case "i386": devSpec = "Simulator" case "x86_64": devSpec = "Simulator" default: devSpec = "Unknown" } return devSpec } 

Based on this answer and this answer . I’ve created a public gist

How it can be used

 let boolean: Bool = UIDevice.isDevice(ofType: .iPhoneX) // true or false let specificDevice: DeviceModel.Model = UIDevice.modelType // iPhone6s, iPhoneX, iPad etc... let model: DeviceModel = UIDevice.model // .simulator(let specificDevice), .real(let specificDevice), // .unrecognizedSimulator(let string), .unrecognized(let string) let modelName: String = UIDevice.model.name // iPhone 6, iPhone X, etc... 

This is the code inside the gist

 public extension UIDevice { public static var modelCode: String { if let simulatorModelIdentifier = ProcessInfo().environment["SIMULATOR_MODEL_IDENTIFIER"] { return simulatorModelIdentifier } var systemInfo = utsname() uname(&systemInfo) return withUnsafeMutablePointer(to: &systemInfo.machine) { ptr in String(cString: UnsafeRawPointer(ptr).assumingMemoryBound(to: CChar.self)) } } public static var model: DeviceModel { // Thanks https://stackoverflow.com/a/26962452/5928180 var systemInfo = utsname() uname(&systemInfo) let modelCode = withUnsafeMutablePointer(to: &systemInfo.machine) { ptr in String(cString: UnsafeRawPointer(ptr).assumingMemoryBound(to: CChar.self)) } // Thanks https://stackoverflow.com/a/33495869/5928180 if modelCode == "i386" || modelCode == "x86_64" { if let simulatorModelCode = ProcessInfo().environment["SIMULATOR_MODEL_IDENTIFIER"], let model = DeviceModel.Model(modelCode: simulatorModelCode) { return DeviceModel.simulator(model) } else if let simulatorModelCode = ProcessInfo().environment["SIMULATOR_MODEL_IDENTIFIER"] { return DeviceModel.unrecognizedSimulator(simulatorModelCode) } else { return DeviceModel.unrecognized(modelCode) } } else if let model = DeviceModel.Model(modelCode: modelCode) { return DeviceModel.real(model) } else { return DeviceModel.unrecognized(modelCode) } } public static var modelType: DeviceModel.Model? { return UIDevice.model.model } public static func isDevice(ofType model: DeviceModel.Model) -> Bool { return UIDevice.modelType == model } } public enum DeviceModel { case simulator(Model) case unrecognizedSimulator(String) case real(Model) case unrecognized(String) public enum Model: String { case iPod1 = "iPod 1" case iPod2 = "iPod 2" case iPod3 = "iPod 3" case iPod4 = "iPod 4" case iPod5 = "iPod 5" case iPad2 = "iPad 2" case iPad3 = "iPad 3" case iPad4 = "iPad 4" case iPhone4 = "iPhone 4" case iPhone4S = "iPhone 4S" case iPhone5 = "iPhone 5" case iPhone5S = "iPhone 5S" case iPhone5C = "iPhone 5C" case iPadMini1 = "iPad Mini 1" case iPadMini2 = "iPad Mini 2" case iPadMini3 = "iPad Mini 3" case iPadAir1 = "iPad Air 1" case iPadAir2 = "iPad Air 2" case iPadPro9_7 = "iPad Pro 9.7\"" case iPadPro9_7_cell = "iPad Pro 9.7\" cellular" case iPadPro10_5 = "iPad Pro 10.5\"" case iPadPro10_5_cell = "iPad Pro 10.5\" cellular" case iPadPro12_9 = "iPad Pro 12.9\"" case iPadPro12_9_cell = "iPad Pro 12.9\" cellular" case iPhone6 = "iPhone 6" case iPhone6plus = "iPhone 6 Plus" case iPhone6S = "iPhone 6S" case iPhone6Splus = "iPhone 6S Plus" case iPhoneSE = "iPhone SE" case iPhone7 = "iPhone 7" case iPhone7plus = "iPhone 7 Plus" case iPhone8 = "iPhone 8" case iPhone8plus = "iPhone 8 Plus" case iPhoneX = "iPhone X" init?(modelCode: String) { switch modelCode { case "iPod1,1": self = .iPod1 case "iPod2,1": self = .iPod2 case "iPod3,1": self = .iPod3 case "iPod4,1": self = .iPod4 case "iPod5,1": self = .iPod5 case "iPad2,1": self = .iPad2 case "iPad2,2": self = .iPad2 case "iPad2,3": self = .iPad2 case "iPad2,4": self = .iPad2 case "iPad2,5": self = .iPadMini1 case "iPad2,6": self = .iPadMini1 case "iPad2,7": self = .iPadMini1 case "iPhone3,1": self = .iPhone4 case "iPhone3,2": self = .iPhone4 case "iPhone3,3": self = .iPhone4 case "iPhone4,1": self = .iPhone4S case "iPhone5,1": self = .iPhone5 case "iPhone5,2": self = .iPhone5 case "iPhone5,3": self = .iPhone5C case "iPhone5,4": self = .iPhone5C case "iPad3,1": self = .iPad3 case "iPad3,2": self = .iPad3 case "iPad3,3": self = .iPad3 case "iPad3,4": self = .iPad4 case "iPad3,5": self = .iPad4 case "iPad3,6": self = .iPad4 case "iPhone6,1": self = .iPhone5S case "iPhone6,2": self = .iPhone5S case "iPad4,1": self = .iPadAir1 case "iPad4,2": self = .iPadAir2 case "iPad4,4": self = .iPadMini2 case "iPad4,5": self = .iPadMini2 case "iPad4,6": self = .iPadMini2 case "iPad4,7": self = .iPadMini3 case "iPad4,8": self = .iPadMini3 case "iPad4,9": self = .iPadMini3 case "iPad6,3": self = .iPadPro9_7 case "iPad6,11": self = .iPadPro9_7 case "iPad6,4": self = .iPadPro9_7_cell case "iPad6,12": self = .iPadPro9_7_cell case "iPad6,7": self = .iPadPro12_9 case "iPad6,8": self = .iPadPro12_9_cell case "iPad7,3": self = .iPadPro10_5 case "iPad7,4": self = .iPadPro10_5_cell case "iPhone7,1": self = .iPhone6plus case "iPhone7,2": self = .iPhone6 case "iPhone8,1": self = .iPhone6S case "iPhone8,2": self = .iPhone6Splus case "iPhone8,4": self = .iPhoneSE case "iPhone9,1": self = .iPhone7 case "iPhone9,2": self = .iPhone7plus case "iPhone9,3": self = .iPhone7 case "iPhone9,4": self = .iPhone7plus case "iPhone10,1": self = .iPhone8 case "iPhone10,2": self = .iPhone8plus case "iPhone10,3": self = .iPhoneX case "iPhone10,6": self = .iPhoneX default: return nil } } } public var name: String { switch self { case .simulator(let model): return "Simulator[\(model.rawValue)]" case .unrecognizedSimulator(let s): return "UnrecognizedSimulator[\(s)]" case .real(let model): return model.rawValue case .unrecognized(let s): return "Unrecognized[\(s)]" } } public var model: DeviceModel.Model? { switch self { case .simulator(let model): return model case .real(let model): return model case .unrecognizedSimulator(_): return nil case .unrecognized(_): return nil } } } 

Simple Way to get device name with one line of code

 let name = ProcessInfo.init().environment["SIMULATOR_DEVICE_NAME"] ?? "NoN" print("My device name is: ", name) 

Result for iPhone X simulator -> My device name is: iPhone X

Result in Xcode 9.3.1 playground -> My device name is: iPad Pro (9.7-inch)

You can use BDLocalizedDevicesModels framework to parse device info and get the name.

Then just call UIDevice.currentDevice.productName in your code.

 struct utsname systemInfo; uname(&systemInfo); NSString* deviceModel = [NSString stringWithCString:systemInfo.machine encoding:NSUTF8StringEncoding]; 
 struct DeviceType { static let IS_IPHONE_4_OR_LESS = UIDevice.current.userInterfaceIdiom == .phone && Constants.SCREEN_MAX_LENGTH < 568 static let IS_IPHONE_5 = UIDevice.current.userInterfaceIdiom == .phone && Constants.SCREEN_MAX_LENGTH == 568 static let IS_IPHONE_6 = UIDevice.current.userInterfaceIdiom == .phone && Constants.SCREEN_MAX_LENGTH == 667 static let IS_IPHONE_6P = UIDevice.current.userInterfaceIdiom == .phone && Constants.SCREEN_MAX_LENGTH == 736 static let IS_IPAD = UIDevice.current.userInterfaceIdiom == .pad && Constants.SCREEN_MAX_LENGTH == 1024 }