Xcode 5 & Asset Catalog: Como fazer referência ao LaunchImage?

102

Estou usando o Catálogo de Ativos do Xcode 5 e gostaria de usá-lo LaunchImagecomo imagem de fundo de minha visualização inicial (uma prática bastante comum para fazer a transição de 'carregando' para 'carregado' parecer suave).

Gostaria de usar a mesma entrada no Catálogo de ativos para economizar espaço e não ter que replicar a imagem em dois conjuntos de imagens diferentes.

No entanto, ligando para:

UIImage *image = [UIImage imageNamed:@"LaunchImage"]; //returns nil
toblerpwn
fonte

Respostas:

83

Esta é a lista (quase) completa do LaunchImage (excluindo as imagens do iPad sem barra de status):

Pichirichi
fonte
Alguém conhece as imagens do iPad sem barra de status?
Mohamed Hafez
1
@Mohamed Hafez: Pichirichi realmente os inclui em sua lista. Eles são LaunchImage-Portrait ~ ipad.png, LaunchImage-Portrait@2x~ipad.png, LaunchImage-Landscape ~ ipad.png e LaunchImage-Landscape@2x~ipad.png.
John Jacecko
O que significam os números 700 e 800?
Sound Blaster
2
Eu percebi: significa iOS 7 e 8
Sound Blaster
4
É incrivelmente irritante que o XCode criará automaticamente um nome de arquivo para esses ativos de imagem e fará com que você se esforce para descobrir como acessá-los diretamente ...
Sr. T
67
- (NSString *)splashImageNameForOrientation:(UIInterfaceOrientation)orientation {
    CGSize viewSize = self.view.bounds.size;
    NSString* viewOrientation = @"Portrait";
    if (UIDeviceOrientationIsLandscape(orientation)) {
        viewSize = CGSizeMake(viewSize.height, viewSize.width);
        viewOrientation = @"Landscape";
    }

    NSArray* imagesDict = [[[NSBundle mainBundle] infoDictionary] valueForKey:@"UILaunchImages"];
    for (NSDictionary* dict in imagesDict) {
        CGSize imageSize = CGSizeFromString(dict[@"UILaunchImageSize"]);
        if (CGSizeEqualToSize(imageSize, viewSize) && [viewOrientation isEqualToString:dict[@"UILaunchImageOrientation"]])
            return dict[@"UILaunchImageName"];
    }
    return nil;
}
Cherpak Evgeny
fonte
1
Funciona bem. Abordagem inteligente e elegante para pesquisar o dicionário de informações do pacote principal para imagens de lançamento disponíveis e, em seguida, escolher aquela com a resolução correspondente!
iOSX
1
Esta é uma ideia brilhante, melhor do que a minha e também preparada para o futuro, a menos que a Apple mude a estrutura do info.plist.
nonamelive de
1
Esta é uma solução muito inteligente. Eu tenho vários destinos em meus projetos Xcode e apenas usar a string LaunchImage nem sempre retorna a imagem correta. Muito obrigado.
Enrico Susatyo
3
Embora uma ideia brilhante. Mas não funciona para telas com barra de status opaca. Então, precisava mudar self.view.bounds.size para [UIScreen mainScreen] .bounds.size
RamaKrishna Chunduri
1
Ótima solução. Pequena edição necessária: há uma conversão implícita de UIInterfaceOrientation para UIDeviceOrientation. Use em seu UIInterfaceOrientationIsLandscape()lugar.
Almog C
53

Os LaunchImages são especiais e não são realmente um catálogo de ativos no dispositivo. Se você olhar usando iFunBox / iExplorer / etc (ou no simulador, ou no diretório de compilação), você pode ver os nomes finais e escrever o código para usá-los - por exemplo. para um projeto apenas para iPhone apenas iOS7, isso definirá a imagem de inicialização certa:

NSString *launchImage;
if  ((UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPhone) &&
     ([UIScreen mainScreen].bounds.size.height > 480.0f)) {
    launchImage = @"LaunchImage-700-568h";
} else {
    launchImage = @"LaunchImage-700";
}

[self.launchImageView setImage:[UIImage imageNamed:launchImage]];

Coloquei isso em viewDidLoad.

Isso não é realmente ideal, seria ótimo se a Apple nos desse uma boa API para fazer isso.

