Jak uzyskać szerokość i wysokość ekranu w iOS?

Jak uzyskać wymiary ekranu w iOS?

Obecnie używam:

lCurrentWidth = self.view.frame.size.width;
lCurrentHeight = self.view.frame.size.height;

w viewWillAppear:iwillAnimateRotationToInterfaceOrientation:duration:

Za pierwszym razem otrzymuję cały rozmiar ekranu. Za drugim razem dostaję ekran minus pasek nawigacyjny.

Jak uzyskać wymiary ekranu w iOS?

Problem z opublikowanym kodem polega na tym, że liczysz na rozmiar widoku odpowiadający rozmiarowi ekranu, a jak już zauważyłeś, nie zawsze tak jest. Jeśli potrzebujesz rozmiaru ekranu, powinieneś spojrzeć na obiekt reprezentujący sam ekran, w następujący sposób:

CGRect screenRect = [[UIScreen mainScreen] bounds];
CGFloat screenWidth = screenRect.size.width;
CGFloat screenHeight = screenRect.size.height;

Aktualizacja podzielonego widoku: W komentarzach Dmitry zapytał:

Jak mogę uzyskać rozmiar ekranu w podzielonym widoku?

Podany powyżej kod zgłasza rozmiar ekranu, nawet w trybie podzielonego ekranu. Gdy używasz trybu podzielonego ekranu, zmienia się okno aplikacji. Jeśli powyższy kod nie zawiera oczekiwanych informacji, to podobnie jak PO, patrzysz na niewłaściwy obiekt. W takim przypadku powinieneś jednak spojrzeć na okno zamiast na ekran:

CGRect windowRect = self.view.window.frame;
CGFloat windowWidth = windowRect.size.width;
CGFloat windowHeight = windowRect.size.height;

Szybki 4.2

let screenRect = UIScreen.main.bounds
let screenWidth = screenRect.size.width
let screenHeight = screenRect.size.height

// split screen            
let windowRect = self.view.window?.frame
let windowWidth = windowRect?.size.width
let windowHeight = windowRect?.size.height

Ostrożnie, [Główny ekran UIScreen] zawiera również pasek stanu, jeśli chcesz pobrać ramkę dla swojej aplikacji (bez paska stanu), powinieneś użyć

+ (CGFloat) window_height   {
    return [UIScreen mainScreen].applicationFrame.size.height;
}

+ (CGFloat) window_width   {
    return [UIScreen mainScreen].applicationFrame.size.width;
}

Przetłumaczyłem niektóre z powyższych odpowiedzi Celu C na kod Swift. Każde tłumaczenie jest poprzedzone odniesieniem do oryginalnej odpowiedzi.

Główna odpowiedź

let screen = UIScreen.main.bounds
let screenWidth = screen.size.width
let screenHeight = screen.size.height

Prosta funkcja odpowiedzi

func windowHeight() -> CGFloat {
    return UIScreen.mainScreen().applicationFrame.size.height
}

func windowWidth() -> CGFloat {
    return UIScreen.mainScreen().applicationFrame.size.width
}

Odpowiedź dotycząca orientacji urządzenia

var screenHeight : CGFloat
let statusBarOrientation = UIApplication.sharedApplication().statusBarOrientation
// it is important to do this after presentModalViewController:animated:
if (statusBarOrientation != UIInterfaceOrientation.Portrait
    && statusBarOrientation != UIInterfaceOrientation.PortraitUpsideDown){
    screenHeight = UIScreen.mainScreen().applicationFrame.size.width
} else {
    screenHeight = UIScreen.mainScreen().applicationFrame.size.height
}

Zaloguj się

let screenWidth = UIScreen.mainScreen().bounds.size.width
let screenHeight = UIScreen.mainScreen().bounds.size.height
println("width: \(screenWidth)")
println("height: \(screenHeight)")

Wcześniej stosowałem następujące metody wygody:

- (CGRect)getScreenFrameForCurrentOrientation {
    return [self getScreenFrameForOrientation:[UIApplication sharedApplication].statusBarOrientation];
}

