Support semantic search with Core Spotlight

2:14 - Creating CSSearchableItem

// Creating searchable items for donation


let item = CSSearchableItem(uniqueIdentifier: uniqueIdentifier, domainIdentifier: domainIdentifier, attributeSet: attributeSet)

2:28 - Creating CSSearchableAttributeSet

// Creating searchable content for donation


let attributeSet = CSSearchableItemAttributeSet(contentType: UTType.text)
attributeSet.contentType = UTType.text.identifier

2:40 - Searchable items with type

// Searchable items with text


attributeSet.title
attributeSet.textContent


// Searchable items with media


attributeSet.contentType
attributeSet.contentURL


// Searchable items with links


attributeSet.contentURL
attributeSet.relatedUniqueIdentifier

3:31 - Batch indexing with client state

// Batch indexing with client state


let index = CSSearchableIndex(name: "SpotlightSearchSample")        
index.fetchLastClientState { state, error in         
    if state == nil {
        index.beginBatch()
        index.indexSearchableItems(items)
        index.endIndexBatch(expectedClientState: state, newClientState: newState) { error in
        }
    }
}

3:56 - Avoid overwriting existing attributes

// Make it an update to avoid overwriting existing attributes


item.isUpdate = true

7:19 - Configure a query

// Configure a query


let queryContext = CSUserQueryContext()
queryContext.fetchAttributes = ["title", "contentDescription"]

7:33 - Ranked results

// Ranked results


queryContext.enableRankedResults = true
queryContext.maxRankedResultCount = 2

7:47 - Suggestions

// Suggestions


queryContext.maxSuggestionCount = 4

7:55 - Filter queries

// Filter queries


queryContext.filterQueries = ["contentTypeTree=\"public.image\""]

8:23 - Query for searchable items and suggestions

// Query for searchable items and suggestions


let query = CSUserQuery(userQueryString: "windsurfing carmel", userQueryContext: queryContext)
for try await element in query.responses {
    switch(element) {
        case .item(let item):
            self.items.append(item)
            break
        case .suggestion(let suggestion):
            self.suggestions.append(suggestion)
            break
    }
}

8:40 - Suggestions

// Suggestions


suggestion.localizedAttributedSuggestion

8:56 - Preparing for queries

// Preparing for queries


CSUserQuery.prepare
CSUserQuery.prepareWithProtectionClasses

9:50 - Set the lastUsedDate

// Set the lastUsedDate when the user interacts with the item


item.attributeSet.lastUsedDate = Date.now
item.isUpdate = true

10:00 - Interactions with items and suggestions from a query

// Interactions with items and suggestions from a query


query.userEngaged(item, visibleItems: visibleItems, interaction: CSUserQuery.UserInteractionKind.select)

query.userEngaged(suggestion, visibleSuggestions: visibleSuggestions, interaction: CSUserQuery.UserInteractionKind.select)