ios - descargar - Detecta el dispositivo actual con UI_USER_INTERFACE_IDIOM() en Swift

descargar swift para windows

Question

¿Cuál es el equivalente de UI_USER_INTERFACE_IDIOM() en Swift para detectar entre iPhone y iPad?

Obtengo un error Use of unresolved identifier al compilar en Swift.

Answer 1

Cuando trabaje con Swift, puede usar la enum UIUserInterfaceIdiom , definida como:

enum UIUserInterfaceIdiom : Int {
case unspecified
case phone // iPhone and iPod touch style UI
case pad // iPad style UI
}

Así que puedes usarlo como:

UIDevice.current.userInterfaceIdiom == .pad
UIDevice.current.userInterfaceIdiom == .phone
UIDevice.current.userInterfaceIdiom == .unspecified

O con una instrucción Switch:

 switch UIDevice.current.userInterfaceIdiom {
case .phone:
// It''s an iPhone
case .pad:
// It''s an iPad
case .unspecified:
// Uh, oh! What could it be?
}

UI_USER_INTERFACE_IDIOM() es una macro Objective-C, que se define como:

#define UI_USER_INTERFACE_IDIOM() / ([[UIDevice currentDevice] respondsToSelector:@selector(userInterfaceIdiom)] ? / [[UIDevice currentDevice] userInterfaceIdiom] : / UIUserInterfaceIdiomPhone)

Además, tenga en cuenta que incluso cuando se trabaja con Objective-C, la macro UI_USER_INTERFACE_IDIOM() solo es necesaria cuando se dirige a iOS 3.2 y versiones posteriores. Cuando se implementa en iOS 3.2 y superior, puede usar [UIDevice userInterfaceIdiom] directamente.

Answer 2

En swift 4 y Xcode 9.2, puede detectar si un dispositivo es iPhone / iPad de las siguientes maneras.

if (UIDevice.current.userInterfaceIdiom == .pad){
print("iPad")
}
else{
print("iPhone")
}

De otra manera

 let deviceName = UIDevice.current.model
print(deviceName);
if deviceName == "iPhone"{
print("iPhone")
}
else{
print("iPad")
}

Answer 3

Hay una forma muy simple de al menos determinar si el usuario usa un iPad o un iPhone usando el siguiente código (Swift 3):

Para un iPhone:

UIDevice.currentDeviceIsIPhone()

Para un iPad:

UIDevice.currentDeviceIsIPad()

Nota: estos métodos no detectarán un dispositivo iPad si la aplicación se ejecuta en un iPad con una pantalla de iPhone.

Answer 4

Intenta agregar una extensión como esta:

 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 where 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 "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", "iPad6,7", "iPad6,8":return "iPad Pro"
case "AppleTV5,3": return "Apple TV"
case "i386", "x86_64": return "Simulator"
default: return identifier
}
}
}

Así es como lo usarás:

let modelName = UIDevice.currentDevice().modelName

EDITAR Para simulador, puedes probar una solución here

Answer 5

Para su información, he utilizado UI_USER_INTERFACE_IDIOM() para mi aplicación escrita en Swift. La aplicación se puede compilar bien con XCode 6.3.1 sin ninguna advertencia en ese comando, funciona bien en Simulator (con cualquier dispositivo seleccionado) y en todos mis dispositivos reales (iPhone, iPad) con versiones de iOS de 7.1 a 8.3.

Sin embargo, la aplicación se bloqueó en los dispositivos de los revisores de Apple (y fue rechazada). Eso me tomó unos días para detectar el problema con algunas recargas más a iTunes Connect.

Ahora uso UIDevice.currentDevice().userInterfaceIdiom en UIDevice.currentDevice().userInterfaceIdiom lugar y mi aplicación puede sobrevivir a tales bloqueos.

Answer 6

Realicé un par de adiciones a las respuestas anteriores para que obtengas un tipo en lugar de un valor de cadena.

Pensé que esto se usaría principalmente para los ajustes de la interfaz de usuario, por lo que no me pareció relevante incluir todos los modelos secundarios, es decir, iPhone 5s, pero esto podría extenderse fácilmente agregando pruebas de modelos a la matriz de dispositivos de dispositivos.

Probado trabajando en Swift 3.1 Xcode 8.3.2 con dispositivos físicos y simuladores

Implementación:

UIDevice.whichDevice()

