Crie experiências inteligentes com a Siri usando App Schemas

7:59 - Contributing message content to Apple Intelligence

// Contributing message content to Apple Intelligence
  
  @AppEntity(schema: .messages.message)
  struct MessageEntity: IndexedEntity {

      // The text content of the message
      @Property(indexingKey: \.textContent)
      var body: AttributedString?
  }

8:36 - An interface that locates entities using arbitrary string input

// An interface that locates entities using arbitrary string input

  struct ContactQuery: EntityStringQuery {
      func entities(matching string: String) async throws -> [ContactEntity] {
          let predicate = #Predicate<Person> { person in
              person.name.localizedStandardContains(string)
          }
          let descriptor = FetchDescriptor<Person>(predicate: predicate)
          let matches = try modelContext.fetch(descriptor)
          return matches.map(\.entity)
      }
  }

17:19 - Working across apps - View annotations

// Working across apps - View annotations
  
  List {
      ForEach(messages) { message in
          MessageRow(message: message)
              .appEntityIdentifier(
                  EntityIdentifier(
                      for: MessageEntity.self,
                      identifier: message.id
                  )
              )
      }
  }

18:18 - Working across apps - Exporting content to another app

// Working across apps - Exporting content to another app
  
  extension ContactEntity: Transferable {

      static var transferRepresentation: some TransferRepresentation {
          IntentValueRepresentation(
              exporting: \.person
          )
      }
  }

19:21 - Working across apps - IntentValueQuery

// Working across apps - IntentValueQuery

  struct ContactEntityQuery: IntentValueQuery {

      func values(for input: [IntentPerson]) async throws -> [ContactEntity] {
          let names = input.map(\.displayName)
          let descriptor = FetchDescriptor<Contact>()
          let contacts = try model.mainContext.fetch(descriptor)
          let matches = contacts.filter { contact in
              names.contains(where: { name in
                  contact.name.localizedStandardContains(name)
              })
          }
          return matches.map(\.entity)
      }
  }

20:00 - Working across apps - IntentValueRepresentation

// Working across apps - IntentValueRepresentation

  extension ContactEntity: Transferable {

      static var transferRepresentation: some TransferRepresentation {
          IntentValueRepresentation(exporting: \.person, importing: { intentPerson in                    
              let contact = Contact(importing: intentPerson)
              ContactManager.shared.contacts.append(contact)
              return contact.entity
          })
      }
  }