Во-первых, здесь запись Apple, касающаяся отказа от темного режима. Содержимое этой ссылки написано для Xcode 11 и iOS 13:

Все приложение через файл info.plist (Xcode 12)

Используйте следующий ключ в вашем файле info.plist:

UIUserInterfaceStyle

И присвойте ему значение Light.

XML для UIUserInterfaceStyle назначения:

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

Документация Apple для UIUserInterfaceStyle

Все приложение через info.plist в настройках сборки (Xcode 13)

Окно всего приложения через свойство окна

Вы можете установить overrideUserInterfaceStyle напротив переменной приложения window. Это будет применяться ко всем представлениям, которые появляются в окне. Это стало доступно в iOS 13, поэтому для приложений, поддерживающих предыдущие версии, вы должны включить проверку доступности.

В зависимости от того, как был создан ваш проект, он может находиться в файле AppDelegate или SceneDelegate.

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

Индивидуальный UIViewController или UIView

Вы можете установить overrideUserInterfaceStyle напротив переменной UIViewControllers или UIView overrideUserInterfaceStyle. Это стало доступно в iOS 13, поэтому для приложений, поддерживающих предыдущие версии, вы должны включить проверку доступности.

Быстрый

override func viewDidLoad() {
    super.viewDidLoad()
    // overrideUserInterfaceStyle is available with iOS 13
    if #available(iOS 13.0, *) {
        // Always adopt a light interface style.
        overrideUserInterfaceStyle = .light
    }
}

Для тех бедняжек в Objective-C

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

Когда установлено против UIViewController, контроллер представления и его дочерние элементы принимают определенный режим.

Когда установлено против UIView, представление и его дочерние элементы принимают определенный режим.

Документация Apple по overrideUserInterfaceStyle

Индивидуальные представления через SwiftUI View

Вы можете установить preferredColorScheme равным light или dark. Указанное значение установит цветовую схему для презентации.

import SwiftUI

struct ContentView: View {
    var body: some View {
        Text("Light Only")
            .preferredColorScheme(.light)
    }
}

Документация Apple для PreferredColorScheme

Благодарим @Aron Nelson, @Raimundas Sakalauskas, @NSLeader и @rmaddy за улучшение этого ответа благодаря их отзывам. .

Согласно сеансу Apple «Внедрение темного режима в iOS» (https://developer.apple.com/videos/play/wwdc2019/214/, начиная с 31:13) можно установить overrideUserInterfaceStyle на UIUserInterfaceStyleLight или UIUserInterfaceStyleDark на любом контроллере представления или представлении, которое будет использоваться в traitCollection для любого подпредставления или просмотр контроллера.

Как уже упоминалось SeanR, вы можете установить UIUserInterfaceStyle на Light или Dark в файле plist вашего приложения, чтобы изменить это для всего вашего приложения.

Если вы не используете Xcode 11 или новее (например, SDK для iOS 13 или новее), ваше приложение не выбрало автоматически поддержку темного режима. Таким образом, нет необходимости отказываться от темного режима.

Если вы используете Xcode 11 или новее, система автоматически включила темный режим для вашего приложения. Есть два подхода к отключению темного режима в зависимости от ваших предпочтений. Вы можете отключить его полностью или отключить для любого конкретного окна, представления или контроллера представления.

Полностью отключите темный режим для своего приложения

Вы можете отключить темный режим, включив ключ UIUserInterfaceStyle со значением Light в файл Info.plist вашего приложения.

Это игнорирует предпочтения пользователя и всегда применяет светлый вид в ваше приложение.

Отключить темный режим для окна, представления или контроллера представления

Вы можете заставить свой интерфейс всегда отображаться в светлом или темном стиле, установив свойство 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

Примечание. Apple настоятельно рекомендует поддерживать темный режим в вашем приложении. Таким образом, вы можете временно отключить темный режим.

Подробнее читайте здесь: Выбор конкретного стиля интерфейса для вашего приложения iOS

********** Самый простой способ для Xcode 11 и выше ***********

Добавьте это в info.plist перед </dict></plist>

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

Думаю, я нашел решение. Сначала я собрал его по кусочкам из UIUserInterfaceStyle - Information Property List и UIUserInterfaceStyle - UIKit, но теперь мы обнаружили, что это фактически задокументировано на Выбор определенного стиля интерфейса для вашего приложения iOS.

В вашем info.plist установите для UIUserInterfaceStyle (Стиль пользовательского интерфейса) значение 1 (_ 3_).

РЕДАКТИРОВАТЬ: Согласно ответу дорбита, более подходящей настройкой для UIUserInterfaceStyle может быть Light.

Обновление Xcode 12 и iOS 14. Я попробовал предыдущие варианты отключения темного режима, и это предложение в файле info.plist у меня не работает:

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

Теперь он переименован в:

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

Этот параметр заблокирует все темные режимы в полном приложении.

ИЗМЕНИТЬ:

Исправлена ​​опечатка, спасибо @sarah

Приведенный выше ответ работает, если вы хотите отказаться от всего приложения. Если вы работаете над библиотекой с пользовательским интерфейсом, и у вас нет возможности редактировать .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"];
    }
}

