Vous devriez vérifier la variable userInterfaceStyle de UITraitCollection , comme sur tvOS et macOS.

switch traitCollection.userInterfaceStyle {
case .light: //light mode
case .dark: //dark mode
case .unspecified: //the user interface style is not specified
}

Vous devez utiliser la fonction traitCollectionDidChange(_ previousTraitCollection: UITraitCollection?) UIView / UIViewController pour détecter les changements dans l'environnement de l'interface (y compris les changements dans le style de l'interface utilisateur).

Depuis la documentation Apple Developer :

Le système appelle cette méthode lorsque l'environnement de l'interface iOS change. Implémentez cette méthode dans les contrôleurs de vue et les vues, en fonction des besoins de votre application, pour répondre à de tels changements. Par exemple, vous pouvez ajuster la disposition des sous-vues d'un contrôleur de vue lorsqu'un iPhone est pivoté de l'orientation portrait à l'orientation paysage. L'implémentation par défaut de cette méthode est vide.

Les éléments d'interface utilisateur par défaut du système (tels que UITabBar ou UISearchBar ) s'adaptent automatiquement au nouveau style d'interface utilisateur.

Comme mentionné par daveextreme, la vérification du style d'interface utilisateur de la vue actuelle ne renvoie pas toujours le style système lorsque vous utilisez la propriété overrideUserInterfaceStyle . Dans de tels cas, il peut être préférable d'utiliser le code suivant:

switch UIScreen.main.traitCollection.userInterfaceStyle {
case .light: //light mode
case .dark: //dark mode
case .unspecified: //the user interface style is not specified
}

Le meilleur point pour détecter les changements est la fonction traitCollectionDidChange (_ previousTraitCollection: UITraitCollection?) De UIView / UIViewController.

override func traitCollectionDidChange(_ previousTraitCollection: UITraitCollection?) {
    super.traitCollectionDidChange(previousTraitCollection)

    let hasUserInterfaceStyleChanged = previousTraitCollection.hasDifferentColorAppearance(comparedTo: traitCollection) // Bool
    // Update your user interface based on the appearance
}

La détection des changements d'apparence est simple en remplaçant traitCollectionDidChange sur les contrôleurs de vue. Ensuite, accédez simplement au traitCollection.userInterfaceStyle du contrôleur de vue.

Cependant, il est important de se rappeler que traitCollectionDidChange peut être appelé pour d'autres changements de trait, tels que la rotation de l'appareil. Vous pouvez vérifier si l'apparence actuelle est différente en utilisant cette nouvelle méthode:

override func traitCollectionDidChange(_ previousTraitCollection: UITraitCollection?) {
    super.traitCollectionDidChange(previousTraitCollection)

    let userInterfaceStyle = traitCollection.userInterfaceStyle // Either .unspecified, .light, or .dark
    // Update your user interface based on the appearance
}

dans objective-c vous voudriez faire:

if( self.traitCollection.userInterfaceStyle == UIUserInterfaceStyleDark ){

        //is dark
}else{

    //is light

}

Vous pouvez utiliser cette extension:

import UIKit

extension UIApplication {
    @available(iOS 13.0, *)
    var userInterfaceStyle: UIUserInterfaceStyle? {
        return self.keyWindow?.traitCollection.userInterfaceStyle
    }
}

@available(iOS 13.0, *)
    func setSystemTheme() {
        switch UIApplication.shared.userInterfaceStyle {
        case .dark?:
            currentTheme = .dark
        case .light?:
            currentTheme = .light
        default:
            break
        }
    }

Pour iOS 13 , vous pouvez utiliser cette propriété pour vérifier si le style actuel est en mode sombre ou non:

if #available(iOS 13.0, *) {
    if UITraitCollection.current.userInterfaceStyle == .dark {
        print("Dark mode")
    }
    else {
        print("Light mode")
    }
}

1 / pour UIView / UIViewController:

//Never use this! You will get wrong value in app extensions (ex. ToDay widget)
UIScreen.main.traitCollection.userInterfaceStyle == .dark //WRONG!

2 / pour statique ou autre:

UITraitCollection.current.userInterfaceStyle == .dark

MAIS:

self.traitCollection.userInterfaceStyle == .dark

Objectif c

Pour détecter lorsque le mode sombre est activé ou désactivé via le centre de contrôle, utilisez une notification «appDidBecomeActive» qui sera déclenchée lorsque vous reviendrez sur votre application.

