实际上，我写了一些代码，允许你在代码中全局选择退出暗模式，而不需要在应用程序中处理每个视图控制器。通过管理一个类列表，可以细化到在一个类的基础上选择退出。对我来说，我想让我的用户看看他们是否喜欢我的应用程序的黑暗模式界面，如果他们不喜欢，他们可以把它关掉。这将允许他们在其他应用程序中继续使用暗模式。

用户的选择是很好的(看看你苹果，这就是你应该实现的方式)。

它的工作原理是，它只是UIViewController的一个类别。当它加载时，它将原生的viewDidLoad方法替换为一个检查全局标志的方法，以查看是否所有内容都禁用了暗模式。

因为它是在UIViewController加载时触发的，默认情况下它应该自动启动并禁用暗模式。如果这不是你想要的，那么你需要提前在某个地方设置标志，或者只设置默认标志。

我还没有编写任何响应用户打开或关闭标志的代码。这就是示例代码。如果我们想让用户与这个交互，所有的视图控制器都需要重新加载。我不知道如何立即做到这一点，但可能发送一些通知将会做到这一点。现在，这个全局暗模式的开/关只会在应用启动或重启时起作用。

现在，仅仅尝试在你的大型应用程序中的每个MFING viewController中关闭暗模式是不够的。如果你使用颜色资产，你就完全完蛋了。十多年来，我们一直认为不可变对象是不可变的。你从颜色资产目录中获得的颜色是UIColor，但它们是动态(可变)的颜色，当系统从暗模式变为亮模式时，它们会在你下面发生变化。这应该是一个特色。但是，当然没有主切换来要求这些事情停止这种更改(据我所知，也许有人可以改进这一点)。

所以解决方案分为两部分:

1. UIViewController上的一个公共类别，提供了一些实用和方便的方法…例如，我认为苹果没有考虑到我们中的一些人在应用程序中混合了web代码。因此，样式表需要根据暗模式或亮模式进行切换。因此，您要么需要构建某种动态样式表对象(这很好)，要么只需询问当前状态(不好但很容易)。

2. 这个类别在加载时会替换UIViewController类的viewDidLoad方法并拦截调用。我不知道这是否违反了应用商店的规则。如果是这样的话，可能还有其他方法但你可以把它看作是概念的证明。例如，你可以为所有主视图控制器类型创建一个子类并让你自己的所有视图控制器继承那些，然后你可以使用DarkMode类别思想并调用它来强制选择出所有的视图控制器。它更丑了，但它不会打破任何规则。我更喜欢使用运行时，因为运行时就是用来做这个的。在我的版本中，你只需要添加category，在category上设置一个全局变量来决定是否要阻止暗模式，它就会这样做。

3. 如前所述，你还没有走出困境，另一个问题是UIColor基本上做了它想做的任何事情。所以即使你的视图控制器屏蔽了暗模式UIColor也不知道你在哪里或如何使用它，所以无法适应。因此，你可以正确地获取它，但在未来的某个时候，它会恢复给你。也许很快，也许稍后。因此，解决方法是使用CGColor分配它两次，并将其转换为静态颜色。这意味着如果你的用户返回并在设置页面上重新启用暗模式(这里的想法是让用户能够控制你的应用程序，而不是系统的其他部分)，所有这些静态颜色都需要替换。到目前为止，这个问题留给了别人去解决。最简单的方法就是设置默认退出暗模式，然后除以0让应用程序崩溃，因为你无法退出它，然后告诉用户重新启动它。这可能也违反了应用商店的指导方针，但这是一个想法。

UIColor类别不需要被暴露，它只需要调用colorNamed:…如果你没有告诉暗模式ViewController类来阻止暗模式，它会像预期的那样完美地工作。试着做一些优雅的东西而不是标准的苹果sphaghetti代码这意味着你需要修改大部分应用如果你想通过编程选择退出暗模式或切换它。现在我不知道是否有更好的方式来编程改变信息。请按需要关闭暗模式。就我的理解而言，这是一个编译时特性，之后你就完蛋了。

这是你需要的代码。应该使用一个方法来设置UI样式或在代码中设置默认值。你可以自由地使用，修改，做任何你想做的事情，没有保修，我不知道它是否能通过应用商店。非常欢迎改进。

