SwiftUI is getting more mature with every new major iOS release and it is now in a state where it can be used for a lot of use cases. The app that I work on my daily job is based on Objective-C and I wanted to prototype some things in SwiftUI because it was faster and more fun. It was also a great way to escape UIKit for a little and learn more about SwiftUI. That means I had to display SwiftUI views from Objective-C ViewControllers. In this article I will explain how I did that.
There are some limitations between Objective-C and Swift regarding SwiftUI. SwiftUI views are structs and they are not visible from the Objective-C code. The only way to bridge the two worlds is to use some kind of a mediator class between Objective-C and Swift code.
SwiftUI and UIKit
Because we will be displaying SwiftUI views from UIKit we first need to know what abstractions to use to wrap SwiftUI views. UIKit can only present or push UIViewController
instances. To create UIViewController
instance from SwiftUI view we need to wrap it into a UIHostingController
. In UIHostingController
initializer we pass the SwiftUI view that we want to wrap like in the example below:
let controller = UIHostingController(rootView: SwiftUIView())
UIHostingController
is a subclass of UIViewController
and now controller
variable can be used from our UIKit code to present it, push it onto the navigation stack or add it as a child view controller. You can read more about UIHostingController
here.
Adding Obj-C to the mix
Now that we know how to display SwiftUI views inside UIKit we need to bridge UIHostingController
to the Objective-C world. As I mentioned earlier, Swift structs are not visible from the Objective-C context so we need to add a middleman that will create UIHostingController
instances wrapped around SwiftUI views.
I like to call the middleman implementations as SwiftUIViewAdapter or SwiftUIViewFactory. I am still not settled on a final suffix but something between these two seems right.
Let’s start with a simple SwiftUI view that will display the text that is passed into its initializer:
import SwiftUI
struct HelloWorldView: View {
var text: String
init(text: String) {
self.text = text
}
var body: some View {
Text(text)
}
}
To display the HelloWorldView
we need to wrap it into the middleman class that will create the UIHostingController
:
@objc class HelloWorldViewFactory: NSObject {
@objc static func create(text: String) -> UIViewController {
let helloWorldView = HelloWorldView(text: text)
let hostingController = UIHostingController(rootView: helloWorldView)
return hostingController
}
}
There are a couple of things happening in the HelloWorldViewFactory
class implementation above, so let’s cover them one by one:
-
HelloWorldViewFactory
class has one static functioncreate(text:)
that will create theHelloWorldView
and initialize it, wrap it inside theUIHostingController
and return it. - To expose
HelloWorldViewFactory
to Objective-C code we need to prefix it with@objc
annotation and we need to subclassNSObject
. This is becauseNSObject
is the root class of most Objective-C class hierarchies, from which subclasses inherit a basic interface to the runtime system and the ability to behave as Objective-C objects. - You can also notice that we are passing text String argument to
create
function. This allows us to use custom initializers for SwiftUI views and to pass dependencies that views need.
Now we can display this view from Objective-C like this:
UIViewController *vc = [HelloWorldViewFactory createWithText:@"Hello from Obj-C!"];
[self presentViewController:vc animated:YES completion:nil];
In this example the device should display the view that has text centered and set to Hello from Obj-C!
Importing Swift code into Objective-C
If you didn’t use Swift in your existing Objective-C project it is important to know that you need to import the Swift module header into the Objective-C file that will use your Swift code. That header file is named like $(SWIFT_MODULE_NAME)-Swift.h
and if you want, you change the name for that header file inside build settings for your target. The config option that defines the name is Objective-C Generated Interface Header Name.
If your app target is called MyTestApp
you can import the Swift code into Objective-C like this:
#import "MyTestApp-Swift.h"
If you are in the same situation as I was I hope that this article will help you.
Top comments (0)