Вы можете отключить темный режим во всем приложении в Xcode 11:

1. Перейти в Info.plist

2. Добавить ниже как

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

Info.plist будет выглядеть так, как показано ниже ...

Последнее обновление-

Если вы используете Xcode 10.x, то по умолчанию UIUserInterfaceStyle это light для iOS 13.x. При запуске на устройстве iOS 13 он будет работать только в облегченном режиме.

Нет необходимости явно добавлять ключ UIUserInterfaceStyle в файл Info.plist, его добавление приведет к ошибке при проверке приложения, например:

Неверный ключ Info.plist. Ключ UIUserInterfaceStyle в файле Payload / AppName.appInfo.plist недействителен.

Добавляйте ключ UIUserInterfaceStyle в файл Info.plist только при использовании Xcode 11.x.

Для всего приложения: (в файле info.plist):

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

Окно (обычно все приложение):

window!.overrideUserInterfaceStyle = .light

Вы можете получить окно с SceneDelegate

UIViewController:

viewController.overrideUserInterfaceStyle = .light

Вы можете установить любой viewController, даже внутри viewController, это self

UIView:

view.overrideUserInterfaceStyle = .light

Вы можете установить любой view, даже внутри вида, это само

Возможно, вам придется использовать if #available(iOS 13.0, *) { ,,, }, если вы поддерживаете более ранние версии iOS.

Просмотр SwiftUI:

.preferredColorScheme(.light) <- This Modifier

or

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

Если вы добавите ключ UIUserInterfaceStyle в файл plist, возможно, Apple отклонит сборку выпуска, как указано здесь: 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.

Обновление iOS 14.3 и Xcode 12.3

В файле info.plist добавьте Внешний вид как Светлый.

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

Помимо других ответов, насколько я понимаю, вам нужно подготовиться только к темному режиму при компиляции с iOS 13 SDK (с использованием XCode 11).

Система предполагает, что приложения, связанные с iOS 13 или более поздней версией SDK, поддерживают как светлый, так и темный вид. В iOS вы указываете конкретный внешний вид, который хотите, назначая определенный стиль интерфейса вашему окну, представлению или контроллеру представления. Вы также можете полностью отключить поддержку темного режима с помощью ключа Info.plist.

Ссылка

Swift 5

Два способа переключить темный режим на светлый:

1- info.plist

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

2- Программно или во время выполнения

  @IBAction private func switchToDark(_ sender: UIButton){
        UIApplication.shared.windows.forEach { window in
            //here you can switch between the dark and light
            window.overrideUserInterfaceStyle = .dark
        }
    }

На данный момент мое приложение не поддерживает темный режим и использует светлый цвет панели приложений. Мне удалось заставить содержимое строки состояния сделать темный текст и значки, добавив следующий ключ к моему 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

Не забудьте установить атрибут яркости панели приложения на панели приложения Flutter следующим образом:

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

