Ok so my old apps which were written for the 3.5in and 4in iphone screens are downloaded on the and iphone with an 4.7/5.5in they seem to upscale and run perfectly fine with everything where it's suppose to be on the screen. So now I'm writing a new app just for the 4in screens because my thinking is that it will upscale when ran on 4.7/5.5in screen but this doesn't seem to be the case.
When I run my new app on a device with a 4.7/5.5in screen there is no upscaling. Why is this so? is there any setting to force the iphone to perform the upscaling or do I have to actually tune everything for 4.7/5.5in screens?
UPDATE:
Ok I figured it out. To get your apps designed for the 4in screen to zoom in/upscale to fit the 4.7/5.5in screens you have delete the LaunchScreen.storyboard file from your project and add the Default-568#2x file.
iOS apps detect the screen size using the launch screen. The made the OS zoom out the app in order to support older apps.
If you want to let the app take full usage of the screen resolution you should use a LaunScreen storyboard or provide the assets for all the screen sizes. If this assets are not found and you use the asset catalog for the splash screen you will get the zoom to fit larger screens
I have recently been running into a problem with one of the iOS applications that I'm developing. The problem with this application is that UI elements appear to be oversized. In Xcode the elements could have the same default sizes, but during the simulation process the elements are almost too large to fit on the screen. Has anyone ran into a similar issue and figured out how to resolve it. I have attached pictures below that illustrate the problem more clearly. In one of the pictures below, the keyboard clearly appears to be larger than that in the other picture.
Oversized User Interface
Normal Sized User Interface
Two possibilities
The device has Display Zoom turned on. You can change that in Settings > Display & Brightness > Display Zoom.
You app doesn't have a launch image for that size. Either add a launch image for that screen size or use a launch storyboard/xib. How to enable native resolution for apps on iPhone 6 and 6 Plus?
In iOS apps you should set a launch image that looks similar to your first screen. Apple advises against using splash screens as launch images, but what if your app has a completely different first screen the first time it is launched (say registration screen) than the usual first screen? Is there a way to set two launch images and if not is there a way around it other than a blank or splash screen?
I was going through iOS Human Interface Guidelines.
It was mentioned as
Display a launch image that closely resembles the first screen of the application. This practice decrease the perceived launch time of your application.
Avoid displaying an About Window or a splash screen. In general, try to avoid providing any type of startup experience that prevents people from using your application immediately.
What is the difference between a launch image and a splash screen?
Launch image is the image that appears when you launch your app, the images you put in the xcode (iphone, iphone retina, ipad landscape, ipad landscape retina, ipad portrait and ipad portrait retina)
Apple recomends using a screenshot of your app main window, so it appears that your app launch faster (I use a screenshot without buttons)
Splass screen is, for example, the screens the games use, where you can see the company logo and some other info, some of them even use 2 or 3 splass screens. You have to include them programmatically
Wow, old question with no accepted or highly-upvoted answer, bubbling to the front page thanks to an edit. Guess I may as well try my hand at clearing things up?
Launch Image (or Launch Screen)
This is displayed by the OS itself, and appears only while the OS is loading your app (that is, before your process is running and any of your own code gets a chance to execute.
Because your app has no running code to handle display of the launch image, the way you provide one is part of your Xcode project's build-time configuration: Either you provide a LaunchScreen.storyboard, or a set of static launch images — one for each device screen size you support.
Apple's Human Interface Guidelines recommend that your launch image be a rough facsimile of the initial UI of your app. There are a couple of reasons for that:
The launch screen is displayed only briefly before your app takes over and can display its own UI, so having the launch image look like the actual UI makes the user feel more like they're jumping right into your app instead of having to wait for something else.
The launch screen is displayed only briefly, so if you display something that doesn't look like your initial UI, the user may see it flash and go away before they can get a decent look at it.
(Because your launch screen should look like actual UI, and because there are many screen sizes to support, the storyboard approach is preferred — you can use Auto Layout to ensure that your fake UI adapts to different screen sizes just like your real UI would. Xcode then generates the necessary images at build time.)
Splash Screen or About Window
This is what you see in many apps that don't follow Apple's guidance, and it comes in two forms (used separately or together):
Using the Launch Screen system to display content that doesn't look like the app's initial UI — instead, for example, it might be a logo or some other branding element, or might include static text like copyright notices, credits, or version information.
After the app has launched (and thus has control of the screen to display whatever it wants), continuing to display logos or branding or other passive content instead of a usable UI.
The second case is recommended against, but sometimes unavoidable — game engines, in particular, tend to take awhile to start up, so it might be okay to have a "loading" screen. (If so, your launch image should look like your loading screen, so that the user doesn't feel like they're separately waiting for your app to launch and then load.)
The worst offenders are apps that don't really have any extra "loading" work to do, but use a splash screen as their launch image, and then programmatically continue to display that image for an arbitrary amount of time so that the user gets more chance to see it. (And has to wait for it to get out of the way, or manually dismiss it, before actually using the app.)
Launch Image is displayed when the app loads.
Splash screen means, that you display a view with about information as your startscreen. Your User should use your app immediately.
The launch image is designed to make the perceived launch time of you app feel faster by showing something resembling the interface that will be loaded as quickly as possible. Displaying a logo does nothing but draw attention to how quickly your app loads and adds nothing to the user’s experience.
If your bundle have default.png then apps takes as a launch image and it remains on screen for 3 seconds
In iOS splash screen means when you provide any image named Default.png in the bundle and before executing the mainWindow it is just loading that image in the iPhone screen. So, Default.png image is considered as the Splash Screen in iPhone.
While you load the mainWindow in the iPhone application, you can assign any image that can be viewed in the screen in the specific size as given that is called the launch image.
So, launch image that is one which we provide run time when application launches and starting the main-window. And here launch image can be dynamically changed based on program written while Default.png / splash screen will be fixed for the application.
Please let me know if you still have any question?
Launch Image may take a little short time. It shows when app loading starts into iphone volatile memory. it shows for very short.
Splash screen means, that you display an Image until your necessary information loading not complete. Like, U can see any loading image before start any heavy game. When all data loading complete then this screen removed and game statrs.
It may shows for little long. !
Launch Image is displayed when the app loads. It is designed to make your app feel faster by showing something resembling the interface that will be loaded as quickly as possible.
Splash screen means, that you display a view with about information as your start screen. Your User should use your app immediately.
iOS guidelines ask us to package 768 x 1004 (portrait launch image) or 1024 x 748 (landscape launch image) sized launch images for iPad irrespective of the fact whether the app is fullscreen or not. However if we intend to extend the duration of our full screen by showing the same launch image for some more time so that we can do the initialization in the backend, we tend to see a small drift (the launch image shown by us shifts by a small amount).
This is because of the fact that scaling used by iOS to show the non fullscreen image is different from what when we display the image.
Can someone help me fix this?
I've seen that Apple document that requests Default.png files of 1024x748 and 1004x768. However, if your app specifies that it's a full screen app (status bar hidden), then I think it's ok to make your Default.png files (for iPad) the full 1024x768, which makes this problem go away.
I'm just looking at a full screen universal app I have now, that has been released, and its launch image is full screen (1024x768).
Running in the simulator works just fine (and I marked up the image to make absolutely certain that it wasn't cropping off the top 20x and then rescaling).
I don't have an iTunes Connect app that I can currently validate against (easily), so it's possible that it'll complain upon submission to iTunes Connect. But, I doubt it.
If you look at the project Summary tab -> iPad Deployment Info, it will show a warning for your Launch Image sizes:
The size of the launch image for iPad in landscape mode does not match
the recommended size of 1024 x 748 pixels.
So, I take that as a recommendation, not a requirement.
Edit: also, see this other stack overflow question. That answer also suggests using 1024x768 images, and it hasn't received any pushback from the community (after 19 months+)