codesanitize

I’m making an attempt to check a function that requires me to simulate my location, which isn’t attainable on an actual machine so far as I do know. This is the reason I now have to construct my app that has been working for a lot of weeks and a whole lot of builds on my actual machine, on a simulator. Nevertheless, as quickly as I begin the app within the simulator (or it will get began by xCode), the app crashes with this log:

*** Terminating app as a consequence of uncaught exception 'NSInvalidArgumentException', cause: 'Couldn't discover a storyboard named 'Predominant' in bundle NSBundle  (loaded)'
*** First throw name stack:
(
    0   CoreFoundation                      0x000000010a3677d4 __exceptionPreprocess + 172
    1   libobjc.A.dylib                     0x000000010681b7cc objc_exception_throw + 72
    2   UIKitCore                           0x0000000145d7f1f0 -[UIStoryboard name] + 0
    3   UIKitCore                           0x0000000145bd6810 -[UIApplication _storyboardInitialMenu] + 112
    4   UIKitCore                           0x0000000145bf3544 -[UIApplication buildMenuWithBuilder:] + 44
    5   UIKitCore                           0x00000001460f2cec -[UIMenuSystem _buildMenuWithBuilder:fromResponderChain:atLocation:inCoordinateSpace:] + 92
    6   UIKitCore                           0x000000014501b900 -[_UIMainMenuSystem _buildMenuWithBuilder:fromResponderChain:atLocation:inCoordinateSpace:] + 112
    7   UIKitCore                           0x00000001460f2c2c -[UIMenuSystem _newBuilderFromResponderChain:atLocation:inCoordinateSpace:] + 96
    8   UIKitCore                           0x000000014501b7d4 -[_UIMainMenuSystem _automaticallyRebuildIfNeeded] + 172
    9   UIKitCore                           0x000000014501b80c -[_UIMainMenuSystem _keyCommands] + 20
    10  UIKitCore                           0x0000000145beeeec -[UIApplication _keyCommands] + 80
    11  UIKitCore                           0x0000000145bffab0 -[UIResponder _enumerateKeyCommandsInChainWithOptions:usingBlock:] + 436
    12  UIKitCore                           0x0000000145beeb74 -[UIApplication _immediatelyUpdateSerializableKeyCommandsForResponder:] + 164
    13  UIKitCore                           0x00000001460eb9a8 -[_UIAfterCACommitBlock run] + 64
    14  UIKitCore                           0x00000001460ebdbc -[_UIAfterCACommitQueue flush] + 164
    15  UIKitCore                           0x0000000145bdf54c _runAfterCACommitDeferredBlocks + 256
    16  UIKitCore                           0x0000000145bd1028 _cleanUpAfterCAFlushAndRunDeferredBlocks + 76
    17  CoreFoundation                      0x000000010a2c7134 __CFRUNLOOP_IS_CALLING_OUT_TO_A_BLOCK__ + 20
    18  CoreFoundation                      0x000000010a2c6898 __CFRunLoopDoBlocks + 348
    19  CoreFoundation                      0x000000010a2c1450 __CFRunLoopRun + 808
    20  CoreFoundation                      0x000000010a2c0cec CFRunLoopRunSpecific + 536
    21  GraphicsServices                    0x000000011f51ad00 GSEventRunModal + 164
    22  UIKitCore                           0x0000000145bd27d4 -[UIApplication _run] + 796
    23  UIKitCore                           0x0000000145bd6ba0 UIApplicationMain + 124
    24  UIKitCore                           0x0000000144f9cf1c block_destroy_helper.14 + 9560
    25  [...].debug.dylib                    0x0000000107067cdc $sSo21UIApplicationDelegateP5UIKitE4mainyyFZ + 128
    26  [...].debug.dylib                    0x0000000107067c4c $s4[...]11AppDelegateC5$mainyyFZ + 44
    27  [...].debug.dylib                    0x0000000107067d58 __debug_main_executable_dylib_entry_point + 28
    28  dyld                                0x00000001046113d4 start_sim + 20
    29  ???                                 0x000000010470ab98 0x0 + 4369460120
)
libc++abi: terminating as a consequence of uncaught exception of sort NSException
*** Terminating app as a consequence of uncaught exception 'NSInvalidArgumentException', cause: 'Couldn't discover a storyboard named 'Predominant' in bundle NSBundle  (loaded)'
terminating as a consequence of uncaught exception of sort NSException
CoreSimulator 1010.15 - System: iPhone 16 Professional (7F88C881-9905-4665-AC11-282A5171CCAC) - Runtime: iOS 18.5 (22F77) - DeviceType: iPhone 16 Professional

