How can I delay splash launch screen programmatically in Swift Xcode iOS

Question

I have put an image in imageView in LaunchStoreyboard. How can I delay the time of image programmatically?

Here is the Launch Screen Guideline from Apple.

Here is code for Launch Screen View controller:

import UIKit
class LaunshViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        self.delay(0.4)
    }

    func delay(_ delay:Double, closure:@escaping ()->()) {
        let when = DispatchTime.now() + delay
        DispatchQueue.main.asyncAfter(deadline: when, execute: closure)
    }
}

Possible duplicate of [iOS: how to delay the launch screen?](http://stackoverflow.com/questions/35028449/ios-how-to-delay-the-launch-screen) — Oleg Gordiichuk, Apr 07 '17 at 10:49
My question is in Swift 3 but you suggested the Obj-C one @OlegGordiichuk — Xcodian Solangi, Apr 07 '17 at 10:57
approach that is suggested to be implement is quite suitable in you're case without dependency to the programing language. — Oleg Gordiichuk, Apr 07 '17 at 11:03
NOTE: the link to apple docs is out-dated, and they didn't re-direct. — benc, Jul 21 '22 at 06:17

Jack · Accepted Answer · 2022-10-22T14:59:01.677

80

As of today there is no predefine method from Apple to hold launch screen. Here are some Approaches which are not optimum but works

Approach #1 Create a Separate ViewController which has Launch logo & create a timer or perform some operation (Like Database/Loads some essential network call) depends on your app type this way you can ready with data before hand & hold the launch screen as well :)

Approach #2 Not Optimum

Use Sleep code which holds up the app for a while.

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
        Thread.sleep(forTimeInterval: 3.0)
        // Override point for customization after application launch.
        return true
    }

edited Oct 22 '22 at 14:59

answered Apr 07 '17 at 11:21

Jack

13,571
6
76
98

6

It is a very bad hack, not the right way to do it. @yoowim answer is also a hack but a good way to achieve the same. Apple otherwise doesn't provide any way to do this. – zeeshan Jan 26 '19 at 14:55
1

@zeeshan is there is any approach you can recommend instead of this – Munish Kapoor Sep 20 '19 at 02:42
1

@MunishKapoor I can suggest something, but first the explanation on why this is bad. When you do Thread.sleep (in this particular situation) you are blocking the main thread and preventing any progress the app should be doing naturally, which is, of course, dangerous. Now, what can you do to fix this? Simple: make your first ViewController look like the splash screen. This way you will be free to do any background computations or any kind of control over the normal flow of your app's launch. Once you're done with this ViewController, simply push or present a new ViewController. Hope it helped! – tf.alves Dec 14 '19 at 15:52

score 24 · Answer 2 · answered Mar 19 '18 at 08:34

Would not recommending setting the entire application in a waiting state. If the application needs to do more work before finishing the watchdog could kill the application for taking too long time to start up.

Instead you could do something like this to delay the launch screen.

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
        // Override point for customization after application launch.
        window = UIWindow(frame: UIScreen.main.bounds)
        window?.rootViewController = UIStoryboard(name: "LaunchScreen", bundle: nil).instantiateInitialViewController()
        window?.makeKeyAndVisible()

        DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 3) {
            self.window?.rootViewController = UIStoryboard(name: "Main", bundle: nil).instantiateInitialViewController()
        }
        return true
    }

score 23 · Answer 3 · edited Aug 22 '19 at 04:15

23

Swift 4.x

It is Not a good practice to put your application to sleep!

Booting your App should be as fast as possible, so the Launch screen delay is something you do not want to use.

But, instead of sleeping you can run a loop during which the receiver processes data from all attached input sources:

This will prolong the launch-screen's visibility time.

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
    // Override point for customization after application launch.

    RunLoop.current.run(until: NSDate(timeIntervalSinceNow:1) as Date)

    return true
}

edited Aug 22 '19 at 04:15

Forge

6,538
6
44
64

answered Aug 31 '18 at 08:39

yoowim

239
2
2

4