JosephH
fonte
2
Isso funcionou para mim, mas eu realmente gostaria que houvesse uma maneira mais simples de referenciar a imagem de lançamento.
Zorayr
Talvez corrigido no Xcode 5.0.2 - veja abaixo, parece funcionar para mim simplesmente para fazer referência a "LaunchImage.png"
Adam
1
@Adam Adoraria se isso fosse verdade! Acabei de experimentar iphone5s / xcode5.0.2 / ios7.0.4, [UIImage imageNamed: @ "LaunchImage.png"] me dá nulo.
JosephH
@JosephH hmm. Talvez exija um projeto recém-criado? Este é um projeto criado no Xcode 5.0.2, apenas a mudança para os padrões foi "disabled ARC". Está funcionando muito bem :). Vou ver se consigo encontrar mais alguma coisa, mas não consigo pensar no que mais eu poderia ter mudado
Adam
Eu estava tentando um código semelhante, mas usando "Padrão" e "Padrão-568h" (os nomes dos arquivos de recursos originais). Depois de olhar dentro do pacote de aplicativos exportado, percebi que o Xcode altera os nomes para "LaunchImage-700 *".
Nicolas Miari
27

Meu aplicativo atualmente suporta apenas iOS 7 e posterior.

É assim que faço referência à imagem de lançamento do catálogo de ativos:

NSDictionary *dict = @{@"320x480" : @"LaunchImage-700",
                       @"320x568" : @"LaunchImage-700-568h",
                       @"375x667" : @"LaunchImage-800-667h",
                       @"414x736" : @"LaunchImage-800-Portrait-736h"};
NSString *key = [NSString stringWithFormat:@"%dx%d",
    (int)[UIScreen mainScreen].bounds.size.width,
    (int)[UIScreen mainScreen].bounds.size.height];
UIImage *launchImage = [UIImage imageNamed:dict[key]];

Você pode adicionar mais pares de valores-chave se quiser oferecer suporte a versões mais antigas do iOS.

não-amanteigado
fonte
1
Observe que a partir do iOS 8, UIScreen.mainScreen.boundsé diferente dependendo da orientação atual da interface. Consulte stackoverflow.com/a/24153540/158525
Jean Regisser
1
Obrigado por isso, exatamente o que eu estava procurando!
Joseph Paterson
Obrigado por htis, algum método para acessar ícones de aplicativos?
AsifHabib 01 de
10

Aqui está uma categoria no UIImage baseada na solução fornecida por Cherpak Evgeny acima.

UIImage + SplashImage.h :

#import <UIKit/UIKit.h>

/**
 * Category on `UIImage` to access the splash image.
 **/
@interface UIImage (SplashImage)

/**
 * Return the name of the splash image for a given orientation.
 * @param orientation The interface orientation.
 * @return The name of the splash image.
 **/
+ (NSString *)si_splashImageNameForOrientation:(UIInterfaceOrientation)orientation;

/**
 * Returns the splash image for a given orientation.
 * @param orientation The interface orientation.
 * @return The splash image.
 **/
+ (UIImage*)si_splashImageForOrientation:(UIInterfaceOrientation)orientation;

@end

UIImage + SplashImage.m :

#import "UIImage+SplashImage.h"

@implementation UIImage (SplashImage)

+ (NSString *)si_splashImageNameForOrientation:(UIInterfaceOrientation)orientation
{
    CGSize viewSize = [UIScreen mainScreen].bounds.size;

    NSString *viewOrientation = @"Portrait";

    if (UIDeviceOrientationIsLandscape(orientation))
    {
        viewSize = CGSizeMake(viewSize.height, viewSize.width);
        viewOrientation = @"Landscape";
    }

    NSArray* imagesDict = [[[NSBundle mainBundle] infoDictionary] valueForKey:@"UILaunchImages"];

    for (NSDictionary *dict in imagesDict)
    {
        CGSize imageSize = CGSizeFromString(dict[@"UILaunchImageSize"]);
        if (CGSizeEqualToSize(imageSize, viewSize) && [viewOrientation isEqualToString:dict[@"UILaunchImageOrientation"]])
            return dict[@"UILaunchImageName"];
    }
    return nil;
}

+ (UIImage*)si_splashImageForOrientation:(UIInterfaceOrientation)orientation
{
    NSString *imageName = [self si_splashImageNameForOrientation:orientation];
    UIImage *image = [UIImage imageNamed:imageName];
    return image;
}