警告一下，我不使用ARC或任何其他牵手方法。

////// H file


#import <UIKit/UIKit.h>


@interface UIViewController(DarkMode)


// if you want to globally opt out of dark mode you call these before any view controllers load
// at the moment they will only take effect for future loaded view controllers, rather than currently
// loaded view controllers


// we are doing it like this so you don't have to fill your code with @availables() when you include this
typedef enum {
QOverrideUserInterfaceStyleUnspecified,
QOverrideUserInterfaceStyleLight,
QOverrideUserInterfaceStyleDark,
} QOverrideUserInterfaceStyle;


// the opposite condition is light interface mode
+ (void)setOverrideUserInterfaceMode:(QOverrideUserInterfaceStyle)override;
+ (QOverrideUserInterfaceStyle)overrideUserInterfaceMode;


// utility methods
// this will tell you if any particular view controller is operating in dark mode
- (BOOL)isUsingDarkInterfaceStyle;
// this will tell you if any particular view controller is operating in light mode mode
- (BOOL)isUsingLightInterfaceStyle;


// this is called automatically during all view controller loads to enforce a single style
- (void)tryToOverrideUserInterfaceStyle;


@end




////// M file




//
//  QDarkMode.m


#import "UIViewController+DarkMode.h"
#import "q-runtime.h"




@implementation UIViewController(DarkMode)


typedef void (*void_method_imp_t) (id self, SEL cmd);
static void_method_imp_t _nativeViewDidLoad = NULL;
// we can't @available here because we're not in a method context
static long _override = -1;


+ (void)load;
{
#define DEFAULT_UI_STYLE UIUserInterfaceStyleLight
// we won't mess around with anything that is not iOS 13 dark mode capable
if (@available(iOS 13,*)) {
// default setting is to override into light style
_override = DEFAULT_UI_STYLE;
/*
This doesn't work...
NSUserDefaults *d = NSUserDefaults.standardUserDefaults;
[d setObject:@"Light" forKey:@"UIUserInterfaceStyle"];
id uiStyle = [d objectForKey:@"UIUserInterfaceStyle"];
NSLog(@"%@",uiStyle);
*/
if (!_nativeViewDidLoad) {
Class targetClass = UIViewController.class;
SEL targetSelector = @selector(viewDidLoad);
SEL replacementSelector = @selector(_overrideModeViewDidLoad);
_nativeViewDidLoad = (void_method_imp_t)QMethodImplementationForSEL(targetClass,targetSelector);
QInstanceMethodOverrideFromClass(targetClass, targetSelector, targetClass, replacementSelector);
}
}
}


// we do it like this because it's not going to be set often, and it will be tested often
// so we can cache the value that we want to hand to the OS
+ (void)setOverrideUserInterfaceMode:(QOverrideUserInterfaceStyle)style;
{
if (@available(iOS 13,*)){
switch(style) {
case QOverrideUserInterfaceStyleLight: {
_override = UIUserInterfaceStyleLight;
} break;
case QOverrideUserInterfaceStyleDark: {
_override = UIUserInterfaceStyleDark;
} break;
default:
/* FALLTHROUGH - more modes can go here*/
case QOverrideUserInterfaceStyleUnspecified: {
_override = UIUserInterfaceStyleUnspecified;
} break;
}
}
}
+ (QOverrideUserInterfaceStyle)overrideUserInterfaceMode;
{
if (@available(iOS 13,*)){
switch(_override) {
case UIUserInterfaceStyleLight: {
return QOverrideUserInterfaceStyleLight;
} break;
case UIUserInterfaceStyleDark: {
return QOverrideUserInterfaceStyleDark;
} break;
default:
/* FALLTHROUGH */
case UIUserInterfaceStyleUnspecified: {
return QOverrideUserInterfaceStyleUnspecified;
} break;
}
} else {
// we can't override anything below iOS 12
return QOverrideUserInterfaceStyleUnspecified;
}
}


- (BOOL)isUsingDarkInterfaceStyle;
{
if (@available(iOS 13,*)) {
if (self.traitCollection.userInterfaceStyle == UIUserInterfaceStyleDark){
return YES;
}
}
return NO;
}


