Comenzi rapide Siri — cum să le implementați?

Publicat: 2020-01-16

Comenzile rapide Siri, o caracteristică nouă prezentată la WWDC de anul trecut, oferă posibilitatea de a efectua anumite funcționalități ale aplicației în fundal. Nu trebuie să pornim aplicația pentru a folosi aceste funcționalități în aplicație, putem pur și simplu să îi spunem lui Siri, de exemplu „Burger Time” și sistemul știe căreia aplicație este alocată această comandă rapidă și ne comandă un burger.

Ce sunt comenzile rapide Siri?

  • O modalitate convenabilă de a îndeplini sarcini din ecranul de blocare sau din zona de căutare.
  • Comenzile rapide pot fi adăugate și la Siri pentru a rula cu o frază vocală pe iOS, HomePod și watchOS.
  • Dezvoltatorii adaugă cârlige pentru comenzi rapide în aplicațiile lor, care îi permit lui Siri să se conecteze la aceste comenzi rapide.
  • Utilizarea modelelor de învățare automată a comportamentului dvs. pentru a analiza funcțiile comune pe care le executați și pentru a sugera comenzi rapide automat.
  • iOS 12+

În acest articol, ne vom concentra pe implementarea comenzii rapide de comandă, una dintre cele mai populare aplicații ale comenzilor rapide Siri. Vom crea o aplicație simplă care vă va permite să comandați burgeri

Cum putem crea comenzi rapide Siri?

Procesul de creare a comenzilor rapide Siri
  1. La început, trebuie să ne gândim la funcționalitatea pe care utilizatorul dorește cu adevărat să o faciliteze în aplicația noastră . Aceasta ar trebui să fie o funcționalitate pe care utilizatorul o execută frecvent și îi cere utilizatorului să intre în aplicație și să treacă o cale lungă în ea. Comenzile rapide vor permite scurtarea acestei căi pentru a efectua funcționalitatea.
  2. În pasul următor, trebuie să donați o comandă rapidă. Ce inseamna asta? Trebuie să transmitem sistemului informația despre faptul că am plasat o comandă, de exemplu un burger cu slănină. Furnizăm aceste informații sistemului și ulterior Siri ne poate sugera la un moment dat să facem această comandă specifică.
  3. Ultimul lucru pe care trebuie să-l faceți este să gestionați această comandă rapidă, care se întâmplă atunci când utilizatorul îi spune lui Siri comanda definită mai devreme , de exemplu „Timp burger”, sau în cazul în care utilizatorul apasă pe comanda rapidă sugerată de Siri pe ecranul de blocare.

Ok, poate vom scrie ceva cod? Care sunt posibilitățile noastre ca dezvoltatori?

NSUserActivity & Intents - exemple de comenzi rapide Siri

NSUserActivity — Vom crea o comandă rapidă care ne va permite să lansăm ecranul pentru a face o nouă comandă

  1. Adăugați cheia la Info.plist
 <key>NSUserActivityTypes</key>
<matrice>
	<string>com.miquido.SiriShotcutDemo.make-order</string>
</array>

2. Donați comanda rapidă când utilizatorul intră pe ecran

 let orderActivity = NSUserActivity(activityType: "com.miquido.SiriShotcutDemo.make-order")
orderActivity.persistentIdentifier = NSUserActivityPersistentIdentifier ("com.miquido.SiriShotcutDemo.make-order")
orderActivity.isEligibleForSearch = adevărat
orderActivity.isEligibleForPrediction = adevărat
orderActivity.title = „Efectuați o comandă”
orderActivity.suggestedInvocationPhrase = „Timp de burger”

let attributes = CSSearchableItemAttributeSet(itemContentType: kUTTypeItem ca șir)
attributes.contentDescription = "Hamburgeri deliciosi !"
attributes.thumbnailData = UIImage(numit: „logo”)?.pngData()
orderActivity.contentAttributeSet = atribute
userActivity = orderActivity

3. În AppDelegate , trebuie să implementați delegatul continueUserActivity care, după obținerea acestui tip special, va redirecționa către ecranul dat

 func application(_ application: UIApplication,
                 continuare userActivity: NSUserActivity,
                 restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void) -> Bool {
    dacă userActivity.activityType == „com.miquido.SiriShotcutDemo.make-order” {
        // gestionează aplicația deschisă pe ecranul de comandă
        returnează adevărat
    } 
    returnează fals
} 
Procesul de implementare a comenzilor rapide Siri pentru a comanda un burger

Intenții — Vom implementa o comandă rapidă pentru a face comenzi

Sfat profesionist înainte de implementare:
Intențiile apar atunci când utilizatorul face ceva sistematic. Cu toate acestea, când doriți să testați această funcționalitate, astfel încât să primiți întotdeauna o sugestie de la Siri, trebuie să activați două opțiuni — „ Afișează comenzi rapide recente ” și „ Afișează donațiile pe ecranul de blocare ” în Setări -> Dezvoltator.

Opțiuni: Afișează comenzi rapide recente și Afișează donații pe ecranul de blocare
  1. Creați un fișier de definire a intenției. Cel mai bun mod este să îl adaug la un cadru separat în proiectul meu, acesta va fi în OrderKit .
Pictograma SiriKit Intent Definition File

