I'm about to submit my first iPad app, and I have 2 questions regarding to Default.png images.
I would prefer a "splash screen" showing some artwork of my app, instead of the UI as if it was loaded, the app is a bit heavy and I've seen the users dispair when the UI is apparently loaded but it's not working. Does anyone know if apple is accepting apps with "splash screens"?
I want to provide a Default-X.png for every orientation, I've read the iPad programming guide, my question is, is "Default-LandscapeLeft" a Default image rotated 90 degrees clockwise, and "Default-LandscapeRight" rotated 90 degrees counter clockwise?
I'm asking this because I don't have an iPad yet to test this on.
Thank you a lot in advance.
Some are accepted, some are not, it doesn't all depend on that. However, it is recommended that you avoid the heavy loading times that would require a splash-screen. You could find a compromise by showing an image of a faded-out version of your working UI. If you need initial loading activity, consider deferring this loading stage after the Default.png is displayed, and use a view with similar aspect, but with some sort of progress indicator.
You don't need an iPad to test it, you can use the simulator, it can be rotated.
Take a look in the App Store, most apps use a splash screen rather than a UI capture, despite what the UI guidelines say.
And you are correct about the Default.png layouts, although left and right can be the same image if you wish.
About Interface Orientation, I have not tested that yet. But if I imagine the iPad in normal portrait position (being the exit button at the bottom)
I would think that Default-LandscapeLeft is iPad turned counter-clockwise while Default-LandscapeRight is clockwise.
Unless you have a clock which is turning backwards... :-)
Cheers
Related
I have a game we're trying to release in the app store for iphone and ipad, and while it works fine on all of our devices (a handful of iphones and ipads), when the app store reviewers try it the actual viewport they see is highly cropped and distorted.
This is an example options screen that the reviewer saw:
This is what that options screen looks like for us on an equivalent aspect ratio/resolution:
As you can see, it's just a small, off-centered square for them, surrounded by black. But we've tested this on devices like an old iphone 5 up to big ipads and have never seen anything like this, the game takes up the full screen and the aspect ratio is correct and not distorted or stretched.
One important detail is this is entirely an OpenGL and SDL program, not using any Apple UI frameworks at all. The render size is determined by SDL_GetRendererOutputSize(), which then is used in glViewport(), and the window is created with the SDL_WINDOW_ALLOW_HIGHDPI flag. This so far has seemed to work with both retina and non-retina physical devices.
Also all of the screenshots they've given us look the same, same little square viewport surrounded by black, so I originally thought they were cropping them on purpose to highlight specific components of the screen, but this appears to be just exactly how it looks for them as this square is in the same position in each screenshot. I've asked them for more information on their devices but they wouldn't tell me.
We also have the program set to only ever use landscape, not portrait, but the weird thing is that with the way our UI reflows, the only way to get that button to look squished the way it does there is if the game was somehow still rendering in portrait, as seen this example shot I took by forcing it to run in a very tall portrait window:
I don't even know where to begin to try to figure out what's going wrong for them though, because as I've said, everything looks fine when running in an emulator and everything looks fine when we've run it on several physical devices. Is there some build or release configuration I could be missing? Some OpenGL setting I should check? I'm just hoping this problem looks similar to something someone else has encountered before.
If you are on an equivalent device, then another thing that may differ is the accessibility settings. Search for display zoom in settings. Also, try locking the iPad into portrait mode before launching your app to try and reproduce.
Note the little double arrow icon in the lower right corner of the reviewer’s screenshot. I don’t know what that is, but it looks like it could be some kind of screen zoom or accessibility mode. Perhaps they can answer what it does, and how to enable it for yourself.
To follow up with the solution that worked for me, I noticed that in my project's General settings in Xcode, under Deployment Info, I had only checked iPhone and not iPad. What I've since learned is that without that checkbox, some iPads will have to run in an emulation mode, which may have been the source of our problem. Deploying a new build with that checked (as well as "requires full screen"), it rendered exactly the same on our own iPads, but the app was subsequently approved with no further problems. I had made no other changes to the program, so my assumption is that that setting likely fixed it.
Since Apple is requiring a storyboard launch screen in a few months I went ahead and tried to add one. Adding one is simple and it works just fine but it screws up the layout after loading the app. No longer does a larger screen automatically adjust the resolution, instead I'm left with an SE layout on an 8 Plus screen placed in the top-left corner with the background image repeating (like wallpaper from a 90s website). I'm not using constraints, but I'm not even sure if that's the issue. If so I have a feeling I have a lot of work ahead of me (keep in mind I've never had a need for constraints). A side thought though is, from what I understand, Apple wants all apps to look correctly on all devices... makes perfect sense. But my apps have always appeared correctly no matter the device. So it's ironic that adding the launch screen is breaking my apps' appearances. Is it the constraints? Is there an alternative solution? Or is there hopefully something simple in the launch screen that needs to be changed? Thank you!
I have created a simple Launch Screen for my app using the LaunchScreen.storyboard (in Xcode 7.1.1). It consists of a label containing a title, a UIView (with mode set to 'Aspect Fit') containing an image of the icon (2000 px x 2000 px) and a label at the foot containing a copyright statement (see image below).
Can anyone tell me if this will meet the App Store requirements for a Launch Screen?
Thanks!
There's no problem with your launch screen.
The only thing I'd recommend to change is reduce resolution of your icon - there's no need to icon be so big. It will speed up your app launch time and reduce it's size on device.
Here's link to Launch Screen guidelines, so you can learn more from there.
And here's link to App Store Review Guidelines, they don't mention Launch Screens, but still it's worth reading them before app submission.
Three tips to create a great splash screen for your mobile app:-
1 - Use the right size
From one smartphone to another, the screen resolution can vary a lot.
Let's imagine you have crafted the perfect splash screen for an iPhone 5S. This image should mesure 640 x 1136px. It will look great on the iPhone 5S, 5C and 5, which have the same screen resolution. But what about the iPhone 4 which has a 640 x 960 px screen resolution? Displayed on the iPhone 4S or 4, your splash screen will be distorted.
To make the perfect one, you should create as much splash screens as there are screen resolutions. If your are creating an iPhone app, it's not a big deal since there are few devices.
2 - Keep it simple
The splash screen doesn't last very long. So no need to put a long text on your splash screen. Your users won't have the time to read it. And moreover, that's not the purpose of the splash screen.
Use your brand name, your logo, your motto, or whatever describes you and your app the best. Make a clear composition using those elements, and create one single image, in portrait mode.
If you want to create several sizes for your splash screen, I recommend you focus on the center of the image to put your composition. Leaving the edges of the splash screen free will enable you to crop your image to the different desired sizes.
3 - Tell your users it's loading
The splash screen is a still image. When you see it, it looks like your phone is frozen. Nothing happens. You can't interact with the app. You're stuck. You can only wait for the app to finish loading.
A lot of things can happen in the background when your app is being launched. Your app may need to upload or download data before being ready to be used. Your app launches some processes to boot correctly a new session or restore an old one ... Well, depending on the user's phone processor and/or the bandwidth the phone has access to, the time to boot your app can vary a lot.
To reassure your users, you should mention in your splash screen that your app is loading, and that within a few seconds of patience, your user will be able to use and enjoy your app.
Note:-
Copied from here
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.
OK, I have a question regarding launch images on the iPad and orientation. Again, this is specifically regarding, launch images and has nothing to do with rotation/orientation once the application actually gets control.
Anyway, the Default.png resource is always loaded, regardless of orientation of the device, regardless of supported orientations, and regardless of Initial Interface Orientation. It just appears that the app is considered to be in Portrait until it is (possibly) auto-rotated later. I read something to this effect on the apple dev stuff, but given that there are launch images for these different orientations (Default-Landscape, Default-LandscapeLeft, etc.) I presumed that orientation was not fixed at launch.
The simple solution was to rotate my Default.png 90 degrees so that it is at least dimensionally correct, but that is not an acceptable solution unless it is the only solution. I did come across a reference to a folder called 'Resource-iPad' but have not been able to dig up much info in that regard.
Both the device and simulator seem consistent. I am targeting iPhone/iPad. Resources are in the root of main bundle, etc.
So, I must be missing something obvious, but I am not sure what and that is where you guys come in.
Thanks in advance,
Tom
If your app is universal, make sure you have two images for the iPad version -- one named "Default-Landscape~ipad.png" and one "Default-Portrait~ipad.png". Be careful of the tilde vs. dash in the names.
If it isn't universal, then just "Default-Portrait.png" and "Default-Landscape.png" should work. Not sure why it isn't working for you. Maybe having "Default.png" and "Default-Landscape.png" isn't an acceptable combination for the OS, in which case change Default.png to Default-Portrait.png
I know that most (if not all) landscape Splash Screens are made by rotating the picture 90°. This usually reflects the intended orientation once the app loads, and helps the user turn their iOS device accordingly.