Warning: Date/NSDate is subject to leap seconds, timezone changes and winter/summer time adjustments. So trying to wait for 1 second could sometimes become waiting for 1 hour + 1 second. So don't use `RunLoop` like that, better use it with [`addTimer:forMode:`](https://developer.apple.com/documentation/foundation/runloop/1418468-add). – Cœur May 31 '19 at 17:17

score 23 · Answer 4 · answered May 02 '20 at 12:13

Swift 5.x, iOS 13.x.x

Modifying the following function in the AppDelegate class does not work in Swift 5.x/iOS 13.x.x.

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    // Override point for customization after application launch.
    return true
}

Instead, you will have to modify the scene function in SceneDelegate class as following. It will delay the LaunchSceen for 3 seconds.

func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {

    window?.rootViewController = UIStoryboard(name: "LaunchScreen", bundle: nil).instantiateInitialViewController()
    window?.makeKeyAndVisible()

    DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 3) {
        self.window?.rootViewController = UIStoryboard(name: "Main", bundle: nil).instantiateInitialViewController()
    }

    guard let _ = (scene as? UIWindowScene) else { return }
}

The window variable should already be there in SceneDelegate class like the following.

var window: UIWindow?

Unlike the previous answers, this is the solution which actually works. — Corbin Miller, May 04 '20 at 05:05

score 3 · Answer 5 · answered May 31 '19 at 16:29

Definitely your app should not be put to sleep as it may be killed by the OS for being unresponsive for so long.

If you're using a static image for your launch screen, what works for me is to use the image in the LaunchScreen.storyboard, and then when your main controller launches, modally present a VC with the same image as the background in the ViewDidAppear of your main controller (with animated set to false).

You can then use your logic to know when to dismiss the launch screen (dismiss method in the VC with animated set to false).

The transition from the actual LaunchScreen to my VC presenting the same screen looks to me imperceptible.

PS: the ViewDidAppear method might be called more than once, in which case you need to use logic to not present the VC with the launch screen a second time.

Saranjith · Answer 6 · 2017-07-10T12:29:06.247

2

Create a ViewController and use NSTimer to detect the delay time. and when the timer ends push the first UIViewcontroller.

In ViewDidLoad method..

[NSTimer scheduledTimerWithTimeInterval:2.0 target:self selector:@selector(fireMethod) userInfo:nil repeats:NO];


-(void)fireMethod
{
// push view controller here..
}

edited Jul 10 '17 at 12:29

answered Apr 07 '17 at 11:51

Saranjith

11,242
5
69
122

score 0 · Answer 7 · answered Dec 04 '22 at 20:42

0

Put one line of code in AppDelegate Class;

 func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
            // Override point for customization after application launch.
            Thread.sleep(forTimeInterval: 3.0)
            return true
    }

answered Dec 04 '22 at 20:42

Furkan E

1
3

Your answer could be improved with additional supporting information. Please [edit] to add further details, such as citations or documentation, so that others can confirm that your answer is correct. You can find more information on how to write good answers [in the help center](/help/how-to-answer). – Community Dec 07 '22 at 10:21

score -1 · Answer 8 · answered Jan 02 '22 at 08:45

SwiftUI

For SwiftUI, you can put a very similar code to the accepted answer into ContentView.onAppearing:

struct ContentView: View {

    var body: some View {
        Text("Hello")
        .onAppear {
            Thread.sleep(forTimeInterval: 3.0)
        }
    }
}

score -1 · Answer 9 · answered Feb 01 '22 at 09:35

Putting a thread to sleep is not a good idea.

I would suggest you go to SceneDelegate's "willConnectTo" function and paste this piece of code and you are good to go.

window?.rootViewController = UIStoryboard(name: "LaunchScreen", bundle: nil).instantiateInitialViewController()

window?.makeKeyAndVisible()
    
DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 3) {
        self.window?.rootViewController = UIStoryboard(name: "Main", bundle: nil).instantiateInitialViewController()
}
    
guard let _ = (scene as? UIWindowScene) else { return }

How can I delay splash launch screen programmatically in Swift Xcode iOS

9 Answers9

Linked