It appears to crash as a result of my app is in search of a storyboard file, which I’ve faraway from day one, as a result of I’m doing every thing programatically.

Steps I’ve completed:

1. Take away the reference to storyboard in Launch Display. -> Was already empty
2. Examine for any reference to “Predominant” or Storyboard in my data.plist -> Nothing
3. Checked if the deployment goal was set to common or something aside from iPhone -> Was already the case.

I do not know what else I can examine. AI is telling me that it could be a dependency that’s making an attempt to reference Storyboard. In that case, how do I discover out which one it’s?

I’ve a questions on syncing view positions throughout an animation change.

This is the model I am aiming for, however discover when the keyboard seems, the view top modifications instantly with no animation.

This model is what I presently have, with the animation when view top shrinks, however discover on the swipe down there’s a noticeable hole between the date header and the highest of the checklist view. Type of seems damaged.

This is the code:

                        .onReceive(keyboardHeightPublisher.removeDuplicates()) { top in
                        withAnimation {
                            let unadjustedKeyboardHeight = self.keyboardUnadjustedHeight - top
                            self.keyboardAdjustedListHeight = unadjustedKeyboardHeight
                        } completion: {
                            change (self.modalState) {
                            case .didShow:
                                self.modalState = .didShow
                            default:
                                break
                            }
                        }
                    }

So the self.keyboardAdjustedListHeight is connected to to the checklist view:

.body(top: self.keyboardAdjustedListHeight)
                    .place(CGPoint(x: (geometry.dimension.width / 2), y: (self.gesturePosition.y + (self.dateHeaderRect.top / 2)) + (self.keyboardAdjustedListHeight / 2)))

Your entire modal is is simply

ZStack 
  - VStack (date header)
       - drag gesture
  - VStack (checklist view)
       - positioned underneath the date header primarily based on drag gesture place.

I attempted matchedGeometryEffect however that did not do the trick.

Any clues?

EDIT: I am aiming to get the second GIF (animated checklist view) however the one drawback is the hole upon dragging down.

SOLUTION:
Used a variation of @Benzy Neez’s answer right here.

This was the supposed impact. Principally an animation of the checklist view shrinking however no separation of the date header from the checklist view on down drag.
This code is beneath the checklist view VStack.
So nonetheless:

ZStack 
    VStack (date view)
        (drag gesture updates place)
    VStack (checklist view)
        (updates place primarily based on drag gesture)

            .animation(.easeInOut, worth: self.animateShrinkModal)
                    .toolbar(content material: {
                        ToolbarItem(placement: .keyboard) {
                            EmptyView()
                        }
                    })
                    .onReceive(keyboardHeightPublisher.removeDuplicates()) { top in
                        let unadjustedKeyboardHeight = self.keyboardUnadjustedHeight - top
                        self.keyboardAdjustedListHeight = unadjustedKeyboardHeight
                        
                        if top > .zero {
                            self.animateShrinkModal.toggle()
                        }
                        
                        change (self.modalState) {
                        case .didShow:
                            self.modalState = .didShow
                        default:
                            break
                        }
                    }

As you’ll be able to see I solely set off the animation when the keyboard top shouldn’t be zero. The modal top is reset with out an animation proper after the keyboard top is zero which is properly after the drag ends. Even dragging slowly towards the keyboard has the specified impact.

Within the earlier tutorials, we explored how Basis Fashions work in iOS 26 and how one can begin constructing AI-powered options utilizing this new framework. We additionally launched the @Generable macro, which makes it straightforward to transform generated responses into structured Swift varieties.

Now, in Half 3 of the Basis Fashions sequence, we’ll dive into one other highly effective functionality: Software Calling — a characteristic that lets the mannequin work together along with your app’s features to carry out duties, retrieve information, or set off actions based mostly on person enter.

The on-device language mannequin isn’t able to answering each sort of query, particularly people who require real-time information, like the present climate or the newest inventory costs. In different circumstances, you may want the mannequin to entry your app’s personal information to reply precisely. That’s the place Software Calling is available in that it permits the mannequin to delegate particular duties to your app’s features or exterior APIs.

On this tutorial, we’ll prolong the Ask Me Something app. Whereas the on-device mannequin can deal with normal queries, it doesn’t have entry to up-to-date details about trending motion pictures. To bridge that hole, we’ll use Software Calling to combine with the The Film Database (TMDB) API, enabling the mannequin to reply to movie-related questions utilizing reside information.

Utilizing TMDB APIs