Да, вы можете пропустить, добавив следующий код в viewDidLoad:

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

Objective-c версия

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

В Xcode 12 вы можете изменить добавление в качестве внешнего вида. Это будет работать !!

Добавить в info.plist

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

Вот несколько советов и приемов, которые вы можете использовать в своем приложении для поддержки или обхода темного режима.

Первый совет: переопределить стиль ViewController

вы можете переопределить стиль интерфейса UIViewController с помощью

1: overrideUserInterfaceStyle = .dark // Для темного режима

2: overrideUserInterfaceStyle = .light // Для светового режима

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

Второй совет: добавление ключа в info.plist

Просто вы можете добавить новый ключ

UIUserInterfaceStyle

в вашем приложении info.plist и установите для него значение Светлый или Темный. это заменит стиль приложения по умолчанию на указанное вами значение. Вам не нужно добавлять overrideUserInterfaceStyle = .light эту строку в каждый viewController, достаточно одной строки в info.plist.

Просто добавьте следующий ключ в свой info.plist файл:

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

Просто добавьте эту строку в файл info.plist:

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

Это заставит приложение работать только в облегченном режиме.

Да .. вы можете добавить настройку ниже в проект iOS.

В файле info.plist добавьте UIUserInterfaceStyle в Light.

Если ваш проект находится в IONIC .. Вы можете добавить настройки ниже в файл конфигурации

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

Используя эти настройки, темный режим устройства не повлияет на ваше приложение.

Я бы использовал это решение, поскольку свойство окна может быть изменено в течение жизненного цикла приложения. Поэтому присвоение overrideUserInterfaceStyle = .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
    }
}

Вы можете сделать: добавить этот новый ключ UIUserInterfaceStyle в Info.plist и установить для него значение Light. и проверьте, что контроллер предупреждений появляется в световом режиме.

UIUserInterfaceStyle Light Если вы включили светлый / темный режим во всем приложении независимо от настроек пользователя, добавив ключ UIUserInterfaceStyle в ваш файл Info.plist и установив для него значение Light или Dark.

На этот вопрос так много ответов, поэтому, используя его в info.plist, вы можете задать его в AppDelegate следующим образом:

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

Тест на Xcode 11.3, iOS 13.3

На самом деле я просто написал код, который позволит вам глобально отказаться от темного режима в коде без необходимости путаться с каждым отдельным контроллером viw в вашем приложении. Вероятно, это можно улучшить, чтобы отказаться от класса за классом, управляя списком классов. Что касается меня, то я хочу, чтобы мои пользователи видели, нравится ли им интерфейс темного режима для моего приложения, и, если он им не нравится, они могут его отключить. Это позволит им продолжать использовать темный режим для остальных своих приложений.

Выбор пользователя - это хорошо (кхм, глядя на вас, Apple, вот как вы должны были это реализовать).

Итак, как это работает, так это то, что это просто категория UIViewController. При загрузке он заменяет собственный метод viewDidLoad на метод, который будет проверять глобальный флаг, чтобы узнать, отключен ли темный режим для всего или нет.

Поскольку он запускается при загрузке UIViewController, он должен автоматически запускаться и отключать темный режим по умолчанию. Если это не то, что вы хотите, то вам нужно попасть туда пораньше и установить флаг, или просто установить флаг по умолчанию.

Я еще не написал ничего, чтобы ответить пользователю, включающим или выключающим флаг. Итак, это в основном пример кода. Если мы хотим, чтобы пользователь взаимодействовал с этим, необходимо перезагрузить все контроллеры представления. Я не знаю, как это сделать навскидку, но, вероятно, отправка какого-нибудь уведомления поможет. Итак, сейчас это глобальное включение / выключение темного режима будет работать только при запуске или перезапуске приложения.