- (BOOL)isUsingLightInterfaceStyle;
{
if (@available(iOS 13,*)) {
if (self.traitCollection.userInterfaceStyle == UIUserInterfaceStyleLight){
return YES;
}
// if it's unspecified we should probably assume light mode, esp. iOS 12
}
return YES;
}


- (void)tryToOverrideUserInterfaceStyle;
{
// we have to check again or the compile will bitch
if (@available(iOS 13,*)) {
[self setOverrideUserInterfaceStyle:(UIUserInterfaceStyle)_override];
}
}


// this method will be called via the viewDidLoad chain as we will patch it into the
// UIViewController class
- (void)_overrideModeViewDidLoad;
{
if (_nativeViewDidLoad) {
_nativeViewDidLoad(self,@selector(viewDidLoad));
}
[self tryToOverrideUserInterfaceStyle];
}




@end


// keep this in the same file, hidden away as it needs to switch on the global ... yeah global variables, I know, but viewDidLoad and colorNamed: are going to get called a ton and already it's adding some inefficiency to an already inefficient system ... you can change if you want to make it a class variable.


// this is necessary because UIColor will also check the current trait collection when using asset catalogs
// so we need to repair colorNamed: and possibly other methods
@interface UIColor(DarkMode)
@end


@implementation UIColor (DarkMode)


typedef UIColor *(*color_method_imp_t) (id self, SEL cmd, NSString *name);
static color_method_imp_t _nativeColorNamed = NULL;
+ (void)load;
{
// we won't mess around with anything that is not iOS 13 dark mode capable
if (@available(iOS 13,*)) {
// default setting is to override into light style
if (!_nativeColorNamed) {
// we need to call it once to force the color assets to load
Class targetClass = UIColor.class;
SEL targetSelector = @selector(colorNamed:);
SEL replacementSelector = @selector(_overrideColorNamed:);
_nativeColorNamed = (color_method_imp_t)QClassMethodImplementationForSEL(targetClass,targetSelector);
QClassMethodOverrideFromClass(targetClass, targetSelector, targetClass, replacementSelector);
}
}
}




// basically the colors you get
// out of colorNamed: are dynamic colors... as the system traits change underneath you, the UIColor object you
// have will also change since we can't force override the system traits all we can do is force the UIColor
// that's requested to be allocated out of the trait collection, and then stripped of the dynamic info
// unfortunately that means that all colors throughout the app will be static and that is either a bug or
// a good thing since they won't respond to the system going in and out of dark mode
+ (UIColor *)_overrideColorNamed:(NSString *)string;
{
UIColor *value = nil;
if (@available(iOS 13,*)) {
value = _nativeColorNamed(self,@selector(colorNamed:),string);
if (_override != UIUserInterfaceStyleUnspecified) {
// the value we have is a dynamic color... we need to resolve against a chosen trait collection
UITraitCollection *tc = [UITraitCollection traitCollectionWithUserInterfaceStyle:_override];
value = [value resolvedColorWithTraitCollection:tc];
}
} else {
// this is unreachable code since the method won't get patched in below iOS 13, so this
// is left blank on purpose
}
return value;
}
@end

这里有一组实用函数用于进行方法交换。单独的文件中。这是标准的东西，你可以在任何地方找到类似的代码。

// q-runtime.h


#import <Foundation/Foundation.h>
#import <objc/message.h>
#import <stdatomic.h>


// returns the method implementation for the selector
extern IMP
QMethodImplementationForSEL(Class aClass, SEL aSelector);


// as above but gets class method
extern IMP
QClassMethodImplementationForSEL(Class aClass, SEL aSelector);




extern BOOL
QClassMethodOverrideFromClass(Class targetClass, SEL targetSelector,
Class replacementClass, SEL replacementSelector);


extern BOOL
QInstanceMethodOverrideFromClass(Class targetClass, SEL targetSelector,
Class replacementClass, SEL replacementSelector);




// q-runtime.m