@end
Vilanovi
fonte
imageNamed envia a imagem para o cache do sistema, mas a imagem de inicialização às vezes é muito grande, por isso fica na memória até que o cache a
libere
9

Resposta de @ codeman atualizada para Swift 1.2:

func splashImageForOrientation(orientation: UIInterfaceOrientation, size: CGSize) -> String? {
    var viewSize        = size
    var viewOrientation = "Portrait"

    if UIInterfaceOrientationIsLandscape(orientation) {
        viewSize        = CGSizeMake(size.height, size.width)
        viewOrientation = "Landscape"
    }

    if let imagesDict = NSBundle.mainBundle().infoDictionary as? [String: AnyObject] {
        if let imagesArray = imagesDict["UILaunchImages"] as? [[String: String]] {
            for dict in imagesArray {
                if let sizeString = dict["UILaunchImageSize"], let imageOrientation = dict["UILaunchImageOrientation"] {
                    let imageSize = CGSizeFromString(sizeString)
                    if CGSizeEqualToSize(imageSize, viewSize) && viewOrientation == imageOrientation {
                        if let imageName = dict["UILaunchImageName"] {
                            return imageName
                        }
                    }
                }
            }
        }
    }

    return nil

}

Para chamá-lo e apoiar a rotação para iOS 8:

override func viewWillAppear(animated: Bool) {
    if let img = splashImageForOrientation(UIApplication.sharedApplication().statusBarOrientation, size: self.view.bounds.size) {
        backgroundImage.image = UIImage(named: img)
    }
}

override func viewWillTransitionToSize(size: CGSize, withTransitionCoordinator coordinator: UIViewControllerTransitionCoordinator) {
    let orientation = size.height > size.width ? UIInterfaceOrientation.Portrait : UIInterfaceOrientation.LandscapeLeft

    if let img = splashImageForOrientation(orientation, size: size) {
        backgroundImage.image = UIImage(named: img)
    }

}

Exatamente o que eu precisava, obrigado!

Anthony Scott
fonte
7

Acabei de escrever um método geral para obter o nome da imagem inicial para iPhone e iPad (paisagem, retrato), funcionou para mim, espero que ajude você também. Escrevi isso com a ajuda de outras respostas do SO, obrigado @Pichirichi pela lista completa.

+(NSString*)getLaunchImageName
{

 NSArray* images= @[@"LaunchImage.png", @"[email protected]",@"[email protected]",@"[email protected]",@"[email protected]",@"LaunchImage-700-Portrait@2x~ipad.png",@"LaunchImage-Portrait@2x~ipad.png",@"LaunchImage-700-Portrait~ipad.png",@"LaunchImage-Portrait~ipad.png",@"LaunchImage-Landscape@2x~ipad.png",@"LaunchImage-700-Landscape@2x~ipad.png",@"LaunchImage-Landscape~ipad.png",@"LaunchImage-700-Landscape~ipad.png"];

UIImage *splashImage;

if ([self isDeviceiPhone])
{
    if ([self isDeviceiPhone4] && [self isDeviceRetina])
    {
        splashImage = [UIImage imageNamed:images[1]];
        if (splashImage.size.width!=0)
            return images[1];
        else
            return images[2];
    }
    else if ([self isDeviceiPhone5])
    {
        splashImage = [UIImage imageNamed:images[1]];
        if (splashImage.size.width!=0)
            return images[3];
        else
            return images[4];
    }
    else
        return images[0]; //Non-retina iPhone
}
else if ([[UIDevice currentDevice] orientation]==UIDeviceOrientationPortrait || [[UIDevice currentDevice] orientation] == UIDeviceOrientationPortraitUpsideDown)//iPad Portrait
{
    if ([self isDeviceRetina])
    {
        splashImage = [UIImage imageNamed:images[5]];
        if (splashImage.size.width!=0)
            return images[5];
        else
            return images[6];
    }
    else
    {
        splashImage = [UIImage imageNamed:images[7]];
        if (splashImage.size.width!=0)
            return images[7];
        else
            return images[8];
    }

}
else
{
    if ([self isDeviceRetina])
    {
        splashImage = [UIImage imageNamed:images[9]];
        if (splashImage.size.width!=0)
            return images[9];
        else
            return images[10];
    }
    else
    {
        splashImage = [UIImage imageNamed:images[11]];
        if (splashImage.size.width!=0)
            return images[11];
        else
            return images[12];
    }
 }
}

Outros métodos utilitários são