2. Selectați o categorie, în acest caz „Comandă”. În acest fișier trebuie să alegem parametrii pe care îi vom transmite sistemului și să creăm combinații ale acestor parametri.

Intenție personalizată, parametri și tipuri de comenzi rapide
Definirea comenzii – Creați intenție personalizată
Definirea comenzii — Definiți răspunsurile
Definirea comenzii — Definiți răspunsurile

3. Creați o nouă țintă cu o extensie pentru intenții, selectați „Includeți extensia UI” când o creați.

Pictograma Extensie de intenții
Fișier -> Nou -> Țintă... -> Extensie intenții
Iată cum ar trebui să arate calitatea de membru țintă pentru Order.intentdefinition

4. Creați o interfață de utilizare pentru intenție în fișierul MainInterface.storyboard .

Crearea interfeței de utilizare pentru intenție
Crearea interfeței de utilizare pentru intenția noastră

5. Configurați starea ready și de success în IntentViewController .

 func configureView(pentru parametri: Set<INParameter>,
                       de interacțiune: INInteraction,
                       interactiveBehavior: INUIInteractiveBehavior,
                       context: INUIHostedViewContext,
                       finalizare: @escaping (Bool, Set<INParameter>, CGSize) -> Void) {
        
    guard let intent = interaction.intent ca? OrderIntent altfel {
        completare(fals, Set(), .zero)
        întoarcere
    }
    dacă interaction.intentHandlingStatus == .gata {
        configurare(cu: intentie)
        waitTime.isHidden = adevărat
        completare (adevărat, parametri, dimensiune dorită)
    } altfel dacă interaction.intentHandlingStatus == .success,
        let response = interaction.intentResponse ca? OrderIntentResponse {
        configurare(cu: intentie)
        waitTime.isHidden = fals
        dacă lăsați waitTimeText = response.waitTime {
            waitTime.text = „Comanda va fi gata în \(waitTimeText) minute”
        }
        everythingIsOkLabel.text = „Atingeți pentru a afișa comenzile”
        completare (adevărat, parametri, dimensiune dorită)
    }

    completare (fals, parametri, .zero)
}

configurare funcție privată (cu intenție: OrderIntent) {
    burgerNameLabel.text = intent.burgerName
    if lat cantitate = intent.quantity?.stringValue {
        quantityLabel.text = "\(cantitate) buc."
    }
    if lat additions = intent.additions {
        additionsLabel.text = additions.elements.toString
    }
}

6. După crearea UI, putem merge la donarea intenției noastre. În acest caz, cel mai bine este să donați intențiile la plasarea comenzii. Furnizăm toate informațiile sistemului pe care le-am definit anterior în fișierul Order.intentdefinition , adică numele burgerului, cantitatea și completările, precum și fraza propusă afișată în cazul în care am dori să adăugăm imediat această comandă rapidă la Siri la plasarea comenzii. .

 funcția privată donateInteracțiune(pentru comandă: Comandă) {
    lasă interacțiunea = INInteracțiune(intent: order.intent, răspuns: nil)
    
    interaction.donate { (eroare) in
        dacă eroare != nil {
            // gestionează eroarea
        } altfel {
            print(„Interacțiunea donată cu succes”)
        }
    }
} 
 Comandă de extensie publică {
    
    var intent: OrderIntent {
        lasă orderIntent = OrderIntent()
        orderIntent.burgerName = nume
        if lat intValue = Int(cantitate) {
            orderIntent.quantity = NSNumber(valoare: intValue)
        }
        orderIntent.suggestedInvocationPhrase = „Timp de burger”
        
        orderIntent.additions = additions.map { opțiune -> INObject în
            returnează INObject(identificator: option.rawValue,
                            afișare: option.rawValue)
        }
        return orderIntent
    }
    
}

7. Acum putem gestiona situația ce se va întâmpla în cazul în care utilizatorul primește sugestia unei comenzi rapide și face clic pe ea și în cazul în care utilizatorul apelează comanda rapidă de la Siri.

 clasa publică OrderIntentHandler: NSObject, OrderIntentHandling {
    
    public func confirm(intent: OrderIntent,
                        finalizare: @escaping (OrderIntentResponse) -> Void) {
        finalizare(OrderIntentResponse(cod: OrderIntentResponseCode.ready, userActivity: nil))
    }
    
    public func handle(intent: OrderIntent, 
                       finalizare: @escaping (OrderIntentResponse) -> Void) {
        guard let burgerName = intent.burgerName else {
            finalizare(OrderIntentResponse(cod: .failure, userActivity: nil))
            întoarcere
        }
        
        Defaults.save(comanda: comanda(de la: intentia))
        finalizare(OrderIntentResponse.success(burgerName: burgerName, waitTime: „5”))
    }
    
} 
Demo comandă rapidă Siri

Asta e tot, totul funcționează

Puteți verifica întregul proiect pe GitHub-ul meu aici

Surse:

  • https://developer.apple.com/videos/play/wwdc2018/211/
  • https://developer.apple.com/videos/play/wwdc2018/214/
  • https://developer.apple.com/documentation/sirikit/donating_shortcuts
  • https://developer.apple.com/design/human-interface-guidelines/sirikit/overview/siri-shortcuts/
  • https://www.raywenderlich.com/6462-siri-shortcuts-tutorial-in-ios-12