Jak uzyskać zależną od orientacji wysokość i szerokość ekranu?

Próbuję programowo określić aktualną wysokość i szerokość mojej aplikacji. Używam tego:

CGRect screenRect = [[UIScreen mainScreen] bounds];

Ale daje to szerokość 320 i wysokość 480, niezależnie od tego, czy urządzenie jest w orientacji pionowej czy poziomej. Jak mogę określić aktualną szerokość i wysokość (tj. W zależności od orientacji urządzenia) mojego głównego ekranu?

Możesz użyć czegoś podobnego UIInterfaceOrientationIsPortrait([UIApplication sharedApplication].statusBarOrientation)do określenia orientacji, a następnie odpowiednio użyć wymiarów.

JEDNAK, podczas zmiany orientacji jak w UIViewController's

- (void) willRotateToInterfaceOrientation:(UIInterfaceOrientation)toInterfaceOrientation 
                                 duration:(NSTimeInterval)duration

Użyj orientacji przekazanej, toInterfaceOrientationponieważ statusBarOrientation UIApplication będzie nadal wskazywać na starą orientację, ponieważ jeszcze się nie zmieniła (ponieważ jesteś w module willobsługi zdarzeń).

Podsumowanie

Istnieje kilka powiązanych z tym postów, ale każdy z nich wydaje się wskazywać, że musisz:

1. Spójrz, [[UIScreen mainScreen] bounds]aby uzyskać wymiary,
2. Sprawdź, w jakiej jesteś orientacji i
3. Uwzględnij wysokość paska stanu (jeśli jest pokazana)

Spinki do mankietów

• Iphone: pobierz aktualne wymiary widoku lub wymiary ekranu
• IPhone / iPad: jak programowo uzyskać szerokość ekranu?
• Cel C - jak uzyskać aktualną rozdzielczość ekranu?
• „Nieprawidłowy” rozmiar ramki / okna po zmianie orientacji na iPhonie lub iPadzie
• iPhone Dev SDK - pobierz szerokość ekranu

Kodeks roboczy

Zwykle nie posuwam się tak daleko, ale wzbudziłeś moje zainteresowanie. Poniższy kod powinien załatwić sprawę. Napisałem kategorię na UIApplication. Dodałem metody klasowe, aby uzyskać currentSize lub rozmiar w danej orientacji, czyli to, co nazywasz w UIViewController willRotateToInterfaceOrientation:duration:.

@interface UIApplication (AppDimensions)
+(CGSize) currentSize;
+(CGSize) sizeInOrientation:(UIInterfaceOrientation)orientation;
@end

@implementation UIApplication (AppDimensions)

+(CGSize) currentSize
{
    return [UIApplication sizeInOrientation:[UIApplication sharedApplication].statusBarOrientation];
}

+(CGSize) sizeInOrientation:(UIInterfaceOrientation)orientation
{
    CGSize size = [UIScreen mainScreen].bounds.size;
    UIApplication *application = [UIApplication sharedApplication];
    if (UIInterfaceOrientationIsLandscape(orientation))
    {
        size = CGSizeMake(size.height, size.width);
    }
    if (application.statusBarHidden == NO)
    {
        size.height -= MIN(application.statusBarFrame.size.width, application.statusBarFrame.size.height);
    }
    return size;
}

@end

Aby skorzystać z kodu wystarczy zadzwonić [UIApplication currentSize]. Uruchomiłem również powyższy kod, więc wiem, że działa i raportuje prawidłowe odpowiedzi we wszystkich orientacjach. Zwróć uwagę, że uwzględniam pasek stanu. Co ciekawe, musiałem odjąć MIN wysokości i szerokości paska stanu.

Mam nadzieję że to pomoże. :RE

Inne przemyślenia

Możesz przejść do uzyskania wymiarów, patrząc na właściwość UIWindow rootViewController. Patrzyłem na to w przeszłości i podobnie przedstawia te same wymiary zarówno w orientacji pionowej, jak i poziomej, z wyjątkiem tego, że informuje o przekształceniu rotacyjnym:

(gdb) po [[[[[UIApplication sharedApplication] keyWindow] rootViewController] widok]

<UILayoutContainerView: 0xf7296f0; ramka = (0 0; 320 480); transformacja = [0, -1, 1, 0, 0, 0]; autorezacja = W + H; layer = <CALayer: 0xf729b80 >>

(gdb) po [[[[[UIApplication sharedApplication] keyWindow] rootViewController] widok]

<UILayoutContainerView: 0xf7296f0; ramka = (0 0; 320 480); autorezacja = W + H; layer = <CALayer: 0xf729b80 >>

Nie jestem pewien, jak działa twoja aplikacja, ale jeśli nie używasz jakiegoś kontrolera nawigacyjnego, możesz mieć UIView pod głównym widokiem z maksymalną wysokością / szerokością rodzica i rosnąć / kurczyć się z rodzicem. Następnie można zrobić: [[[[[[[UIApplication sharedApplication] keyWindow] rootViewController] view] subviews] objectAtIndex:0] frame]. W jednej linii wygląda to dość intensywnie, ale masz pomysł.

Jednak ... Nadal lepiej byłoby wykonać powyższe 3 kroki pod podsumowaniem. Zacznij zadzierać z UIWindows, a dowiesz się dziwnych rzeczy, na przykład pokazanie UIAlertView zmieni okno klucza UIApplication, aby wskazywało na nowe okno UIWindow utworzone przez UIAlertView. Kto wiedział? Zrobiłem to po znalezieniu błędu polegającego na keyWindow i odkryciu, że to się tak zmieniło!

To jest mój kod rozwiązania! Ta metoda może dodać do klasy Categroy klasy NSObject lub możesz zdefiniować niestandardową klasę UIViewController Top i pozwolić wszystkim innym UIViewControllers na dziedziczenie.

-(CGRect)currentScreenBoundsDependOnOrientation
{  

    CGRect screenBounds = [UIScreen mainScreen].bounds ;
    CGFloat width = CGRectGetWidth(screenBounds)  ;
    CGFloat height = CGRectGetHeight(screenBounds) ;
    UIInterfaceOrientation interfaceOrientation = [UIApplication sharedApplication].statusBarOrientation;

    if(UIInterfaceOrientationIsPortrait(interfaceOrientation)){
        screenBounds.size = CGSizeMake(width, height);
    }else if(UIInterfaceOrientationIsLandscape(interfaceOrientation)){
        screenBounds.size = CGSizeMake(height, width);
    }
    return screenBounds ;
}

Uwaga , po IOS8, jak mówi Apple Document of UIScreen's bounds property :

Dyskusja

Ten prostokąt jest określony w bieżącej przestrzeni współrzędnych, która uwzględnia wszelkie obroty interfejsu obowiązujące dla urządzenia. Dlatego wartość tej właściwości może się zmieniać, gdy urządzenie obraca się między orientacją pionową i poziomą.

więc ze względu na kompatybilność powinniśmy wykryć wersję IOS i wprowadzić zmiany jak poniżej:

#define IsIOS8 (NSFoundationVersionNumber > NSFoundationVersionNumber_iOS_7_1)

-(CGRect)currentScreenBoundsDependOnOrientation
{  

    CGRect screenBounds = [UIScreen mainScreen].bounds ;
    if(IsIOS8){
        return screenBounds ;
    }
    CGFloat width = CGRectGetWidth(screenBounds)  ;
    CGFloat height = CGRectGetHeight(screenBounds) ;
    UIInterfaceOrientation interfaceOrientation = [UIApplication sharedApplication].statusBarOrientation;

    if(UIInterfaceOrientationIsPortrait(interfaceOrientation)){
        screenBounds.size = CGSizeMake(width, height);
    }else if(UIInterfaceOrientationIsLandscape(interfaceOrientation)){
        screenBounds.size = CGSizeMake(height, width);
    }
    return screenBounds ;
}

Oto przydatne makro:

#define SCREEN_WIDTH (UIInterfaceOrientationIsPortrait([UIApplication sharedApplication].statusBarOrientation) ? [[UIScreen mainScreen] bounds].size.width : [[UIScreen mainScreen] bounds].size.height)
#define SCREEN_HEIGHT (UIInterfaceOrientationIsPortrait([UIApplication sharedApplication].statusBarOrientation) ? [[UIScreen mainScreen] bounds].size.height : [[UIScreen mainScreen] bounds].size.width)

W iOS 8+ należy skorzystać z viewWillTransitionToSize:withTransitionCoordinatormetody:

-(void)viewWillTransitionToSize:(CGSize)size withTransitionCoordinator:(id<UIViewControllerTransitionCoordinator>)coordinator {
    [super viewWillTransitionToSize:size withTransitionCoordinator:coordinator];

    // You can store size in an instance variable for later
    currentSize = size;

    // This is basically an animation block
    [coordinator animateAlongsideTransition:^(id<UIViewControllerTransitionCoordinatorContext> context) {

        // Get the new orientation if you want
        UIInterfaceOrientation orientation = [[UIApplication sharedApplication] statusBarOrientation];

        // Adjust your views
        [self.myView setFrame:CGRectMake(0, 0, size.width, size.height)];

    } completion:^(id<UIViewControllerTransitionCoordinatorContext> context) {
        // Anything else you need to do at the end
    }];
}

Zastępuje to przestarzałą metodę animacji, która nie podawała żadnych informacji o rozmiarze:

-(void)willAnimateRotationToInterfaceOrientation:(UIInterfaceOrientation)orientation duration:(NSTimeInterval)duration

Od wersji iOS 8 granice ekranu są teraz zwracane prawidłowo dla bieżącej orientacji. Oznacza to, że iPad w orientacji poziomej [UIScreen mainScreen] .bounds zwróciłby 768 na iOS <= 7 i 1024 na iOS 8.

Poniższe zwraca prawidłową wysokość i szerokość we wszystkich wydanych wersjach.

-(CGRect)currentScreenBoundsDependOnOrientation
{
    NSString *reqSysVer = @"8.0";
    NSString *currSysVer = [[UIDevice currentDevice] systemVersion];
    if ([currSysVer compare:reqSysVer options:NSNumericSearch] != NSOrderedAscending)
        return [UIScreen mainScreen].bounds;

    CGRect screenBounds = [UIScreen mainScreen].bounds ;
    CGFloat width = CGRectGetWidth(screenBounds)  ;
    CGFloat height = CGRectGetHeight(screenBounds) ;
    UIInterfaceOrientation interfaceOrientation = [UIApplication sharedApplication].statusBarOrientation;

    if(UIInterfaceOrientationIsPortrait(interfaceOrientation)){
        screenBounds.size = CGSizeMake(width, height);
        NSLog(@"Portrait Height: %f", screenBounds.size.height);
    }else if(UIInterfaceOrientationIsLandscape(interfaceOrientation)){
        screenBounds.size = CGSizeMake(height, width);
        NSLog(@"Landscape Height: %f", screenBounds.size.height);
    }

    return screenBounds ;
}

jeśli chcesz mieć rozmiar zależny od orientacji i masz widok, możesz po prostu użyć:

view.bounds.size

Pisałem kategorię UIScreen, która działa na wszystkich wersjach iOS, dzięki czemu można go używać tak:
[[UIScreen mainScreen] currentScreenSize].

@implementation UIScreen (ScreenSize)

- (CGSize)currentScreenSize {
    CGRect screenBounds = [[UIScreen mainScreen] bounds];
    CGSize screenSize = screenBounds.size;

    if ( NSFoundationVersionNumber <= NSFoundationVersionNumber_iOS_7_1 ) {  
        UIInterfaceOrientation interfaceOrientation = [[UIApplication sharedApplication] statusBarOrientation];
        if ( UIInterfaceOrientationIsLandscape(interfaceOrientation) ) {
            screenSize = CGSizeMake(screenSize.height, screenSize.width);
        }
    }

    return screenSize;
}

@end

Oto szybki sposób na uzyskanie rozmiarów ekranu zależnych od orientacji:

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ą to standardowe funkcje mojego projektu:

https://github.com/goktugyil/EZSwiftExtensions

float msWidth = [[UIScreen mainScreen] bounds].size.width*(IS_RETINA?2.0f:1.0f);
float msHeight = [[UIScreen mainScreen] bounds].size.height*(IS_RETINA?2.0f:1.0f);
if ( UIInterfaceOrientationIsPortrait(self.interfaceOrientation) ) {
    os->setWidth(MIN(msWidth, msHeight));
    os->setHeight(MAX(msWidth, msHeight));
} else {
    os->setWidth(MAX(msWidth, msHeight));
    os->setHeight(MIN(msWidth, msHeight));
}

NSLog(@"screen_w %f", os->getWidth());
NSLog(@"screen_h %f", os->getHeight());

Jednak w iOS 8.0.2:

+ (NSUInteger)currentWindowWidth
{
    NSInteger width = 0;
    UIInterfaceOrientation orientation = [UIApplication sharedApplication].statusBarOrientation;
    CGSize size = [UIScreen mainScreen].bounds.size;
   // if (UIInterfaceOrientationIsLandscape(orientation)) {
   //     width = size.height;
   // } else {
        width = size.width;
  //  }

    return width;
}

użyj -> setNeedsDisplay () dla widoku, którego rozmiar chcesz zmienić.