+(BOOL)isDeviceiPhone
{
 if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPhone)
 {
     return TRUE;
 }

 return FALSE;
}

+(BOOL)isDeviceiPhone4
{
 if ([[UIScreen mainScreen] bounds].size.height==480)
    return TRUE;

 return FALSE;
}


+(BOOL)isDeviceRetina
{
 if ([[UIScreen mainScreen] respondsToSelector:@selector(displayLinkWithTarget:selector:)] &&
    ([UIScreen mainScreen].scale == 2.0))        // Retina display
 {
    return TRUE;
 } 
 else                                          // non-Retina display
 {
     return FALSE;
 }
}


+(BOOL)isDeviceiPhone5
{
 if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPhone && [[UIScreen mainScreen] bounds].size.height>480)
 {
    return TRUE;
 }
 return FALSE;
}
zaheer
fonte
Na verdade, há um pequeno bug neste código para isDeviceiPhone4: [[UIScreen mainScreen] limites] agora muda com base na orientação em que você está no iOS 8. Você precisará convertê-lo explicitamente em limites de retrato fazendo algo como:, [screen.coordinateSpace convertRect:screen.bounds toCoordinateSpace:screen.fixedCoordinateSpace]mas faça certifique-se de testar se você está no iOS 8 primeiro, caso contrário, ele travará.
Mohamed Hafez
Obrigado @Hafez por apontar isso, vou testá-lo para iOS 8 e atualizar a resposta em breve.
zaheer
7

Versão rápida da resposta de Cherpak Evgeny:

    func splashImageForOrientation(orientation: UIInterfaceOrientation) -> String {
        var viewSize = self.view.bounds.size
        var viewOrientation = "Portrait"
        if UIInterfaceOrientationIsLandscape(orientation) {
           viewSize = CGSizeMake(viewSize.height, viewSize.width)
           viewOrientation = "Landscape"
        }
        let imagesDict = NSBundle.mainBundle().infoDictionary as Dictionary<NSObject,AnyObject>!
        let imagesArray = imagesDict["UILaunchImages"] as NSArray
        for dict in imagesArray {
            let dictNSDict = dict as NSDictionary
            let imageSize = CGSizeFromString(dictNSDict["UILaunchImageSize"] as String)
            if CGSizeEqualToSize(imageSize, viewSize) && viewOrientation == (dictNSDict["UILaunchImageOrientation"] as String) {
                return dictNSDict["UILaunchImageName"] as String
            }
        }
        return ""
    }
codificador
fonte
5

Seguindo a resposta de @Pichirich, referenciei minha imagem de lançamento no InterfaceBuilder como:

"LaunchImage.png"

... e com o Xcode 5.0.2, ele está retirando automaticamente a imagem apropriada diretamente do Catálogo de ativos.

Isso é o que eu esperava - exceto pelo movimento cruelmente desagradável da Apple de silenciosamente renomear "Default.png" para "LaunchImage.png" :)

Adão
fonte
Mais uma coisa deve ser observada. Os tamanhos dessas imagens devem ser exatamente como a Apple recomenda (320x480 para LaunchImage para iOS 5-6 iPhone 3GS, por exemplo), caso contrário, seriam nilapós a inicialização
Alexander Kostiev
3

Na documentação está claramente indicado:

"Cada conjunto em um catálogo de ativos tem um nome . Você pode usar esse nome para carregar programaticamente qualquer imagem individual contida no conjunto. Para carregar uma imagem, chame o método UIImage: ImageNamed : , passando o nome do conjunto que contém a imagem . "

Usar a lista de Pichirichi ajuda a resolver essa inconsistência.

Vladimír Slavík
fonte
1
Observe a parte "nome do conjunto". Olhando para meu catálogo de ativos, tenho um conjunto chamado "LaunchImage". Para carregar a imagem de lançamento, então, chamei: UIImageView *myView = [[UIImageView alloc] initWithImage:[UIImage imageNamed:@"LaunchImage"]];Funciona muito bem!
leanne
1
Não há necessidade de usar a lista de Pichirichi (pensei que ainda seja uma informação incrível de saber) - apenas use o nome do "conjunto" do catálogo de ativos.
leanne
2
Bem, para mim isso não funciona para o Launch Image no Xcode 6.0.1 e iOS 8. O LaunchImage parece ser especial, pois as imagens terminam individualmente no pacote de aplicativos compilado e não permanecem dentro da pasta do pacote xcasset.
auco
O que acontecerá se houver dois catálogos de ativos diferentes contendo conjuntos com nomes idênticos? Como [UIImage imageNamed:..]saberia qual escolher?
Carlos P
Para mim, isso não funciona, XCode 6.0.1 iOS 7 iPod Touch
dev
3

