Bridging Objective-C to Swift

Welcome! In modern iOS development, you'll often encounter projects that mix Swift and Objective-C. This is especially true for legacy apps or when integrating older libraries.

This lesson teaches you how to make your existing Objective-C code accessible and usable within a Swift project, a process known as bridging.

The key to using Objective-C code in Swift is the bridging header. This is a special Objective-C header file that tells the Swift compiler which Objective-C classes, categories, and protocols it should expose to your Swift code.

Think of it as a translator's dictionary for your project.

When you add your first Objective-C file (.h or .m) to an existing Swift project, Xcode will often prompt you:

• "Would you like to configure an Objective-C bridging header?"

If you click 'Create Bridging Header', Xcode automatically sets up the file and configures your project's build settings for you. It's usually named YourProjectName-Bridging-Header.h.

If Xcode doesn't prompt you, or if you need to create one later, you can do it manually:

1. Create a new header file (File > New > File > Header File) and name it YourProjectName-Bridging-Header.h.
2. In your project's Build Settings, search for 'Objective-C Bridging Header'.
3. Set the path to your new header file (e.g., $(SRCROOT)/YourProjectName/YourProjectName-Bridging-Header.h).

Once you have your bridging header (whether created automatically or manually), you simply import the Objective-C header files (.h files) of the classes you want to use in Swift.

You do this using the standard Objective-C #import directive inside your bridging header:

Do NOT import Swift files into the bridging header!

Let's define a simple Objective-C class called MyLogger. We'll put its header in our bridging header.

// MyLogger.h

#import <Foundation/Foundation.h>

@interface MyLogger : NSObject

- (void)logMessage:(NSString *)message;
- (NSString *)getGreetingForName:(NSString *)name;

@end

This class has two methods: one to log a message and one to return a personalized greeting.

Here's the implementation for our MyLogger class:

// MyLogger.m

#import "MyLogger.h"

@implementation MyLogger

- (void)logMessage:(NSString *)message {
    NSLog(@"[MyLogger] %@", message);
}

- (NSString *)getGreetingForName:(NSString *)name {
    return [NSString stringWithFormat:@"Hello, %@!", name];
}

@end

Remember, you'd add #import "MyLogger.h" to your YourProjectName-Bridging-Header.h.

Once MyLogger.h is imported into the bridging header, Swift can see and use MyLogger just like any other Swift class! Notice how Objective-C methods are automatically translated into a more Swift-like syntax.

Try running this example:

Swift automatically maps many Objective-C types to their Swift equivalents:

• NSString becomes String
• NSArray becomes Array
• NSDictionary becomes Dictionary
• NSError becomes Error

Objective-C methods are also often renamed to fit Swift's naming conventions (e.g., - (void)logMessage:(NSString *)message; becomes func logMessage(_ message: String)).

You've learned about the bridging header. How does it enable Objective-C code to be used in Swift?

Great job! You've learned the fundamentals of bridging Objective-C code to Swift.

• The bridging header is your gateway.
• Xcode can auto-create it.
• You #import Objective-C header files into it.
• Swift automatically handles type mapping and naming conventions.

This skill is vital for working on mixed-language projects and integrating with existing Objective-C libraries!