static BOOL
_QMethodOverride(Class targetClass, SEL targetSelector, Method original, Method replacement)
{
BOOL flag = NO;
IMP imp = method_getImplementation(replacement);
// we need something to work with
if (replacement) {
// if something was sitting on the SEL already
if (original) {
flag = method_setImplementation(original, imp) ? YES : NO;
// if we're swapping, use this
//method_exchangeImplementations(om, rm);
} else {
// not sure this works with class methods...
// if it's not there we want to add it
flag = YES;
const char *types = method_getTypeEncoding(replacement);
class_addMethod(targetClass,targetSelector,imp,types);
XLog_FB(red,black,@"Not sure this works...");
}
}
return flag;
}


BOOL
QInstanceMethodOverrideFromClass(Class targetClass, SEL targetSelector,
Class replacementClass, SEL replacementSelector)
{
BOOL flag = NO;
if (targetClass && replacementClass) {
Method om = class_getInstanceMethod(targetClass,targetSelector);
Method rm = class_getInstanceMethod(replacementClass,replacementSelector);
flag = _QMethodOverride(targetClass,targetSelector,om,rm);
}
return flag;
}




BOOL
QClassMethodOverrideFromClass(Class targetClass, SEL targetSelector,
Class replacementClass, SEL replacementSelector)
{
BOOL flag = NO;
if (targetClass && replacementClass) {
Method om = class_getClassMethod(targetClass,targetSelector);
Method rm = class_getClassMethod(replacementClass,replacementSelector);
flag = _QMethodOverride(targetClass,targetSelector,om,rm);
}
return flag;
}


IMP
QMethodImplementationForSEL(Class aClass, SEL aSelector)
{
Method method = class_getInstanceMethod(aClass,aSelector);
if (method) {
return method_getImplementation(method);
} else {
return NULL;
}
}


IMP
QClassMethodImplementationForSEL(Class aClass, SEL aSelector)
{
Method method = class_getClassMethod(aClass,aSelector);
if (method) {
return method_getImplementation(method);
} else {
return NULL;
}
}

因为q-runtime.h是我的可重用库，这只是它的一部分，所以我将它从几个文件中复制粘贴出来。如果有些东西没有编译让我知道。

如果你想退出整个应用程序，上面的答案是有效的。如果你在有UI的库上工作，并且你没有编辑.plist的奢侈，你也可以通过代码来做。

如果你正在编译iOS 13 SDK，你可以简单地使用以下代码:

迅速:

if #available(iOS 13.0, *) {
self.overrideUserInterfaceStyle = .light
}

Obj-C:

if (@available(iOS 13.0, *)) {
self.overrideUserInterfaceStyle = UIUserInterfaceStyleLight;
}

然而，如果你想让你的代码也针对iOS 12 SDK(目前仍然是最新的稳定SDK)编译，你应该使用选择器。使用选择器的代码:

Swift (XCode将显示此代码的警告，但这是目前唯一的方法，因为属性不存在于SDK 12，因此不会编译):

if #available(iOS 13.0, *) {
if self.responds(to: Selector("overrideUserInterfaceStyle")) {
self.setValue(UIUserInterfaceStyle.light.rawValue, forKey: "overrideUserInterfaceStyle")
}
}

Obj-C:

if (@available(iOS 13.0, *)) {
if ([self respondsToSelector:NSSelectorFromString(@"overrideUserInterfaceStyle")]) {
[self setValue:@(UIUserInterfaceStyleLight) forKey:@"overrideUserInterfaceStyle"];
}
}

如果你将在plist文件中添加UIUserInterfaceStyle键，苹果可能会拒绝发布构建，如这里所述:https://stackoverflow.com/a/56546554/7524146 无论如何，显式地告诉每个ViewController self.overrideUserInterfaceStyle = .light是很烦人的。但是你可以为你的根window对象使用此和平代码:

if #available(iOS 13.0, *) {
if window.responds(to: Selector(("overrideUserInterfaceStyle"))) {
window.setValue(UIUserInterfaceStyle.light.rawValue, forKey: "overrideUserInterfaceStyle")
}
}

请注意，你不能在application(application: didFinishLaunchingWithOptions:)中这样做，因为这个选择器在早期阶段不会响应true。但你可以以后再做。如果你在你的应用中使用自定义AppPresenter或AppRouter类，而不是在AppDelegate中自动启动UI，这非常简单。