- (CGRect)getScreenFrameForOrientation:(UIInterfaceOrientation)orientation {

    CGRect fullScreenRect = [[UIScreen mainScreen] bounds];

    // implicitly in Portrait orientation.
    if (UIInterfaceOrientationIsLandscape(orientation)) {
      CGRect temp = CGRectZero;
      temp.size.width = fullScreenRect.size.height;
      temp.size.height = fullScreenRect.size.width;
      fullScreenRect = temp;
    }

    if (![[UIApplication sharedApplication] statusBarHidden]) {
      CGFloat statusBarHeight = 20; // Needs a better solution, FYI statusBarFrame reports wrong in some cases..
      fullScreenRect.size.height -= statusBarHeight;
    }

    return fullScreenRect;
} 

Zdaję sobie sprawę, że jest to stary post, ale czasami uważam, że przydatne jest #define stałe takie jak te, więc nie muszę się o to martwić:

#define DEVICE_SIZE [[[[UIApplication sharedApplication] keyWindow] rootViewController].view convertRect:[[UIScreen mainScreen] bounds] fromView:nil].size

Powyższa stała powinna zwracać prawidłowy rozmiar bez względu na orientację urządzenia. Zatem uzyskanie wymiarów jest tak proste, jak:

lCurrentWidth = DEVICE_SIZE.width;
lCurrentHeight = DEVICE_SIZE.height;

Bardzo, bardzo łatwo jest uzyskać rozmiar urządzenia, a także wziąć pod uwagę orientację:

// grab the window frame and adjust it for orientation
UIView *rootView = [[[UIApplication sharedApplication] keyWindow] 
                                   rootViewController].view;
CGRect originalFrame = [[UIScreen mainScreen] bounds];
CGRect adjustedFrame = [rootView convertRect:originalFrame fromView:nil];

Musimy również wziąć pod uwagę orientację urządzenia:

CGFloat screenHeight;
// it is important to do this after presentModalViewController:animated:
if ([[UIApplication sharedApplication] statusBarOrientation] == UIDeviceOrientationPortrait || [[UIApplication sharedApplication] statusBarOrientation] == UIDeviceOrientationPortraitUpsideDown){
    screenHeight = [UIScreen mainScreen].applicationFrame.size.height;
}
else{
    screenHeight = [UIScreen mainScreen].applicationFrame.size.width;
}

NSLog(@"%.0f", [[UIScreen mainScreen] bounds].size.width);
NSLog(@"%.0f", [[UIScreen mainScreen] bounds].size.height);

Tutaj zaktualizowałem do Swift 3

applicationFrame przestarzałe z iOS 9

W szybkich trzech usunęli () i zmienili kilka konwencji nazewnictwa, możesz odwołać się tutaj Link

func windowHeight() -> CGFloat {
    return UIScreen.main.bounds.size.height
}

func windowWidth() -> CGFloat {
    return UIScreen.main.bounds.size.width
}

Nowoczesna odpowiedź:

jeśli Twoja aplikacja obsługuje podzielony widok na iPadzie, problem ten staje się nieco skomplikowany. Potrzebujesz rozmiaru okna, a nie ekranu, który może zawierać 2 aplikacje. Rozmiar okna może się również różnić podczas działania.

Użyj rozmiaru głównego okna aplikacji:

UIApplication.shared.delegate?.window??.bounds.size ?? .zero

Uwaga: powyższa metoda może mieć niepoprawną wartość, zanim okno stanie się kluczowym oknem podczas uruchamiania. jeśli potrzebujesz tylko szerokości, bardzo zalecana jest metoda poniżej :

UIApplication.shared.statusBarFrame.width

Używanie starego rozwiązania UIScreen.main.boundszwróci granice urządzenia. Jeśli Twoja aplikacja działa w trybie podzielonego widoku, ma nieprawidłowe wymiary.

self.view.window w najgorętszej odpowiedzi może mieć zły rozmiar, gdy aplikacja zawiera 2 lub więcej okien, a okno ma mały rozmiar.

Skorzystaj z nich, Structsaby poznać przydatne informacje o bieżącym urządzeniu w Swift 3.0

struct ScreenSize { // Answer to OP's question

    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 { //Use this to check what is the device kind you're working with

    static let IS_IPHONE_4_OR_LESS  = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH < 568.0
    static let IS_IPHONE_SE         = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH == 568.0
    static let IS_IPHONE_7          = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH == 667.0
    static let IS_IPHONE_7PLUS      = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH == 736.0
    static let IS_IPHONE_X          = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH == 812.0
    static let IS_IPAD              = UIDevice.current.userInterfaceIdiom == .pad && ScreenSize.SCREEN_MAX_LENGTH == 1024.0

}


struct iOSVersion { //Get current device's iOS version