//----------------------------------------------------------------------------
//                          appDidBecomeActive
//----------------------------------------------------------------------------
-(void)appDidBecomeActive:(NSNotification*)note {
    if (@available(iOS 13.0, *)) {
        if( self.traitCollection.userInterfaceStyle == UIUserInterfaceStyleDark ){
            //dark mode
        }
        else {
            //not dark mode
        }
    }
    else {
        //fall back for older versions
    }
}

N'oubliez pas de le supprimer lorsque vous avez terminé:

//------------------------------------------------------------------------------------
//                    viewWillDisappear
//------------------------------------------------------------------------------------
- (void)viewWillDisappear:(BOOL)animated
{
    [super viewWillDisappear:animated];

    [[NSNotificationCenter defaultCenter] removeObserver:self        
                                 name:UIApplicationDidBecomeActiveNotification 
                                 object:nil];

}

Faites ce dont vous avez besoin lorsque le mode sombre change:

//----------------------------------------------------------------------------
//                          viewWillAppear
//----------------------------------------------------------------------------
- (void)viewWillAppear {
    [super viewWillAppear];

    [[NSNotificationCenter defaultCenter]addObserver:self
                                   selector:@selector(appDidBecomeActive:)
                                   name:UIApplicationDidBecomeActiveNotification
                                   object:nil];

}

Créez une fonction de classe pour la méthode d'écriture 1 fois et utilisez-la partout où vous le souhaitez

func isDarkMode() -> Bool{
    if #available(iOS 12.0, *) {
        if UIScreen.main.traitCollection.userInterfaceStyle == .dark {
            return true
        } else {
            return false
        }
    } else {
       return false
    }
}  

Pour Swift:

if (@available(iOS 12.0, *)) {
        switch (UIScreen.mainScreen.traitCollection.userInterfaceStyle) {
            case UIUserInterfaceStyleDark:
                // put your dark mode code here
                break;
            case UIUserInterfaceStyleLight:
            case UIUserInterfaceStyleUnspecified:
                break;
            default:
                break;
        }
}

Pour l'objectif C:

if #available(iOS 12.0, *) {
  switch UIScreen.main.traitCollection.userInterfaceStyle {
    case .dark: // put your dark mode code here
    case .light: 
    case .unspecified: 
  }
}

Pour plus d'informations, regardez cette vidéo WWDC2019

Une belle extension peut-être?

public extension UIViewController {
    @available(iOS 12.0, *)
    public var isDarkMode: Bool { traitCollection.userInterfaceStyle == .dark }
}

Méthode d'assistance ci-dessous qui fonctionne sur n'importe quelle version iOS:

view.backgroundColor = isDarkMode ? .black : .white

Usage:

var isDarkMode: Bool {
    guard #available(iOS 12.0, *) else {
        return false
    }

    return UIScreen.main.traitCollection.userInterfaceStyle == .dark
}

Vous pouvez facilement détecter le mode sombre ou le mode clair avec cette méthode Swift 5

override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
if traitCollection.userInterfaceStyle == .light {
    print("Light mode")
} else {
    print("Dark mode")
}}

SwiftUI

Avec la clé \.colorScheme d'une variable d' Environment :

myUIView.traitCollection.userInterfaceStyle == .dark
myUIViewController.traitCollection.userInterfaceStyle == .dark

En outre, il se met automatiquement à jour lors du changement de la palette de couleurs de l'environnement.

---

UIKit

Pour vérifier le courant, tous les objets conformes au protocole UITraitEnvironment , y compris toutes les sous-classes UIView et toutes les sous-classes UIViewConttroller ont accès au style actuel:

struct ContentView: View {
    @Environment(\.colorScheme) var colorScheme

    var body: some View {
        Text(colorScheme == .dark ? "In dark mode" : "In light mode")
    }
}

Pour détecter les changements de style en direct, voici la réponse détaillée complète

Vous pouvez utiliser le code suivant pour vérifier le mode clair ou sombre dans votre projet:

override func traitCollectionDidChange(_ previousTraitCollection: UITraitCollection?) {
    super.traitCollectionDidChange(previousTraitCollection)

    let userInterfaceStyle = traitCollection.userInterfaceStyle // Either .unspecified, .light, or .dark
    // Update your user interface based on the appearance
}

Vous pouvez également vérifier les changements dans le style d'interface:

func viewDidLoad() {
    super.viewDidLoad()

    switch traitCollection.userInterfaceStyle {
        case .light, .unspecified:
            // light mode detected
        case .dark:
            // dark mode detected
    }
}

Tout comme dans macOS depuis Mojave, vous pouvez définir des images pour les modes clair et sombre dans votre catalogue d'actifs afin que ces images soient utilisées automatiquement:

isDarkMode ? .black : .white