I have content that is loaded in the background.
Loading is a long running task and I want to show data as soon as it's available.
My view show loaded content and a ProgressView whenever there is more content to be expected.
struct MyListView : View
{
#MyContent
var content: [MyItem]
var body: some View
{
List
{
//...show content elements
if content.hasMoreData()
{
ProgressView().task
{
await _content.load(.end)
}
}
}
}
}
I use a custom propertyWrapper to load the data.
#propertyWrapper
struct MyContent<E> : DynamicProperty
{
final class Container<E> : ObservableObject
{
var wrappedValue : [E]
}
let container: Container<E>
var wrappedValue : [E] { container.wrappedValue }
func load() async
{
//...load more content
}
}
When the view loads, the ProgressView spins and the load function is called.
After more data has been loaded the view is refreshed. Unfortunately however the task on the ProgressView is not renewed. The load function is not called again.
I also tried wrapping the MyContent wrapper in an ObservableObject but with similar effects.
final class MyBox<E> : ObservableObject
{
#MyContent
var content: [MyItem]
func load() async
{
await _content.load(position)
await send()
}
#MainActor
private func send() async
{
objectWillChange.send()
}
}
If I look at FetchRequest which is a struct and which has a batchLimit, I think it should not be necessary to use MyBox or an ObservableObject' just to trigger and additional load` call.
How can I force the ProgressView to run the task again?
Related
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 4 months ago.
Improve this question
I have been been reading a lot of about SwiftUI architecture. I read about MVVM, TCA, MVC etc. I am writing an app, where I have to get data from the JSON API and display it on the screen. I am following Apple's code samples and here is what I am doing.
For that I created a NetworkModel.
class NetworkModel {
func getPosts() async throws -> [Post] {
let (data, _) = try await URLSession.shared.data(from: URL(string: "https://jsonplaceholder.typicode.com/posts")!)
let posts = try JSONDecoder().decode([Post].self, from: data)
return posts
}
}
Post.swift
struct Post: Decodable {
let id: Int
let title: String
let body: String
}
PostListView
struct PostListView: View {
#State private var posts: [Post] = []
let networkModel = NetworkModel()
var body: some View {
List(posts, id: \.id) { post in
Text(post.title)
}.task {
do {
await networkModel.getPosts()
} catch {
print(error)
}
}
}
}
Everything works. Is this the right approach? I come from React background so in React if there is a component that is using state and that state will only be used for that component then we simply use private/local state.
I did not create any View Models etc for this app. Are VM's going to benefit me in someway?
The following example code is how I would approach using a NetworkModel.
Caveat, without dealing with the errors.
It creates a NetworkModel as a ObservableObject, which will make it easier
to update the data and have the UI refreshed automatically. The code uses
only one source of truth, the #StateObject var networkModel = NetworkModel(),
and nothing else. This, I believe is important for an architecture.
Is this the right approach?, well that is up to you to determine, by understanding
the various info you read, and your own experience.
struct Post: Decodable, Identifiable {
let userId: Int
let id: Int
let title: String
let body: String
}
#MainActor
class NetworkModel: ObservableObject {
#Published var posts: [Post] = []
func getPosts() async throws {
guard let url = URL(string: "https://jsonplaceholder.typicode.com/posts") else {return}
do {
let (data, _) = try await URLSession.shared.data(from: url)
self.posts = try JSONDecoder().decode([Post].self, from: data)
} catch {
print(error)
}
}
}
struct ContentView: View {
#StateObject var networkModel = NetworkModel()
var body: some View {
List (networkModel.posts) { post in
Text(post.title)
}
.task {
do {
try await networkModel.getPosts()
} catch {
print(error)
}
}
}
}
The info at the following link, gives some good explanations about how to manage data in your app and how SwiftUI has already a lot of structure/architecture built in to help you:
https://developer.apple.com/documentation/swiftui/managing-model-data-in-your-app
SwiftUI is an architecture in itself, it's best to just learn it. E.g. learn the View struct, learn how body func is called if a let property or an #State or #Binding changes. It's really quite simple.
Trying to go from UIKit to SwiftUI I keep wondering how to apply a service layer properly and use observables to publish updates from the service layer all the way out through the view model and to the view.
I have a View that has a View model, which derives from ObservableObject and publishes a property, displayed in the view. Using #EnvironmentObject I can easily access the view model from the view.
struct SomeView: View {
#EnvironmentObject var someViewModel: SomeViewModel
var body: some View {
TextField("Write something here", text: $someViewModel.someUpdateableProperty)
}
}
class SomeViewModel: ObservableObject {
#Published var someUpdateableProperty: String = ""
var someService: SomeService
init(someService: SomeService) {
self.someService = someService
}
// HOW DO I UPDATE self.someUpdateableProperty WHEN someService.someProperty CHANGES?
// HOW DO I UPDATE someService.someProperty WHEN self.someUpdateableProperty CHANGES?
}
class SomeService {
var someProperty: String = ""
func fetchSomething() {
// fetching
someProperty = "Something was fetched"
}
func updateSomething(someUpdateableProperty: String) {
someProperty = someUpdateableProperty
}
}
In my head a simple way could be to forward the property i.e. using computed property
class SomeViewModel: ObservableObject {
#Published var someUpdateableProperty: String {
get {
return someService.someProperty
}
set {
someService.someProperty = value
}
}
var someService: SomeService
init(someService: SomeService) {
self.someService = someService
}
}
Another approach could be if it was possible to set the two published properties equal to each other:
class SomeService: ObservableObject {
#Published var someProperty: String = ""
func fetchSomething() {
// fetching
someProperty = "Something was fetched"
}
}
class SomeViewModel: ObservableObject {
#Published var someUpdateableProperty: String = ""
var someService: SomeService
init(someService: SomeService) {
self.someService = someService
someUpdateableProperty = someService.someProperty
}
}
What is the correct way to forward a publishable property directly through a view model?
In UIKit I would use delegates or closures to call from the service back to the view model and update the published property, but is that doable with the new observables in SwiftUI?
*I know keeping the state in the service is not a good practice, but for the example let's use it.
There are, of course, lots of ways to do this, so I can't speculate on the "correct" way. But one way to do this is to remember that ObservableObject only does one thing - it has an objectWillChange publisher, and that publisher sends automatically when any of the #Published properties changes.
In SwiftUI, that is taken advantage of by the #ObservedObject, #StateObject and #EnvironmentObject property wrappers, which schedule a re-rendering of the view whenever that publisher sends.
However, ObservableObject is actually defined within Combine, and you can build your own responses to the publisher.
If you make SomeService an ObservableObject as in your last code example, then you can observe for changes in SomeViewModel:
private var cancellables = Set<AnyCancellable>()
init(someService: SomeService) {
self.someService = someService
someService.objectWillChange
.sink { [weak self] _ in
self?.objectWillChange.send()
}
.store(in: &cancellables)
}
Now, any published change to the service will cascade through to observers of the view model.
It's important to note that this publisher is will change, not did change, so if you are surfacing any properties from the service in your view model, you should make them calculated variables. SwiftUI coalesces all of the will change messages, then schedules a single view update which takes place on the next run loop, by which point the new values will be in place. If you extract values from within the sink closure, they will still represent the old data.
Is there a way to mock the viewmodels of an application that uses SwiftUI and Combine? I always find articles about mocking services used by the viewmodel but never mocking a viewmodel itself.
I tried to create protocols for each viewmodel. Problem: the #Published wrapper cannot be used in protocols. It seems like there are no solutions...
Thanks for your help
Using a protocol type as #ObservableObject or #StateObject would not work. Inheritance might be a solution (like Jake suggested), or you could go with a generic solution.
protocol ContentViewModel: ObservableObject {
var message: String { get set }
}
Your view model would be simple.
final class MyViewModel: ContentViewModel {
#Published var message: String
init(_ message: String = "MyViewModel") {
self.message = message
}
}
On the other hand, your views would be more complex using a constrained generic.
struct ContentView<Model>: View where Model: ContentViewModel {
#ObservedObject
var viewModel: Model
var body: some View {
VStack {
Text(viewModel.message)
Button("Change message") {
viewModel.message = "🥳"
}
}
}
}
The disadvantage is that you have to define the generic concrete type when using the view --- inheritance could avoid that.
// your mock implementation for testing
final class MockViewModel: ContentViewModel {
#Published var message: String = "Mock View Model"
}
let sut = ContentView<MockViewModel>(viewModel: MockViewModel())
If the view model is only a model, you should probably not mock that at all, instead you would mock the thing that modifies the view model. If your view model actually owns the functions and things that updates itself, then you would want to mock it directly. In which case you can use protocols to mock the view model. It would look a little like this.
protocol ViewModel {
var title: String { get set }
}
class MyViewModel: ViewModel {
#Published var title: String = "Page title"
}
class MockViewModel: ViewModel {
#Published var title: String = "MockPage title"
}
However, this is probably an instance where I would prefer inheriting a class instead of adhering to a protocol. Then I would override the functionality of the class for the mock.
open class ViewModel {
#Published var title: String
open fun getPageTitle() {
title = "This is the page title"
}
}
class MockViewModel: ViewModel {
override fun getPageTitle() {
title = "some other page title"
}
}
Either way would work really. The inheritance way is just less verbose in your test suite if your View Model has functionality too.
I have a couple of DatePickers in a view with the following code. Each DatePicker presents a digit, so "3" or "5". So for "3456" I have 4 DatePickers that can be changed individually.
struct DigitPicker: View {
var digitName: String
#Binding var digit: Int
var body: some View {
VStack {
Picker(selection: $digit, label: Text(digitName)) {
ForEach(0 ... 9) {
Text("\($0)").tag($0)
}
}.frame(width: 60, height: 110).clipped()
}
}
}
I get an error "Generic parameter 'ID' could not be inferred". So I guess the reason is that $digit must conform to Identifiable(). But how do I do that???
The compiler is resolving the ForEach using this extension:
extension ForEach where Content : View {
/// Creates an instance that uniquely identifies views across updates based
/// on the `id` key path to a property on an underlying data element.
///
/// It's important that the ID of a data element does not change unless the
/// data element is considered to have been replaced with a new data
/// element with a new identity. If the ID of a data element changes, then
/// the content view generated from that data element will lose any current
/// state and animations.
public init(_ data: Data, id: KeyPath<Data.Element, ID>, content: #escaping (Data.Element) -> Content)
}
And, as you can see, it can't infer the second argument of the init method.
You can make the second argument explicit to make the compiler happy.
ForEach(0 ... 9, id: \.self) { // identified by self
Text("\($0)").tag($0)
}
I am trying to create a singleton with WebSocket functionality and I just don't know why it's not working
This is my singleton extension:
import Starscream
extension WebSocketManager: WebSocketDelegate {
func websocketDidConnect(socket: WebSocket) {
print("websocket is connected")
}
func websocketDidDisconnect(socket: WebSocket, error: NSError?) {
if let e = error {
print("websocket is disconnected: \(e.localizedDescription)")
} else {
print("websocket disconnected")
}
}
func websocketDidReceiveMessage(socket: WebSocket, text: String) {
print("Received text: \(text)")
}
func websocketDidReceiveData(socket: WebSocket, data: Data) {
print("Received data: \(data.count)")
}}
My singleton:
final class WebSocketManager: NSObject {
static let sharedInstance = WebSocketManager()
public var socket = WebSocket(url: URL(string: "ws://t-w-a.herokuapp.com/new")!)
private override init() {
super.init()
// testing connection of the socket
}
func establishConnection() {
socket.connect()
}
func closeConnection() {
socket.disconnect()
}}
When I am trying to connect the server just nothing happens.
Here is my controller:
class ChatViewController: UIViewController {
#IBOutlet weak var typeText: UITextField!
override func viewDidLoad() {
super.viewDidLoad()
WebSocketManager.sharedInstance.establishConnection()
}}
I've found problem, I just forgot to assign socket variable with the delegate