    static let SYS_VERSION_FLOAT  = (UIDevice.current.systemVersion as NSString).floatValue
    static let iOS7               = (iOSVersion.SYS_VERSION_FLOAT >= 7.0 && iOSVersion.SYS_VERSION_FLOAT < 8.0)
    static let iOS8               = (iOSVersion.SYS_VERSION_FLOAT >= 8.0 && iOSVersion.SYS_VERSION_FLOAT < 9.0)
    static let iOS9               = (iOSVersion.SYS_VERSION_FLOAT >= 9.0 && iOSVersion.SYS_VERSION_FLOAT < 10.0)
    static let iOS10              = (iOSVersion.SYS_VERSION_FLOAT >= 10.0 && iOSVersion.SYS_VERSION_FLOAT < 11.0)
    static let iOS11              = (iOSVersion.SYS_VERSION_FLOAT >= 11.0 && iOSVersion.SYS_VERSION_FLOAT < 12.0)
    static let iOS12              = (iOSVersion.SYS_VERSION_FLOAT >= 12.0 && iOSVersion.SYS_VERSION_FLOAT < 13.0)

}

Jeśli chcesz szerokość / wysokość ekranu niezależnie od orientacji urządzenia (dobre do zmiany rozmiaru tylko kontrolery widoku uruchamiane z orientacji poziomej):

CGFloat screenWidthInPoints = [UIScreen mainScreen].nativeBounds.size.width/[UIScreen mainScreen].nativeScale;
CGFloat screenHeightInPoints = [UIScreen mainScreen].nativeBounds.size.height/[UIScreen mainScreen].nativeScale;

[UIScreen mainScreen] .nativeBounds <- Z dokumentów -> Granica prostokąta ekranu fizycznego, mierzona w pikselach. Ten prostokąt opiera się na urządzeniu w orientacji pionowej. Ta wartość nie zmienia się, gdy urządzenie się obraca.

Oto szybki sposób uzyskania rozmiarów ekranu:

print(screenWidth)
print(screenHeight)

var screenWidth: CGFloat {
    if UIInterfaceOrientationIsPortrait(screenOrientation) {
        return UIScreen.mainScreen().bounds.size.width
    } else {
        return UIScreen.mainScreen().bounds.size.height
    }
}

var screenHeight: CGFloat {
    if UIInterfaceOrientationIsPortrait(screenOrientation) {
        return UIScreen.mainScreen().bounds.size.height
    } else {
        return UIScreen.mainScreen().bounds.size.width
    }
}

var screenOrientation: UIInterfaceOrientation {
    return UIApplication.sharedApplication().statusBarOrientation
}

Są one zawarte jako funkcja standardowa w:

https://github.com/goktugyil/EZSwiftExtensions

CGFloat width = [[UIScreen mainScreen] bounds].size.width; CGFloat height = [[UIScreen mainScreen]bounds ].size.height;

szybki 3.0

dla szerokości

UIScreen.main.bounds.size.width

na wysokość

UIScreen.main.bounds.size.height

Możesz umieścić te makra w pliku pch i używać ich w dowolnym miejscu w projekcie, używając „SCREEN_WIDTH”

#define SCREEN_WIDTH                ((([UIApplication sharedApplication].statusBarOrientation == UIInterfaceOrientationPortrait) || ([UIApplication sharedApplication].statusBarOrientation == UIInterfaceOrientationPortraitUpsideDown)) ? [[UIScreen mainScreen] bounds].size.width : [[UIScreen mainScreen] bounds].size.height)

i „SCREEN_HEIGHT”

#define SCREEN_HEIGHT               ((([UIApplication sharedApplication].statusBarOrientation == UIInterfaceOrientationPortrait) || ([UIApplication sharedApplication].statusBarOrientation ==   UIInterfaceOrientationPortraitUpsideDown)) ? [[UIScreen mainScreen] bounds].size.height : [[UIScreen mainScreen] bounds].size.width)

Przykład użycia:

CGSize calCulateSizze ;
calCulateSizze.width = SCREEN_WIDTH/2-8;
calCulateSizze.height = SCREEN_WIDTH/2-8;