In case you ask the Ask Me Something app about trending motion pictures, the on-device language mannequin received’t have the reply—it merely doesn’t have entry to that form of real-time data and should recommend checking different sources as a substitute. Let’s repair that utilizing Software Calling and the TMDB API. With this setup, each time a person asks a movie-related query, the mannequin received’t reply with “I don’t know.” As an alternative, it is going to robotically name the exterior API and return the related data instantly within the app.

Within the Xcode venture, create a MovieService file and insert the next code:

// Mannequin for a Film
struct Film: Codable, Identifiable {
    let id: Int
    let title: String
    let overview: String
    
    // Coding keys to match API response
    enum CodingKeys: String, CodingKey {
        case id
        case title
        case overview
    }
}

// Mannequin for the API response
struct TrendingMoviesResponse: Codable {
    let outcomes: [Movie]
}

// Service class to fetch trending motion pictures
class MovieService {
    // Base URL for TMDB API
    personal let baseURL = "https://api.themoviedb.org/3"
    
    personal let apiKey = ""
    
    // Operate to fetch trending motion pictures utilizing async/await
    func fetchTrendingMovies() async throws -> [Movie] {
        
        // Assemble the URL for trending motion pictures
        let urlString = "(baseURL)/trending/film/day?api_key=(apiKey)"
        guard let url = URL(string: urlString) else {
            throw URLError(.badURL)
        }
        
        // Carry out the community request
        let (information, response) = strive await URLSession.shared.information(from: url)
        
        // Verify for legitimate HTTP response
        guard let httpResponse = response as? HTTPURLResponse,
              (200...299).comprises(httpResponse.statusCode) else {
            throw URLError(.badServerResponse)
        }
        
        // Decode the JSON response
        let decoder = JSONDecoder()
        let trendingResponse = strive decoder.decode(TrendingMoviesResponse.self, from: information)
        return trendingResponse.outcomes
    }
}

Ensure you exchange the worth of apiKey with your personal TMDB API key. In case you haven’t signed up but, head over to themoviedb.org and register for a free account to get your API key.

The code above is pretty simple: it calls the net API to fetch trending motion pictures, then parses the response and decodes it into an array of Film objects.

Subsequent, we’ll use Software Calling to set off the code in MovieService each time the person asks about trending motion pictures. To get began, create a brand new file named GetTrendingMoviesTool.swift and add the next code:

import FoundationModels

struct GetTrendingMoviesTool: Software {
    let title = "getTrendingMovies"
    let description = "Get trending motion pictures and their data"
    
    let service = MovieService()

    @Generable
    struct Arguments {
        
    }
    
    func name(arguments: Arguments) async throws -> [String] {
        let motion pictures = strive await service.fetchTrendingMovies()
       
        let formattedMovies = motion pictures.map { film in
            "(film.title): (film.overview)"
        }
        
        return formattedMovies
    }
}

We outline a GetTrendingMovieTool struct that conforms to the Software protocol — that is the usual option to implement Software Calling within the Basis Fashions framework. The protocol requires you to specify a title and description for the instrument, together with an Arguments struct to symbolize any parameters the instrument would possibly want. On this case, we don’t require extra enter, so we outline an empty Arguments construction.

In case you needed to filter trending motion pictures by style, you could possibly outline Arguments like this:

@Generable
struct Arguments {
		@Information(description: "The style to fetch trending motion pictures")
		var style: String
}

When the instrument is triggered by the mannequin, the name methodology is robotically executed. Inside it, we name the fetchTrendingMovies() methodology from our service. After receiving the outcomes, we format them to show every film’s title and overview.

With the trending film instrument in place, integrating it into your app is easy. Merely open ContentView and replace the LanguageModelSession initialization as follows:

@State personal var session = LanguageModelSession(instruments: [GetTrendingMoviesTool()])

You may present customized instruments by passing them by way of the instruments parameter when initializing the language mannequin session. That’s it! The language mannequin will robotically invoke GetTrendingMoviesTool each time it detects a query associated to trending motion pictures.

Construct and run the app, then strive asking the identical query once more. This time, the mannequin will efficiently reply with trending film data by invoking the instrument.

Abstract

On this tutorial, we explored instrument calling, a strong addition to the Basis Fashions framework in iOS 26. In contrast to fundamental textual content technology, instrument calling permits the on-device language mannequin to work together along with your app’s features or entry exterior companies.

With instrument calling, you possibly can considerably prolong the mannequin’s capabilities. Whether or not it’s operating customized logic or fetching real-time information by way of APIs, the mannequin can now carry out context-aware duties past its built-in information.

I hope you’ve loved this tutorial sequence and really feel impressed to begin constructing smarter, AI-powered options utilizing the Basis Fashions framework.