Теперь недостаточно просто попытаться отключить темный режим в каждом отдельном контроллере просмотра MFING в вашем огромном приложении. Если вы используете цветные ассеты, вы полностью разочарованы. Мы уже более 10 лет понимаем, что неизменяемые объекты являются неизменяемыми. Цвета, которые вы получаете из каталога цветовых ресурсов, говорят, что они являются UIColor, но они являются динамическими (изменяемыми) цветами и будут меняться под вами, когда система переходит из темного режима в светлый. Это должна быть особенность. Но, конечно, нет главного переключателя, чтобы попросить эти вещи прекратить вносить это изменение (насколько я знаю прямо сейчас, может быть, кто-то сможет это улучшить).

Итак, решение состоит из двух частей:

1. общедоступная категория в UIViewController, которая предоставляет некоторые полезные и удобные методы ... например, я не думаю, что Apple задумывалась о том, что некоторые из нас добавляют веб-код в наши приложения. Таким образом, у нас есть таблицы стилей, которые необходимо переключать в зависимости от темного или светлого режима. Таким образом, вам нужно либо создать какой-то объект динамической таблицы стилей (что было бы хорошо), либо просто спросить, каково текущее состояние (плохо, но легко).

2. эта категория при загрузке заменит метод viewDidLoad класса UIViewController и перехватит вызовы. Я не знаю, нарушает ли это правила магазина приложений. Если это так, вероятно, есть другие способы обойти это, но вы можете считать это доказательством концепции. Вы можете, например, создать один подкласс всех основных типов контроллеров представления и сделать так, чтобы все ваши собственные контроллеры представления унаследовали от них, а затем вы можете использовать идею категории DarkMode и вызвать ее, чтобы принудительно отказаться от всех ваших контроллеров представления. Он уродливее, но никаких правил нарушать не собирается. Я предпочитаю использовать среду выполнения, потому что она была создана для этого. Итак, в моей версии вы просто добавляете категорию, вы устанавливаете глобальную переменную в категории для того, хотите ли вы, чтобы она блокировала темный режим, и она это сделает.

3. Вы еще не вышли из леса, как уже упоминалось, другая проблема заключается в том, что UIColor в основном делает все, что, черт возьми, хочет. Таким образом, даже если ваши контроллеры представления блокируют темный режим, UIColor не знает, где и как вы его используете, поэтому не может адаптироваться. В результате вы можете получить его правильно, но потом он вернется к вам в какой-то момент в будущем. Может, скоро, может, позже. Чтобы решить эту проблему, дважды выделите его с помощью CGColor и превратите в статический цвет. Это означает, что если ваш пользователь вернется и снова включит темный режим на вашей странице настроек (идея состоит в том, чтобы сделать эту работу так, чтобы пользователь мог контролировать ваше приложение над остальной системой), все эти статические цвета нужно заменить. Пока этот вопрос решает кто-то другой. Самый простой способ сделать это - установить по умолчанию, что вы отказываетесь от темного режима, разделить на ноль, чтобы вывести приложение из строя, поскольку вы не можете выйти из него, и попросить пользователя просто перезапустить его. Это, вероятно, также нарушает правила магазина приложений, но это идея.

Категория UIColor не нуждается в раскрытии, она просто работает, вызывая colorNamed: ... если вы не указали классу DarkMode ViewController блокировать темный режим, он будет работать идеально, как и ожидалось. Попытка сделать что-то элегантное вместо стандартного кода яблочного сфагетти, что означает, что вам придется изменить большую часть своего приложения, если вы хотите программно отказаться от темного режима или переключить его. Теперь я не знаю, есть ли лучший способ программно изменить Info.plist, чтобы отключить темный режим по мере необходимости. Насколько я понимаю, это функция времени компиляции, и после этого вас ждут.

Итак, вот код, который вам нужен. Следует зайти и просто использовать один метод для установки стиля пользовательского интерфейса или установить значение по умолчанию в коде. Вы можете свободно использовать, изменять и делать с ним все, что захотите, для любых целей, никаких гарантий не дается, и я не знаю, пройдет ли он в магазине приложений. Улучшения очень приветствуются.

Честно предупреждаю, что я не использую 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 - моя многоразовая библиотека, и это лишь ее часть. Если что-то не компилируется, дайте мне знать.