Access Library's Swift methods inside Project's AppDelegate.mm (Turbo Modules)

[gladiuscode]

Hi everyone!
First things first: I'm a true newbie when it comes to iOS native development, so take everything I write with a lot of doubt, because I am not even sure that it could be done in the first place.

I'm trying to develop a local library that should allow us to "simply" lock the orientation to either portrait or landscape depending the business logic.
So the idea is: "By default i want every screen to be in Portrait, while a given screen B, for example, should be able to follow the screen orientation, therefore we must allow Landscape mode too".

I've managed to properly set it up using Kotlin and it does work, however the same can't be said for Swift.
Taking a step back: "Why don't you use Objective C?" simply put: "I'd like to develop something using a modern approach, because there is a clean syntax and more documentation / examples in the wild west"

That said, I've created the following project structure:

Orientation.m

#import <React/RCTBridgeModule.h>

#ifdef RCT_NEW_ARCH_ENABLED
#import "RNOrientationSpec.h"
@interface RCT_EXTERN_MODULE(Orientation, NSObject<NativeOrientationSpec>)
#else
@interface RCT_EXTERN_MODULE(Orientation, NSObject<RCTBridgeModule>)
#endif

RCT_EXTERN_METHOD(unlockOrientation)
RCT_EXTERN_METHOD(lockToPortrait)

// Don't compile this code when we build for the old architecture.
#ifdef RCT_NEW_ARCH_ENABLED
- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
    (const facebook::react::ObjCTurboModule::InitParams &)params
{
    return std::make_shared<facebook::react::NativeOrientationSpecJSI>(params);
}
#endif

@end

Orientation.swift

import Foundation
import UIKit

@objc(Orientation) 
public class Orientation: NSObject {
    
    var selectedOrientation: UIInterfaceOrientation = UIInterfaceOrientation.unknown
    
    @objc
    static func moduleName() -> String {
        return "Orientation"
    }
    
    @objc
    static func requiresMainQueueSetup() -> Bool {
       return true
    }
    
    @objc
    override init() {
        super.init()
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(orientationDidChange),
            name: UIDevice.orientationDidChangeNotification,
            object: nil
        )
        setSelectedOrientation(orientation: getCurrentOrientation())
    }
    
    deinit {
         NotificationCenter.default.removeObserver(self)
    }
    
    @objc
    public func setSelectedOrientation(orientation: UIInterfaceOrientation) {
        print("Orientation - setSelectedOrientation")
        selectedOrientation = orientation
    }
    
    @objc
    public func getSelectedOrientation() -> UIInterfaceOrientation {
        print("Orientation - getSelectedOrientation")
        return selectedOrientation
    }
    
    @objc
    func unlockOrientation() {
        print("Orientation - unlockOrientation")
        UIDevice.current.setValue(UIInterfaceOrientationMask.allButUpsideDown.rawValue, forKey: "orientation")
        self.adaptToNewOrientation(orientation: UIInterfaceOrientationMask.allButUpsideDown)
    }
    
    @objc
    func lockToPortrait() {
        print("Orientation - lockToPotrait")
        UIDevice.current.setValue(UIInterfaceOrientationMask.portrait.rawValue, forKey: "orientation")
        self.adaptToNewOrientation(orientation: UIInterfaceOrientationMask.portrait)
    }
    
    func adaptToNewOrientation(orientation: UIInterfaceOrientationMask) {
        DispatchQueue.main.async {
            if #available(iOS 16.0, *) {
                guard let window = self.getCurrentWindow() else {
                    print("Orientation - no window available")
                    return
                }
                
                guard let rootViewController = window.rootViewController else {
                    print("Orientation - no rootViewController available")
                    return
                }
            
                guard let windowScene = window.windowScene else {
                    print("Orientation - no windowScene available")
                    return
                }
                
                rootViewController.setNeedsUpdateOfSupportedInterfaceOrientations()
                
                rootViewController.supportedInterfaceOrientations
                
                windowScene.requestGeometryUpdate(.iOS(interfaceOrientations: orientation)) { error in
                    print("Orientation - requestGeometryUpdate error", error)
                }
            } else {
                UIViewController.attemptRotationToDeviceOrientation()
            }
        }
    }

    /*
        This method is needed to listen to device orientation changes and properly
        handle application orientation
     */
    @objc func orientationDidChange(_ notification: Notification) {
        print("Orientation - orientationDidChange")
        let currentOrientation = UIDevice.current.orientation
        
    }
    
    // HELPERS //
    func getCurrentOrientation() -> UIInterfaceOrientation {
        if #available(iOS 13, *) {
            guard let windowScene = self.getCurrentWindow()?.windowScene else {
                print("Orientation - missing windowScene")
                return UIInterfaceOrientation.unknown
            }
            return windowScene.interfaceOrientation;
        } else {
            return UIApplication.shared.statusBarOrientation
        }
    }
    
    /*
        This function is needed to get the current available window.
        Here in React Native we should have only one window tho.
        https://stackoverflow.com/questions/57134259/how-to-resolve-keywindow-was-deprecated-in-ios-13-0/58031897#58031897
     */
    func getCurrentWindow() -> UIWindow? {
        return UIApplication
            .shared
            .connectedScenes
            .compactMap { $0 as? UIWindowScene }
            .flatMap { $0.windows }
            .last { $0.isKeyWindow }
    }
}

Orientation-Bridging-Header.h

//
//  Use this file to import your target's public headers that you would like to expose to Swift.
//

