How should I handle the delegate?

[jslauren]

�Hi everyone,

I am designing an app using the TCA structure, it's very interesting to me.

However, it seems that a problem occurred while handling the delegate.
To solve this problem, use appropriate keywords (e.g. delegate etc.)
I skimmed through all the articles in the discussion.

The most likely answer was a post from 5 months ago, Answers are no longer being updated.
answer

In fact, if you use the ObservableObject protocol to handle the delegate,
You can do it really simply by using @published or @StateObject.
(to process incoming values in real time)

However, as with the WebSocket example, I am in a situation where I am in trouble now because I think that using this method violates the TCA structure.

Could you please give me a simple example of delegate handling?

I've been thinking about it for a month, but I couldn't find an answer.

Thank you

[tgrapperon]

Hey @jslauren! I'm not sure to fully grasp your problem. Can you post a bit of code that shows the issue?

[jslauren]

Hi @tgrapperon !
First of all, I would like to thank you for your interest in my issue.

I'll attach the little bit of code you said.

class LocationModel: NSObject, ObservableObject {
    let locationManager: CLLocationManager = CLLocationManager()
    @Published var location: CLLocation = CLLocation()

    override init() {
        super.init()
        
        locationManager.delegate = self
        locationManager.desiredAccuracy = kCLLocationAccuracyBest
        locationManager.startUpdatingLocation()
    }
    
    func requestAuthrization() {
        locationManager.requestWhenInUseAuthorization()
    }
    
    func checkPermission() -> Bool {
        switch locationManager.authorizationStatus {
        case .notDetermined, .restricted, .denied:
            return false
        case .authorizedAlways, .authorizedWhenInUse:
            return true
        default:
            return false
        }
    }
}

extension LocationModel: CLLocationManagerDelegate {
    func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
        guard let location = locations.last else {
            return
        }

        self.location = location
    }
}

I am using CoreLocation .
And it changes in real time through the didUpdateLocations method.
After saving the location information,

import SwiftUI
import ComposableArchitecture

struct MapView: View {
    let mapStore: StoreOf<MapFeature>
    let representationView: MapRepresentationView = MapRepresentationView()
    @StateObject var locationModel: LocationModel = LocationModel()
    
    var body: some View {
        WithViewStore(mapStore) { viewStore in
            ZStack(alignment: .bottomLeading) {
                representationView
                
                VStack {
                    Button {
                        viewStore.send(.didLocationButtonTapped(representationView.model, .location, locationModel.location))
                    } label: {
                        Image(systemName: "location.square")
                            .resizable()
                            .foregroundColor(.black)
                            
                    }
                    .frame(width: 44, height: 44)
                }
                .frame(width: 110, height: 210)
            }
            .ignoresSafeArea()
            .onAppear {
                viewStore.send(.onAppear(representationView.model))
            }
        }
    }
}

struct MapView_Previews: PreviewProvider {
    static var previews: some View {
        MapView(mapStore: Store(initialState: MapFeature.State(), reducer: MapFeature()))
    }
}

import SwiftUI
import ComposableArchitecture
import CoreLocation

struct MapFeature: ReducerProtocol {
    @Dependency(\.authrizationClient) var authrizationClient
    
    struct State: Equatable {

    }
    
    enum Action: Equatable {
        case onAppear(MapModel)
        case didLocationButtonTapped(MapModel, permissionType, CLLocation)
    }

    func reduce(into state: inout State, action: Action) -> EffectTask<Action> {
        switch action {]
        case .onAppear(let model):
            authrizationClient.requestAuthrization([.location])
            model.initMapView()
            
            return .none
        case .didLocationButtonTapped(let model, let type, let location):
            if authrizationClient.checkPermission([type])[type] ?? false {
                model.drawMarker(lat: location.coordinate.latitude, lng: location.coordinate.longitude)
                model.moveCamera(lat: location.coordinate.latitude, lng: location.coordinate.longitude)
            }
            
            return .none
        }
    }
}

Like this, when the button is pressed, the location information saved above is sent to the store.
I want to handle motion.

Now, as in the attached code, it was easily handled using StateObject,
I thought that this method does not follow the method of TCA architecture structure.

I would like to know how to handle the delegate value that is updated in real time like this.

I'm afraid I didn't explain it too complicatedly.
Thank you. Have a good day!

[maksimn]

1. In the LocationModel you should have a reference to let store: StoreOf<MapFeature>
2. You should add a locationUpdated action to your Action enum.
3. In the delegate method you send this action through ViewStore(store).send(.locationUpdated(location)).
4. In your reducer you handle the action just like you handle other actions.

[jslauren]

@maksimn Thanks for the wonderful solution! I will try to apply this solution.

[Alex293]

You might want to have a look at https://github.com/pointfreeco/composable-core-location

[jslauren]

@Alex293 Thank you so much for taking an interest in my issue and replying!

If only a few problems are solved,
This solution will be the simplest and nicest answer.

First. The latest TCA does not use Environment, but this package does.
Second. If you want to adopt and use a protocol other than Core Location, it is not a fundamental solution.

Certainly, this solution is very attractive.
thank you!

[Alex293]

Sure the style might be a bit outdated but it should be quite easy to update.