除了其他回答，根据我对以下问题的理解，你只需要在对iOS 13 SDK(使用XCode 11)编译时准备Dark模式。

系统假设应用程序链接到iOS 13或更高版本的SDK 支持光明和黑暗的外观。在iOS中，你指定 通过指定特定的界面样式来指定您想要的特定外观 到您的窗口、视图或视图控制器。您也可以禁用支持 黑暗模式完全使用信息。plist关键。< / p >

Link

最新更新,

如果你用的是Xcode 10。x，那么默认的UIUserInterfaceStyle是iOS 13.x的light。当在iOS 13设备上运行时，它只能在灯光模式下工作。

不需要显式地在Info中添加UIUserInterfaceStyle键。plist文件，添加它将给出一个错误时，你验证你的应用程序，说:

无效的信息。plist关键。载荷/AppName.appInfo中的键'UIUserInterfaceStyle'。Plist文件无效。

只在Info中添加UIUserInterfaceStyle键。plist文件时使用Xcode 11.x。

对于整个应用程序:(在info.plist文件中):

<key>UIUserInterfaceStyle</key>
<string>Light</string>

窗口(通常是整个应用程序):

window!.overrideUserInterfaceStyle = .light

你可以从SceneDelegate中获取窗口

ui视图:

viewController.overrideUserInterfaceStyle = .light

你可以设置任何viewController，甚至在viewController内部的it自我

UIView:

view.overrideUserInterfaceStyle = .light

你可以设置任何view，甚至在视图中设置它的__abc1

如果你支持早期的iOS版本，你可能需要使用if #available(iOS 13.0, *) { ,,, }。

SwiftUI视图:

.preferredColorScheme(.light) <- This Modifier

或

.environment(\.colorScheme, .light) <- This Modifier

如果你没有使用Xcode 11或更高版本(即iOS 13或更高版本的SDK)，你的应用程序没有自动选择支持暗模式。所以，没有必要选择退出黑暗模式。

如果你使用的是Xcode 11或更高版本，系统会自动为你的应用启用暗模式。根据你的喜好，有两种方法来禁用暗模式。你可以完全禁用它，也可以为任何特定的窗口、视图或视图控制器禁用它。

禁用黑暗模式完全为您的应用程序

禁用窗口、视图或视图控制器的暗模式

通过设置适当窗口、视图或视图控制器的overrideUserInterfaceStyle属性，可以强制界面始终以浅色或深色样式显示。

视图控制器:

override func viewDidLoad() {
super.viewDidLoad()
/* view controller’s views and child view controllers
always adopt a light interface style. */
overrideUserInterfaceStyle = .light
}

视图:

// The view and all of its subviews always adopt light style.
youView.overrideUserInterfaceStyle = .light

亮点:

/* Everything in the window adopts the style,
including the root view controller and all presentation controllers that
display content in that window.*/
window.overrideUserInterfaceStyle = .light

注意:苹果强烈鼓励在你的应用中支持黑暗模式。

在这里阅读更多:为你的iOS应用选择特定的界面风格

是的，你可以跳过添加以下代码在viewDidLoad:

if #available(iOS 13.0, *) {
// Always adopt a light interface style.
overrideUserInterfaceStyle = .light
}

我的应用程序不支持黑暗模式，现在使用一个浅的应用程序栏颜色。通过在Info.plist中添加以下键，我可以强制状态栏内容为深色文本和图标:

<key>UIStatusBarStyle</key>
<string>UIStatusBarStyleDarkContent</string>
<key>UIUserInterfaceStyle</key>
<string>Light</string>
<key>UIViewControllerBasedStatusBarAppearance</key>
<true/>

在这里找到其他可能的值:https://developer.apple.com/documentation/uikit/uistatusbarstyle

颤振的用户

不要忘记在Flutter应用程序栏上设置应用程序栏亮度属性，如下所示:

AppBar(
backgroundColor: Colors.grey[100],
brightness: Brightness.light, // <---------
title: const Text('Hi there'),
),

********** Xcode 11以上的最容易的方法 ***********

将此添加到信息中。</dict></plist>前面的plist

<key>UIUserInterfaceStyle</key>
<string>Light</string>