Pode-se acessar facilmente a imagem do Launch por uma linha de código.

 UIImage *myAppsLaunchImage = [UIImage launchImage];

Siga as etapas fornecidas abaixo para obter a funcionalidade descrita acima.

Etapa 1. Estenda aUIImageclasse criando uma categoria e adicione o método a seguir a ela.

+ (UIImage *)launchImage {
    NSDictionary *dOfLaunchImage = [NSDictionary dictionaryWithObjectsAndKeys:
                                    @"[email protected]",@"568,320,2,8,p", // ios 8 - iphone 5 - portrait
                                    @"[email protected]",@"568,320,2,8,l", // ios 8 - iphone 5 - landscape
                                    @"[email protected]",@"568,320,2,7,p", // ios 7 - iphone 5 - portrait
                                    @"[email protected]",@"568,320,2,7,l", // ios 7 - iphone 5 - landscape
                                    @"LaunchImage-700-Landscape@2x~ipad.png",@"1024,768,2,7,l", // ios 7 - ipad retina - landscape
                                    @"LaunchImage-700-Landscape~ipad.png",@"1024,768,1,7,l", // ios 7 - ipad regular - landscape
                                    @"LaunchImage-700-Portrait@2x~ipad.png",@"1024,768,2,7,p", // ios 7 - ipad retina - portrait
                                    @"LaunchImage-700-Portrait~ipad.png",@"1024,768,1,7,p", // ios 7 - ipad regular - portrait
                                    @"[email protected]",@"480,320,2,7,p", // ios 7 - iphone 4/4s retina - portrait
                                    @"[email protected]",@"480,320,2,7,l", // ios 7 - iphone 4/4s retina - landscape
                                    @"LaunchImage-Landscape@2x~ipad.png",@"1024,768,2,8,l", // ios 8 - ipad retina - landscape
                                    @"LaunchImage-Landscape~ipad.png",@"1024,768,1,8,l", // ios 8 - ipad regular - landscape
                                    @"LaunchImage-Portrait@2x~ipad.png",@"1024,768,2,8,p", // ios 8 - ipad retina - portrait
                                    @"LaunchImage-Portrait~ipad.png",@"1024,768,1,8,l", // ios 8 - ipad regular - portrait
                                    @"LaunchImage.png",@"480,320,1,7,p", // ios 6 - iphone 3g/3gs - portrait
                                    @"LaunchImage.png",@"480,320,1,7,l", // ios 6 - iphone 3g/3gs - landscape
                                    @"[email protected]",@"480,320,2,8,p", // ios 6,7,8 - iphone 4/4s - portrait
                                    @"[email protected]",@"480,320,2,8,l", // ios 6,7,8 - iphone 4/4s - landscape
                                    @"[email protected]",@"667,375,2,8,p", // ios 8 - iphone 6 - portrait
                                    @"[email protected]",@"667,375,2,8,l", // ios 8 - iphone 6 - landscape
                                    @"[email protected]",@"736,414,3,8,p", // ios 8 - iphone 6 plus - portrait
                                    @"[email protected]",@"736,414,3,8,l", // ios 8 - iphone 6 plus - landscape
                                    nil];
    NSInteger width = ([UIScreen mainScreen].bounds.size.width>[UIScreen mainScreen].bounds.size.height)?[UIScreen mainScreen].bounds.size.width:[UIScreen mainScreen].bounds.size.height;
    NSInteger height = ([UIScreen mainScreen].bounds.size.width>[UIScreen mainScreen].bounds.size.height)?[UIScreen mainScreen].bounds.size.height:[UIScreen mainScreen].bounds.size.width;
    NSInteger os = [[[[[UIDevice currentDevice] systemVersion] componentsSeparatedByString:@"."] objectAtIndex:0] integerValue];
    NSString *strOrientation = UIDeviceOrientationIsLandscape([[UIDevice currentDevice] orientation])?@"l":@"p";
    NSString *strImageName = [NSString stringWithFormat:@"%li,%li,%li,%li,%@",width,height,(NSInteger)[UIScreen mainScreen].scale,os,strOrientation];
    UIImage *imageToReturn = [UIImage imageNamed:[dOfLaunchImage valueForKey:strImageName]];
    if([strOrientation isEqualToString:@"l"] && [strImageName rangeOfString:@"Landscape"].length==0) {
        imageToReturn = [UIImage rotate:imageToReturn orientation:UIImageOrientationRight];
    }
    return imageToReturn;
}

