Searching for a track with MusicKit Swift Beta

Hello @Kimfucious,

Regarding your first question, I'm not a real expert of the capabilities of Apple Music API's search endpoint, but my impression is that your strategy is a fine starting point. I suggest you go ahead with that for now, and see if that works out in practice. If not, then maybe you can come back to us in the forums with more specific information about what you think you would need from this search API for your use case.

As for your second question, all you have to do is:

var albumRequest = MusicCatalogSearchRequest(term: album.name, types: [Album.self])

Also, I suggest you take a look at our sample app for MusicKit. It showcases all the most important core concepts of MusicKit for Swift, including how to use both structured requests offered by the framework.

I hope this helps.

Best regards,

Hi @JoeKun,

You are right again! I would have never guessed [Album.self] by reading the docs, though I do see that in the MusicAlbums app, now that you mention it, thanks. Your patience and support are very much appreciated.

What I still can't find in the docs (nor in the app) is how to do the above albumRequest and include the tracks (songs would be preferable) in the same call.

Unfortunately MusicCatalogSearch request does not have a properties member, so I can't do this:

albumSearchRequest.properties = [.tracks]

At present the above albumResponse only returns the id, title, and artistName.

I've currently worked it out where I do the following:

1. Get a list of albums based on a search string
2. use albums.filter{} to reduce this set to only albums by the desired artist, like this:

let matchedAlbums = response.albums.filter{$0.artistName == artistSearchString}      

For the record, this actually provides for album info, but not tracks.

1. Do a MusicCatalogResourceRequest for each album in matchedAlbums to get the tracks

This doable, but tedious for a few reasons, mainly the return is a Track not a Song, and converting these are a pain.

1. Loop through these to find a track with a criteria matching the one being searched for, which is not hard once the above has been done.

Hi @JoeKun,

I got distracted for a while, but I wanted to come back to this to provide the following feedback.

After a while of trying various ways to do this, I wound up re-writing the app around Track type instead of Song, as it just seemed to make more sense.

I would not have come up with the below without your feedback to this question.

I really wish the docs would include some code examples, as I still battle finding solutions when reading them in their current written form.

In case it helps anyone, here's what I came up with:

1. Create a custom type, AppleMusicTrack, that has the properties I want for the app, including track, where I put the Track (MusicKit type) info as well:

struct AppleMusicTrack: Identifiable {
    var id: String {
        return track.id.rawValue // should probably use MusicItemID here.
    }
    let track: Track // MusicItemID is in here, when I need it.
    let album: String
    let addedAt: String
    let addedBy: String
    let trackType: String
    let matchedBy: String
}

1. Use this function when I can't match a track via isrc

    func getAppleMusicTrackBySearch(track: TrackToMatchType) async -> AppleMusicTrack? {
        var matchedTrack: AppleMusicTrack? = nil
        do {
            let albumSearchRequest = MusicCatalogSearchRequest(term: track.track.album.name, types: [Album.self])
            let response = try await albumSearchRequest.response()
            if(response.albums.count > 0) {
                let matchedAlbums = response.albums.filter{album in
                    track.track.album.artists.contains{$0.name == album.artistName}
                }
                if matchedAlbums.count > 0 {
                    let scrapedTracks = await self.getAppleMusicTracksByAlbumId(albums: matchedAlbums)
                    if(scrapedTracks != nil) {
                        if let firstMatch = scrapedTracks!.first(
                            where: {
                                $0.title == track.track.name
                            }) {
                            matchedTrack = AppleMusicTrack(
                                track: firstMatch,
                                album: firstMatch.title,
                                addedAt: track.addedAt,
                                addedBy: track.addedBy.id,
                                trackType: "matchedAppleMusicTrack",
                                matchedBy: "artist/title",
                            )
                        }
                    }
                }
            }
        } catch {
            print("Error", error)
            // handle error
        }
        if matchedTrack == nil {
            print("No matched track!")
        }
        return matchedTrack
    }

1. The above calls this function to get tracks by album id:

    func getAppleMusicTracksByAlbumId(albums: [Album]) async -> [Track]? {
        var scrapedTracks: [Track]?
        do {
            var albumRequest = MusicCatalogResourceRequest<Album>(matching: \.id, memberOf: albums.map(\.id) )
            albumRequest.properties = [.tracks]
            let albumResponse = try await albumRequest.response()
            let albumsWithTracks = albumResponse.items
            let tracks = albumsWithTracks.flatMap { album -> MusicItemCollection<Track> in
                album.tracks ?? []
            }
            scrapedTracks = tracks.count > 1 ? tracks : nil
        } catch {
            print("Error", error)
        }
        return scrapedTracks
    }