#import <React/RCTBridgeModule.h>

#ifdef RCT_NEW_ARCH_ENABLED
#import "RNOrientationSpec.h"
#endif

I've updated the podspec to handle .swift files too during installation.

So, know my next step would be to import Orientation.swift inside AppDelegate.mm. Surfing the internet I've found that normally, this is done using Xcode feature: auto generated *-Swift.h file, that's great really, if only it would work.
We should be able to import such file using the syntax that you can see in the following Project's AppDelegate.mm:

#import "AppDelegate.h"

#import <React/RCTBundleURLProvider.h>

// This is the import that we should be able to leverage
#import "Orientation-Swift.h" 

@implementation AppDelegate

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
  self.moduleName = @"OrientationExample";
  // You can add your custom initial props in the dictionary below.
  // They will be passed down to the ViewController used by React Native.
  self.initialProps = @{};

  return [super application:application didFinishLaunchingWithOptions:launchOptions];
}

- (NSURL *)sourceURLForBridge:(RCTBridge *)bridge
{
  return [self bundleURL];
}

- (NSURL *)bundleURL
{
#if DEBUG
  return [[RCTBundleURLProvider sharedSettings] jsBundleURLForBundleRoot:@"index"];
#else
  return [[NSBundle mainBundle] URLForResource:@"main" withExtension:@"jsbundle"];
#endif
}

@end

Although XCode complains with the following error related to my Orientation-Swift.h import:

orientation/example/ios/OrientationExample/AppDelegate.mm:4:9: fatal error: 'Orientation-Swift.h' file not found
#import "Orientation-Swift.h"
^~~~~~~~~~~~~~~~~~~~~~~~~~~~
1 error generated.

Does anyone know how we can let xcode do his job and generate such file?

Any help would be really appreciated.
And please bear in mind that my iOS development knowledge is very limited so I might ask you to further explain something if it does appear to be complex or confusing for me.

Again thanks!

[gladiuscode]

I've found the solution that is currently working in a project with the latest React Native release and use_frameworks!

So here we go:

Steps

1. in ModuleName.h: define all methods you want to use in AppDelegate.mm;
2. in ModuleName.mm: import your ModuleName Swift header auto generated by xcode;
3. in ModuleName.mm: init a static instance of your ModuleName.swift implementation;
4. in ModuleName.mm: implement requiresMainQueueSetup and return YES;
5. in ModuleName.mm: implement all methods you defined in ModuleName.h, leveraging your static ModuleName.swift init;
6. in AppDelegate.mm: import your ModuleName.h header;

Done! You can now leverage your methods defined in ModuleName.h, inside AppDelegate.mm. Basically we need the ModuleName.mm file to act as a bridge between our ModuleName.swift implementation and the Project's AppDelegate.mm.

Example

First

We define the following two methods inside ModuleName.h, that we want to be able to use inside AppDelegate.mm.

+ (void)setSelectedOrientationMask: (UIInterfaceOrientationMask)orientation;
+ (UIInterfaceOrientationMask)getSelectedOrientationMask;

Second

We then import xcode auto generated swift header to allow the use of our ModuleName.swift inside our ModuleName.mm code
This kind of import supports use_frameworks. You can find details here

#if __has_include("react_native_orientation_manager-Swift.h")
#import "react_native_orientation_manager-Swift.h"
#else
#import "react_native_orientation_manager/react_native_orientation_manager-Swift.h"
#endif

Third

We then init our swift class as a static property inside ModuleName.mm.

static OrientationManagerImpl *_orientation = [[OrientationManagerImpl alloc] init];

Fourth

We implement requiresMainQueueStep to allow our swift implementation init.

+ (BOOL)requiresMainQueueSetup
{
    return YES;
}

Fifth

We implement all of our methods defined inside ModuleName.h, as you can see we use our ModuleName.swift instance.

+ (void)setSelectedOrientationMask: (UIInterfaceOrientationMask)mask
{
    [_orientation setSelectedOrientationMaskWithMask:mask];
}

+ (UIInterfaceOrientationMask)getSelectedOrientationMask {
    return [_orientation getSelectedOrientationMask];
}

Sixth

We can now import our ModuleName.h inside AppDelegate.mm and use our ModuleName.mm that calls our ModuleName.swift under the hood.

#import "OrientationManager.h"

- (UIInterfaceOrientationMask)application:(UIApplication *)application supportedInterfaceOrientationsForWindow:(UIWindow *)window
{
  return [OrientationManager getSelectedOrientationMask];
}

Conclusions

So now we have a way to create Swift modules that are callable both from JS and our react native project.
I've not tested it with the new architecture yet, since my project is still using the old one.
I hope it will help whoever is crazy enough, like me, to try to implement a native module with swift.
Let's all hope that, one day, Swift will be the default language used by React Native!

[atlj]

Hey @gladiuscode does this also work on the new architecture for you?

[gladiuscode]

Hi @atlj, I have yet to test it out, I can let everybody know soon.
Probably near the weekend

[gladiuscode]

Hi @atlj, I've tested the implementation on the new architecture and it didn't quite work.
After a bit of research, hammering here and there, I've managed to get it to work for the old and new architecture as well.

Here is the repo: react-native-orientation-director

It's my first time developing a library, so it will be a bumpy ride, but I guess you have to start somewhere.

I'll write a proper guide here in this thread this weekend, so people will have a better reference.

For the moment, please, be aware that this selected answer DOESN'T WORK for the new architecture.