Etapa 2. O método acima deve funcionar adicionando o código a seguir também na mesma categoria deUIImage

static inline double radians (double degrees) {return degrees * M_PI/180;}

+ (UIImage *)rotate:(UIImage*)src orientation:(UIImageOrientation) orientation {
    UIGraphicsBeginImageContext(src.size);
    CGContextRef context = UIGraphicsGetCurrentContext();
    if (orientation == UIImageOrientationRight) {
        CGContextRotateCTM (context, radians(90));
    } else if (orientation == UIImageOrientationLeft) {
        CGContextRotateCTM (context, radians(-90));
    } else if (orientation == UIImageOrientationDown) {
        // NOTHING
    } else if (orientation == UIImageOrientationUp) {
        CGContextRotateCTM (context, radians(90));
    }
    [src drawAtPoint:CGPointMake(0, 0)];
    UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();
    return image;
}
Sagar R. Kothari
fonte
Excelente resposta, obrigado!
dortzur,
1
Qual é o nome da imagem de lançamento do iPhone X agora?
RPM de
2

Sei que essa não é necessariamente a melhor solução para todos, mas a maneira mais fácil (e menos propensa a erros, IMHO) de fazer isso é fazendo uma entrada separada em seu catálogo Images.xcassets. Eu chamei SplashImage.

Quando for adicionar uma nova entrada, certifique-se de não selecionar "Nova imagem de inicialização" como uma opção. Em vez disso, selecione o genérico "Novo conjunto de imagens". Em seguida, abra o inspetor e selecione as opções relevantes. Se você estiver construindo apenas para dispositivos de retina, como eu, você pode selecionar o seguinte:

inspetor de imagem

Isso deixará você com quatro entradas (iPhone 4S, iPhone 5 (s, c), iPhone 6 e iPhone 6 Plus).

imagens

Os arquivos correspondentes às imagens são os seguintes:

| Resolution (Xcode entry) | Launch Image name   |   Device         |
|--------------------------|---------------------|------------------|
| 1x                       | Default-750.png     | iPhone 6         |
| 2x                       | Default@2x.png      | iPhone 4S        |
| Retina 4 2x              | Default-568h@2x.png | iPhone 5, 5s, 5c |
| 3x                       | Default-1242.png    | iPhone 6 Plus    |

Claro, depois de fazer isso, você pode simplesmente usar [UIImage imageNamed:@"SplashImage"]

Michael DiStefano
fonte
1
Ideia interessante, mas não funciona no iPhone 6. Ele ainda carrega a imagem [email protected] no simulador do iPhone 6.
nonamelive de
Usando essa abordagem, você também deve tomar cuidado com o conjunto de imagens de lançamento para a orientação paisagem.
berec
2

Com a ajuda da resposta de Pichirichi, implementei a seguinte categoria (iOS 7 +): UIImage + AssetLaunchImage

Na verdade, é pouco mais do que gerar nomes instantaneamente, mas provavelmente será útil.

Timur Kuchkarov
fonte
0

Atualizado para a sintaxe Swift mais recente (Swift 5)

   func splashImageForOrientation(orientation: UIInterfaceOrientation) -> String? {

    var viewSize = screenSize
    var viewOrientation = "Portrait"
    if orientation.isLandscape {
        viewSize = CGSize(width: viewSize.height, height: viewSize.width)
        viewOrientation = "Landscape"
    }
    if let infoDict = Bundle.main.infoDictionary, let launchImagesArray = infoDict["UILaunchImages"] as? [Any] {
        for launchImage in launchImagesArray {
            if let launchImage = launchImage as? [String: Any], let nameString = launchImage["UILaunchImageName"] as? String, let sizeString = launchImage["UILaunchImageSize"] as? String, let orientationString = launchImage["UILaunchImageOrientation"] as? String {
                let imageSize = NSCoder.cgSize(for: sizeString)
                if imageSize.equalTo(viewSize) && viewOrientation == orientationString {
                    return nameString
                }
            }
        }
    }
    return nil
}
pegpeg
fonte