public enum SVNDevice {
case isiPhone4, isIphone5, isIphone6or7, isIphone6por7p, isIphone, isIpad, isIpadPro
}
extension UIDevice {
class func whichDevice() -> SVNDevice? {
let isDevice = { (comparision: Array<(Bool, SVNDevice)>) -> SVNDevice? in
var device: SVNDevice?
comparision.forEach({
device = $0.0 ? $0.1 : device
})
return device
}
return isDevice([
(UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH < 568.0, SVNDevice.isiPhone4),
(UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH == 568.0, SVNDevice.isIphone5),
(UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH == 667.0, SVNDevice.isIphone6or7),
(UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH == 736.0, SVNDevice.isIphone6por7p),
(UIDevice.current.userInterfaceIdiom == .pad && ScreenSize.SCREEN_MAX_LENGTH == 1024.0, SVNDevice.isIpad),
(UIDevice.current.userInterfaceIdiom == .pad && ScreenSize.SCREEN_MAX_LENGTH == 1366.0, SVNDevice.isIpadPro)])
}
}
private struct ScreenSize {
static let SCREEN_WIDTH = UIScreen.main.bounds.size.width
static let SCREEN_HEIGHT = UIScreen.main.bounds.size.height
static let SCREEN_MAX_LENGTH = max(ScreenSize.SCREEN_WIDTH, ScreenSize.SCREEN_HEIGHT)
static let SCREEN_MIN_LENGTH = min(ScreenSize.SCREEN_WIDTH, ScreenSize.SCREEN_HEIGHT)
}

He creado un marco denominado SVNBootstaper que incluye este y algunos otros protocolos de ayuda, es público y está disponible a través de Carthage.

Answer 7

Si desea verificar el dispositivo actual, ya sea su iPad o iPhone, puede usar esta línea de código:

 if(UIDevice.currentDevice().userInterfaceIdiom == .Pad){
}else if(UIDevice.currentDevice().userInterfaceIdiom == .Phone){
}

Answer 8

Yo lo hago de esa manera:

UIDevice.current.model

Muestra el nombre del dispositivo.

Para comprobar si es iPad o iPhone:

if ( UIDevice.current.model.range(of: "iPad") != nil){
print("I AM IPAD")
} else {
print("I AM IPHONE")
}

Answer 9

si / else caso:

 if (UIDevice.currentDevice().userInterfaceIdiom == UIUserInterfaceIdiom.Pad)
{
// Ipad
}
else
{
// Iphone
}

Answer 10

Debe utilizar este marco GBDeviceInfo o ...

Apple define esto:

public enum UIUserInterfaceIdiom : Int {
case unspecified
case phone // iPhone and iPod touch style UI
case pad // iPad style UI
@available(iOS 9.0, *)
case tv // Apple TV style UI
@available(iOS 9.0, *)
case carPlay // CarPlay style UI
}

Así que para la definición estricta del dispositivo se puede utilizar este código.

struct ScreenSize
{
static let SCREEN_WIDTH = UIScreen.main.bounds.size.width
static let SCREEN_HEIGHT = UIScreen.main.bounds.size.height
static let SCREEN_MAX_LENGTH = max(ScreenSize.SCREEN_WIDTH, ScreenSize.SCREEN_HEIGHT)
static let SCREEN_MIN_LENGTH = min(ScreenSize.SCREEN_WIDTH, ScreenSize.SCREEN_HEIGHT)
}
struct DeviceType
{
static let IS_IPHONE_4_OR_LESS = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH < 568.0
static let IS_IPHONE_5 = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH == 568.0
static let IS_IPHONE_6_7 = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH == 667.0
static let IS_IPHONE_6P_7P = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH == 736.0
static let IS_IPAD = UIDevice.current.userInterfaceIdiom == .pad && ScreenSize.SCREEN_MAX_LENGTH == 1024.0
static let IS_IPAD_PRO = UIDevice.current.userInterfaceIdiom == .pad && ScreenSize.SCREEN_MAX_LENGTH == 1366.0
}

cómo utilizar

if DeviceType.IS_IPHONE_6P_7P {
print("IS_IPHONE_6P_7P")
}

para detectar la versión de iOS

struct Version{
static let SYS_VERSION_FLOAT = (UIDevice.current.systemVersion as NSString).floatValue
static let iOS7 = (Version.SYS_VERSION_FLOAT < 8.0 && Version.SYS_VERSION_FLOAT >= 7.0)
static let iOS8 = (Version.SYS_VERSION_FLOAT >= 8.0 && Version.SYS_VERSION_FLOAT < 9.0)
static let iOS9 = (Version.SYS_VERSION_FLOAT >= 9.0 && Version.SYS_VERSION_FLOAT < 10.0)
}

cómo utilizar

if Version.iOS8 {
print("iOS8")
}

Answer 11

Swift 2.0 y iOS 7+ / iOS 8+ / iOS 9+

public class Helper {
public class var isIpad:Bool {
if #available(iOS 8.0, *) {
return UIScreen.mainScreen().traitCollection.userInterfaceIdiom == .Pad
} else {
return UIDevice.currentDevice().userInterfaceIdiom == .Pad
}
}
public class var isIphone:Bool {
if #available(iOS 8.0, *) {
return UIScreen.mainScreen().traitCollection.userInterfaceIdiom == .Phone
} else {
return UIDevice.currentDevice().userInterfaceIdiom == .Phone
}
}
}

