UIWindow is a special UIView, usually there is only one UIWindow in an app.
After the iOS program is started, the first view control created is UIWindow. Then create the controller's view, and finally add the controller's view to the UIWindow, so the controller's view is displayed on the screen.
The reason why an iOS program can be displayed on the screen is entirely because it has UIWindow. In other words, without UIWindow, you cannot see any UI interface.
How to get UIWindow
(1) [UIApplication sharedApplication].windows The UIWindow list opened in this application, so that you can contact any UIView object in the application (the keyboard that pops up when entering text is usually in a new UIWindow);
(2) [UIApplication sharedApplication].keyWindow (gets the main window of the application) is used to receive keyboard and non-touch message events, and there can only be one UIWindow in the program at each moment that is the keyWindow;
Note: After code verification, non-keyWindow can also accept keyboard messages;
Tip: If the text box inside a UIWindow cannot enter text, it may be because this UIWindow is not a keyWindow;
(3) Obtain the UIWindow where a UIView is located.
UIWindowLevel
We know that UIWindow has three levels, namely Normal, StatusBar, and Alert. The values of their three levels are output. We find that from left to right are 0, 1000, and 2000, which means that the Normal level is the lowest, StatusBar is in the intermediate level, and the Alert level is the highest. Usually, the interface of our program is at the Normal level. The status bar at the top of the system should be at the StatusBar level. UIActionSheet and UIAlertView are usually used to interrupt normal processes and remind users of operations, so they are at the Alert level.
According to the principle of window display level priority, the higher level will be displayed at the top level, and the lower level will be displayed below. The view normally displayed by our program is at the bottom level;
keyWindow
The official document explains this way "The key window is the one that is designed to receive keyboard and other non-touch related events. Only one window at a time may be the key window." Translated in this way, keyWindow is specified to receive keyboard and non-touch messages, and there can only be one window in the program at each moment that is a keyWindow.
Observing the UIWindow documentation, we can find that there are four notifications about window changes:
UIWindowDidBecomeVisibleNotification
UIWindowDidBecomeHiddenNotification
UIWindowDidBecomeKeyNotification
UIWindowDidResignKeyNotification
The objects in these four notification objects represent the window object that has been displayed (hidden) and has become a keyWindow (non-keyWindow), and the userInfo is empty. So we can register these four messages, and then print the information to observe the changes in keyWindow and the display of windows, hidden changes.
This is the process of becoming a keywindow
1. The default window of the program is displayed first
2. The default window becomes keywindow again
The window is displayed
4. The default window becomes keywindow
5. In the end, the window of AlertView becomes a keywindow
iOS8 starts to change the bounds of UIWindow (Window itself rotates)
Before iOS 7, the bounds of the Window will not change with the direction, but after iOS 8, the direction of the device will change accordingly.
Do a very simple test, the code is as follows:
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
// Override point for customization after application launch.
[[NSNotificationCenter defaultCenter] addObserver:self
selector:@selector(orientationChanged:)
name:UIDeviceOrientationDidChangeNotification
object:nil];
return YES;
}
- (void)orientationChanged:(NSNotification*)noti {
UIDeviceOrientation orientation = [UIDevice currentDevice].orientation;
NSString *orientationDes = nil;
switch (orientation) {
case UIDeviceOrientationLandscapeLeft:
orientationDes = @"UIInterfaceOrientationLandscapeRight";
break;
case UIDeviceOrientationLandscapeRight:
orientationDes = @"UIInterfaceOrientationLandscapeLeft";
break;
case UIDeviceOrientationPortrait:
orientationDes = @"UIInterfaceOrientationPortrait";
break;
case UIDeviceOrientationPortraitUpsideDown:
orientationDes = @"UIInterfaceOrientationPortraitUpsideDown";
break;
default:
orientationDes = @"";
break;
}
NSLog(@"system ver: %@, \rorientaion: %@, \rwindow bounds: %@",
[UIDevice currentDevice].systemVersion,
orientationDes,
NSStringFromCGRect());
}
The sample code is very simple. Create a new project and then add the above code directly to the delegate.
The result of running on iOS 8 is:
2014-06-04 09:26:32.016 SviOS8[4143:61114] system ver: 8.0,
orientaion: UIInterfaceOrientationLandscapeRight,
window bounds: {{0, 0}, {320, 480}}
2014-06-04 09:26:34.788 SviOS8[4143:61114] system ver: 8.0,
orientaion: UIInterfaceOrientationPortrait,
window bounds: {{0, 0}, {480, 320}}
2014-06-04 09:26:35.791 SviOS8[4143:61114] system ver: 8.0,
orientaion: UIInterfaceOrientationLandscapeLeft,
window bounds: {{0, 0}, {320, 480}}
2014-06-04 09:26:47.468 SviOS8[4143:61114] system ver: 8.0,
orientaion: UIInterfaceOrientationPortraitUpsideDown,
window bounds: {{0, 0}, {480, 320}}
iOS 7 and previous versions run results are:
orientaion: UIInterfaceOrientationLandscapeRight,
window bounds: {{0, 0}, {320, 480}}
2014-06-04 09:39:00.895 SviOS8[4380:70b] system ver: 7.0.3,
orientaion: UIInterfaceOrientationPortrait,
window bounds: {{0, 0}, {320, 480}}
2014-06-04 09:39:01.225 SviOS8[4380:70b] system ver: 7.0.3,
orientaion: UIInterfaceOrientationLandscapeLeft,
window bounds: {{0, 0}, {320, 480}}
2014-06-04 09:39:11.004 SviOS8[4380:70b] system ver: 7.0.3,
orientaion: UIInterfaceOrientationPortraitUpsideDown,
window bounds: {{0, 0}, {320, 480}}
Through comparison, we can clearly see the change in the strategy of UIWindow when handling rotation in iOS 8. Although there will be bugs in the existing project layout due to different from the previous version, we can see that the processing method in iOS 8 is more in line with our expectations. In the vertical direction, we get width < height, in the horizontal direction, width > height, which conforms to the principle of what you see is what you get.
As an aside, whether it is iOS 7 or previous versions, as well as the latest iOS 8, all ViewController bounds are correct, so you only need to adhere to one principle: "All layouts are based on layout, then your app display will be normal."