我将使用这个解决方案，因为窗口属性可能会在应用程序生命周期中发生变化。因此需要重复分配" overrideuserinterfacstyle = .light"。UIWindow.appearance()使我们能够为新创建的UIWindow对象设置默认值。

import UIKit


@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {


var window: UIWindow?


func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {


if #available(iOS 13.0, *) {
UIWindow.appearance().overrideUserInterfaceStyle = .light
}


return true
}
}

这里有一些小贴士和技巧，你可以在你的应用程序中使用来支持或绕过黑暗模式。

第一个技巧:重写ViewController样式

你可以覆盖UIViewController的界面风格

1: overrideuserinterfacstyle = .dark //暗模式

2: overrideuserinterfacstyle = .light //光照模式

class ViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
overrideUserInterfaceStyle = .light
}
}

第二个技巧:在info.plist中添加一个键

您可以简单地添加一个新密钥

UIUserInterfaceStyle

在你的应用程序信息。plist，并将其值设置为Light或Dark。这将覆盖应用程序默认样式为您提供的值。 你不需要在每个viewController中添加overrideUserInterfaceStyle = .light这一行，只需在info中添加一行即可。

只需简单地在你的info.plist文件中添加以下键:

<key>UIUserInterfaceStyle</key>
<string>Light</string>

在Xcode 11中，你可以在整个应用中关闭黑暗的模式:

1. 去Info.plist

2. 添加波纹像

   <key>UIUserInterfaceStyle</key>
   <string>Light</string>
   

Info.plist will be look like below...

只需在info中添加这些行。plist文件:

<key>UIUserInterfaceStyle</key>
<string>light</string>

这将迫使应用程序只在轻模式下运行。

 if #available(iOS 13.0, *) {
overrideUserInterfaceStyle = .light
} else {
// Fallback on earlier versions
}

objective - c版本

 if (@available(iOS 13.0, *)) {
_window.overrideUserInterfaceStyle = UIUserInterfaceStyleLight;
}

import UIKit


extension UIViewController {


override open func awakeFromNib() {


super.awakeFromNib()


if #available(iOS 13.0, *) {


overrideUserInterfaceStyle = .light


}


}
}

你可以这样做:添加这个新键uiuserinterfacstyle到Info。plist，并将其值设置为Light。并检查警报控制器出现轻模式。

这个问题有很多答案，与其在info.plist中使用它，不如像这样在AppDelegate中设置它:

#if compiler(>=5.1)
if #available(iOS 13.0, *) {
self.window?.overrideUserInterfaceStyle = .light
}
#endif

在Xcode 11.3和iOS 13.3上测试

斯威夫特5

你可以通过这个链接下载一个演示项目:- https://github.com/rashidlatif55/DarkLightMode

两种方法切换暗到亮模式:

1 - info.plist

    <key>UIUserInterfaceStyle</key>
<string>Light</string>

2-程序化或运行时

  @IBAction private func switchToDark(_ sender: UIButton){
UIApplication.shared.windows.first?.overrideUserInterfaceStyle = .dark
}

Xcode 12和iOS 14更新。我已经尝试了之前的选项选择退出黑暗模式和这句话在信息。Plist文件不适合我:

<key>UIUserInterfaceStyle</key>
<string>Light</string>

现在它被重命名为:

<key>Appearance</key>
<string>Light</string>

此设置将阻止整个应用程序中的所有黑暗模式。

编辑:

修复了错别字，谢谢@sarah

将此添加到info.plist

<key>UIUserInterfaceStyle</key>
<string>Light</string>

iOS 14.3和Xcode 12.3更新

在信息。将外观添加为光. plist文件。

<key>Appearance</key>
<string>Light</string>

是的. .你可以在iOS项目中添加以下设置。

在信息。将uiuserinterfacstyle添加到Light中。

如果你的项目在IONIC..您可以在配置文件中添加以下设置

<platform name="ios">
<edit-config file="*-Info.plist" mode="merge" target="UIUserInterfaceStyle">
<string>Light</string>
</edit-config>
</platform>

使用这些设置，设备暗模式不会影响你的应用程序。

在ViewController.swift文件中添加overrideUserInterfaceStyle = .light 或将Appearance更改为“light”;在信息。plist文件