Utilizar :

if Helper.isIpad {
}

O

guard Helper.isIpad else {
return
} 

Gracias @ usuario3378170

Answer 12

Swift 2.0 y iOS 9 y Xcode 7.1

// 1. request an UITraitCollection instance
let deviceIdiom = UIScreen.mainScreen().traitCollection.userInterfaceIdiom
// 2. check the idiom
switch (deviceIdiom) {
case .Pad:
print("iPad style UI")
case .Phone:
print("iPhone and iPod touch style UI")
case .TV:
print("tvOS style UI")
default:
print("Unspecified UI idiom")
}

Swift 3.0

// 1. request an UITraitCollection instance
let deviceIdiom = UIScreen.main.traitCollection.userInterfaceIdiom
// 2. check the idiom
switch (deviceIdiom) {
case .pad:
print("iPad style UI")
case .phone:
print("iPhone and iPod touch style UI")
case .tv:
print("tvOS style UI")
default:
print("Unspecified UI idiom")
}

Utilice UITraitCollection. El entorno de rasgo de iOS está expuesto a través de la propiedad traitCollection del protocolo UITraitEnvironment. Este protocolo es adoptado por las siguientes clases:

• UIScreen
• UIWindow
• UIViewController
• UIPresentationController
• Vista

Answer 13

Swift 2.x:

Agregando a la respuesta de Beslav Turalov, la nueva entrada iPad Pro se puede encontrar fácilmente con esta línea

para detectar iPad Pro

struct DeviceType
{
...
static let IS_IPAD_PRO = UIDevice.currentDevice().userInterfaceIdiom == .Pad && ScreenSize.SCREEN_MAX_LENGTH == 1366.0
}

Swift 3 (TV y coche añadido):

struct ScreenSize
{
static let SCREEN_WIDTH = UIScreen.main.bounds.size.width
static let SCREEN_HEIGHT = UIScreen.main.bounds.size.height
static let SCREEN_MAX_LENGTH = max(ScreenSize.SCREEN_WIDTH, ScreenSize.SCREEN_HEIGHT)
static let SCREEN_MIN_LENGTH = min(ScreenSize.SCREEN_WIDTH, ScreenSize.SCREEN_HEIGHT)
}
struct DeviceType
{
static let IS_IPHONE = UIDevice.current.userInterfaceIdiom == .phone
static let IS_IPHONE_4_OR_LESS = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH < 568.0
static let IS_IPHONE_5 = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH == 568.0
static let IS_IPHONE_6 = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH == 667.0
static let IS_IPHONE_6P = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH == 736.0
static let IS_IPHONE_7 = IS_IPHONE_6
static let IS_IPHONE_7P = IS_IPHONE_6P
static let IS_IPAD = UIDevice.current.userInterfaceIdiom == .pad && ScreenSize.SCREEN_MAX_LENGTH == 1024.0
static let IS_IPAD_PRO_9_7 = IS_IPAD
static let IS_IPAD_PRO_12_9 = UIDevice.current.userInterfaceIdiom == .pad && ScreenSize.SCREEN_MAX_LENGTH == 1366.0
static let IS_TV = UIDevice.current.userInterfaceIdiom == .tv
static let IS_CAR_PLAY = UIDevice.current.userInterfaceIdiom == .carPlay
}
struct Version{
static let SYS_VERSION_FLOAT = (UIDevice.current.systemVersion as NSString).floatValue
static let iOS7 = (Version.SYS_VERSION_FLOAT < 8.0 && Version.SYS_VERSION_FLOAT >= 7.0)
static let iOS8 = (Version.SYS_VERSION_FLOAT >= 8.0 && Version.SYS_VERSION_FLOAT < 9.0)
static let iOS9 = (Version.SYS_VERSION_FLOAT >= 9.0 && Version.SYS_VERSION_FLOAT < 10.0)
static let iOS10 = (Version.SYS_VERSION_FLOAT >= 10.0 && Version.SYS_VERSION_FLOAT < 11.0)
}

USO :

if DeviceType.IS_IPHONE_7P { print("iPhone 7 plus") }
if DeviceType.IS_IPAD_PRO_9_7 && Version.iOS10 { print("iPad pro 9.7 with iOS 10 version") }

Answer 14

Swift 3.0 :

let userInterface = UIDevice.current.userInterfaceIdiom
if(userInterface == .pad){
//iPads
}else if(userInterface == .phone){
//iPhone
}else if(userInterface == .carPlay){
//CarPlay
}else if(userInterface == .tv){
//AppleTV
}