Photo by Edward Howell on Unsplash

Why Use Method Swizzling for Analytics in iOS Swift?

before that let's understand what Method Swizzling is.

What is Method Swizzling?

Method Swizzling is a technique that enables you to change the implementation of a method at runtime. It leverages the dynamic nature of Objective-C runtime, which is still accessible in Swift, to swap the original method with a custom method. This technique is instrumental for:

• Logging: Automatically capturing and logging method calls.
• Analytics: Tracking user interactions without scattering tracking code throughout the app.
• Behaviour Modification: Altering the behaviour of existing methods in a controlled way.

Why Use Method Swizzling for Analytics?

• Centralized Tracking: Implement analytics in one place without modifying every view controller or UI component.
• Reduced Code Duplication: Avoid repetitive code by tracking user interactions across the app with a single swizzle.
• Easier Maintenance: Since the tracking logic is centralized, updating or changing the analytics provider only requires changes in one place.

Real-World Example: Automatically Tracking Screen Views

Let’s dive into a practical example where we automatically track screen views whenever a UIViewController appears. This can be extended to track button taps or other similar interactions.

Step 1: Define the Swizzled Method

We will swizzle the viewDidAppear(_:) method of UIViewController to automatically track screen views.

import UIKit

extension UIViewController {
    
    @objc func swizzled_viewDidAppear(_ animated: Bool) {
        // Call the original implementation
        self.swizzled_viewDidAppear(animated)
        
        // Custom behavior: Track screen view
        trackScreenView()
    }
    
    private func trackScreenView() {
        let screenName = NSStringFromClass(type(of: self))
        AnalyticsManager.shared.logScreenView(screenName: screenName)
        print("Tracked screen view: \(screenName)")
    }
}

Here, swizzled_viewDidAppear(_:) is the new method that will replace the original viewDidAppear(_:). Inside this method, after calling the original implementation, we call trackScreenView() to log the screen view event.

Step 2: Implement the AnalyticsManager

The AnalyticsManager is a singleton class responsible for interacting with the analytics service. It abstracts away the details of the actual analytics implementation (e.g., Firebase, Mixpanel).

import Foundation

class AnalyticsManager {
    static let shared = AnalyticsManager()
    
    private init() {}
    
    func logScreenView(screenName: String) {
        // Integrate with your analytics service here
        // Example: FirebaseAnalytics.logEvent("screen_view", parameters: ["screen_name": screenName])
        print("Logging screen view for: \(screenName)")
    }
}

In a real app, you would replace the print statement with a call to your analytics provider's SDK, such as Firebase or Mixpanel.

Step 3: Swizzle the Methods

To ensure that the methods are swizzled early in the app lifecycle, you typically perform the swizzling in the AppDelegate or as soon as the app starts.

import UIKit
import ObjectiveC

extension UIViewController {
    static let swizzleViewDidAppear: Void = {
        let originalSelector = #selector(viewDidAppear(_:))
        let swizzledSelector = #selector(swizzled_viewDidAppear(_:))
        
        guard let originalMethod = class_getInstanceMethod(UIViewController.self, originalSelector),
              let swizzledMethod = class_getInstanceMethod(UIViewController.self, swizzledSelector) else {
            return
        }
        
        method_exchangeImplementations(originalMethod, swizzledMethod)
    }()
}

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
    var window: UIWindow?
    
    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Perform the swizzling
        UIViewController.swizzleViewDidAppear
        
        return true
    }
}

By calling UIViewController.swizzleViewDidAppear, the swizzling is applied as soon as the app launches. This ensures that every UIViewController in your app automatically logs screen views when they appear.

Step 4: Testing the Swizzling

Once you’ve set up the swizzling, you can test it by running the app and navigating between different view controllers. You should see logs in the console indicating that screen views are being tracked.

Example output:

Tracked screen view: YourApp.MainViewController
Tracked screen view: YourApp.DetailViewController

This shows that every time a UIViewController appears, the screen view is logged without any additional code in the view controllers themselves.