Multiple destinations UIKit

[nickmalevich]

Description

I couldn't find an example of implementing multiple destinations in UIKit. There are no problems with this in SwiftUI.
I've written an implementation that does what it needs to do, but there are memory leaks

Checklist

• I have determined whether this bug is also reproducible in a vanilla SwiftUI project.
• If possible, I've reproduced the issue using the main branch of this package.
• This issue hasn't been addressed in an existing GitHub issue or discussion.

Expected behavior

I want to implement the transition from the parent view controller to several child

Actual behavior

This is my implementation of the parent feature

struct IntroFeature: ReducerProtocol {
    struct State {
        @PresentationState var destination: Destination.State?
    }

    enum Action {
        case destination(PresentationAction<Destination.Action>)

        case didTap(Button)

        enum Button {
            case search
        }
    }

    var body: some ReducerProtocol<State, Action> {
        Reduce { state, action in
            switch action {
            case .destination(.presented(.discovery(.callback(.didConnected(let deviceName))))):
                state.destination = .tabBar(.init(deviceName: deviceName))

            case .didTap(.search):
                state.destination = .discovery(.init())

            default:
                break
            }

            return .none
        }
        .ifLet(\.$destination, action: /Action.destination) { Destination() }
    }
}

extension IntroFeature {
    struct Destination: ReducerProtocol {
        enum State {
            case discovery(DiscoveryFeature.State)
            case tabBar(TabBarFeature.State)
        }

        enum Action {
            case discovery(DiscoveryFeature.Action)
            case tabBar(TabBarFeature.Action)
        }

        var body: some ReducerProtocolOf<Self> {
            Scope(state: /State.discovery, action: /Action.discovery) { DiscoveryFeature() }
            Scope(state: /State.tabBar, action: /Action.tabBar) { TabBarFeature() }
        }
    }
}

This is my implementation of handling destination in the UIViewController

store.scope(state: \.destination, action: { .destination(.presented($0)) })
    .ifLet { [weak self] destinationStore in
        guard let self else {
            return
        }

        destinationStore.scope(
            state: /IntroFeature.Destination.State.discovery, action: IntroFeature.Destination.Action.discovery
        )
        .ifLet { [weak self] in
            self?.presentDiscoveryViewController(store: $0)
        }
        .store(in: &cancellables)

        destinationStore.scope(
            state: /IntroFeature.Destination.State.tabBar, action: IntroFeature.Destination.Action.tabBar
        )
        .ifLet { [weak self] in
            guard let self else {
                return
            }

            dismiss(animated: true)
            pushTabBarViewController(store: $0)
        }
        .store(in: &cancellables)
    } else: { [weak self] in
        guard let self else {
            return
        }

        dismiss(animated: true)

        if navigationController?.topViewController != self {
            navigationController?.popViewController(animated: true)
        }
    }
    .store(in: &cancellables)

To return from a child view controller, I use dismiss(). Indeed, all transitions work, however, there is a memory leak every time the return to the parent view controller occurs.
This can also be observed by calling the push or present methods each time twice as much as the previous one.

Steps to reproduce

To reproduce this bug, you just need to go to the child view controllers and return

The Composable Architecture version information

0.58.0

Destination operating system

iOS 16.6

Xcode version information

14.3.1

Swift Compiler version information

5.8.1

[mbrandonw]

Hi @nickmalevich, can you please provide a minimal reproducing project that demonstrates the memory leak?

[nickmalevich]

Hi @mbrandonw, you can see my example project on this repo https://github.com/nickmalevich/DestinationTCA.
This project includes two parts, you can switch between them on file AppDelegate.swift. The first part has memory leaks and you will see some UI bugs. And the second part doesn't have UI bugs.
So basically I decided the problem, but maybe you know better solution

[mbrandonw]

Hi @nickmalevich, the two demos you have provided do not function the same for me. In the ParentWithFeature demo, when you tap "Second" you will see two drill-down animations happen to the yellow screen. This leads me to believe there is a bug somewhere in your code causing two navigations. The ParentWithoutFeature demo does not have that problem. Can you try fixing that bug and see if the leak still remains?

I'm not sure this is an issue with the library currently, and so I am going to convert it to a discussion. Please follow up with any findings over there.

[jaanussiim]

I used this discussion as a reference for managing the destination in UIKit world. I believe the memory leak comes from using the same cancellables set inside the destination ifLet.

Having two destinations. Hitting just the first one repeatedly - everything works as expected. Hitting the second destination, it is pushed multiple times. The cancellables registered inside destination scope ifLet are sticking around.

I added destinationCancellables that is used inside destination scope ifLet and cleared in destination scope else, and multiple pushes are not happening.

I believe this is an application bug.

[lukeredpath]

I think the comment above is correct - capturing the cancellables set inside the other ifLet is causing a retain cycle.

FWIW, I don't think you need to store the cancellables returned by the inner ifLet - the only thing that can change over time is the destination - it can change value or become nil. The outer cancellable will track that. Once you have a non-nil destination, you only need to use ifLet for a one-off scoping operation.