---
sourceDocument: Yokohama-API-Referenz
sourceDocumentLink: https://servicenow-prod.fluidtopics.net/r/de-DE/yokohama/api-reference

 Release :

    - yokohama

ft:locale :

    - de-DE

ft:publication_title :

    - Yokohama-API-Referenz

ft:clusterId :

    - crapiref

bundleId :

    - crapiref

workflow :

    - Creator


---

# Now ChatServiceklasse: IOS

# Now ChatServiceklasse: IOS {#ariaid-title1}

* Freigeben Version: Yokohama
* 
* Aktualisiert 30. Januar 2025
* 
* ![](https://www.servicenow.com/docs/portal-asset/ico-clock) 4 Minuten Lesedauer

Die Now Chatservice Klasse stellt virtuelles und bereit ServicemitarbeiterChat-Fähigkeiten.

Mit dieser Klasse können Sie Chat-Services starten und stoppen, Chat-Sitzungen starten, eine Chat-Anwenderoberfläche erstellen und ungelesene Nachrichten abonnieren/abbestellen.
{#NowChatServiceiOSAPI__entry__2}

| Name | Beschreibung |
|-|-|
| konfigurieren | Konfigurationseinstellungen, die bei der Initialisierung des Service bereitgestellt wurden. Datentyp: [Jetzt Servicekonfiguration](https://servicenow-prod.fluidtopics.net/m~vU6ffKznzmlhUz94FBmw#NowServiceConfigurationiOSStruct "Die Jetzt Servicekonfiguration Struktur definiert Konfigurationsinformationen für einen Funktionsservice.") |
| Instanzversion | Version des zugeordneten ServiceNowInstanz, z. B. vancouver oder xanadu. Datentyp: Zeichenfolge |
| Netzwerkservice | Netzwerkservice, der diesem Chatservice zugeordnet ist. Datentyp: Netzwerkservice |
| Sitzungstyp | Typ der Sitzung. Mögliche Werte: * Authentifiziert * Gast * Identität angenommen * unbekannt Datentyp: Sitzungstyp |
[Tabelle : 1. Eigenschaften]

## NowChatService -- init(Konfiguration: NowServiceConfiguration, Delegierter: NowChatServiceDelegate?, coreServiceProvider: NowCoreServiceProviding? = Null) {#ariaid-title2}

Initialisiert eine neue NowChatService-Instanz.
{#NChatServ-init_O_S_S__table_jgv_vqp_npb__entry__3}

| Name | Typ | Beschreibung |
|-|-|-|
| konfigurieren | [Jetzt Servicekonfiguration](https://servicenow-prod.fluidtopics.net/m~vU6ffKznzmlhUz94FBmw#NowServiceConfigurationiOSStruct "Die Jetzt Servicekonfiguration Struktur definiert Konfigurationsinformationen für einen Funktionsservice.") | Konfigurationsinformationen, die zum ordnungsgemäßen Initialisieren des Service erforderlich sind. |
| Delegierter | Now​Chatservice-​​Delegierter | Optional. NowChat-Rückrufdelegierungsobjekt, das das NowChatServiceDelegate-Protokoll implementiert. Standard: Null |
| CoreServiceanbieter | Jetzt CoreServicebereitstellung | Optional. Objekt, das das NowCoreServiceProviding-Protokoll implementiert. Bietet Zugriff auf Now Chat-Services. Standard: Null |
[Tabelle : 2. Parameter]

{#NChatServ-init_O_S_S__table_jgv_vqp_npb}  
Das folgende Codebeispiel zeigt, wie diese Funktion aufgerufen wird.

    guard let coreService = NowSDK.core() else {
      // Error with NowServiceError.sdkNotConfigured
      return
    }

    guard 
      let instanceUrl = URL(string: "http://sample.service-now.com"), 
      let serviceConfig = NowSDK.makeServiceConfiguration(for: instanceUrl) else {
        // Could not create service -- 
        // NowServiceError.serviceConfigurationInvalid
        return
      }
        
    let chatService = NowChatService(configuration: serviceConfig, delegate: delegate, coreServiceProvider: coreService)

## NowChatService -- makeChatUI(Design: NowChatThemeable, chatConfiguration: NowChatConfiguration? = null) -\> Result\<UIViewController, NowChatServiceError\>) {#ariaid-title3}

Erstellt `UIViewController `Die die Chat-Anwenderoberfläche hostet.
Obwohl diese Funktion die Chat-UI erstellt, müssen Sie die Chat-Sitzung trotzdem initiieren, indem Sie aufrufen [StartChat()](https://servicenow-prod.fluidtopics.net/AZ1cPcyfmzhG28zLPjBuWg#NChatServ-startChat_O "Startet eine Chatsitzung und führt einen Abschlussblock aus, nachdem die Chatsitzung gestartet wurde.")Funktion. Sie sollten diesen Anruf tätigen, wenn die Chat-UI sichtbar wird. Weitere Informationen finden Sie in der zugehörigen Beispielanwendung und [Mobile SDK Entwicklerleitfaden -- iOS](https://servicenow-prod.fluidtopics.net/~k6MSYSQHuBaRkQWi_R1yQ "Die ServiceNow Mobile SDKErmöglicht Ihnen, die Funktionalität und Ressourcen von zu nutzen ServiceNowPlattform in Ihren eigenständigen mobilen iOS-Anwendungen.").
{#NChatServ-makeChatUI_O__table_lkt_lvj_npb__entry__3}

| Name | Typ | Beschreibung |
|-|-|-|
| Design | Now ChatThemeable Objekt | Designinformationen für die zu erstellende Chat-UI. |
| Chatkonfiguration | [Now Chatkonfiguration?](https://servicenow-prod.fluidtopics.net/9NjW_m28m9Os1jAhYk8Fzg#NowChatOptionsiOS "Die Now ChatKonfiguration Mit der Klasse können Sie Optionen in einer Chatsitzung konfigurieren, z. B. das Anzeigen einer Eingabeaufforderung vor dem Schließen eines Chatfensters, das Deaktivieren von Funktionen während der Verwendung des Chats, das Anwenden verschiedener Konversationsoptionen bei Verwendung des Chats und das Konfigurieren von UI-Komponenten in Now Chat.") | Optional. Optionen, die auf die Chatsitzung angewendet werden sollen. |
[Tabelle : 3. Parameter]

{#NChatServ-makeChatUI_O__table_lkt_lvj_npb} {#NChatServ-makeChatUI_O__table_mkt_lvj_npb__entry__2}

| Typ | Beschreibung |
|-|-|
| Objekt | Erfolg: UIViewController-Objekt, das die Konfigurationsinformationen des UI-View-Controllers enthält. Fehler: NowChatServiceError-Objekt. Mögliche Fehler: * ChatServiceUngültiges Element * CoreServiceungültig * GastanwenderNichtAllow * Ungültige Anmeldeinformationen * Keine Sitzung * unbekannt * Nicht unterstütztServer |
[Tabelle : 4. Rückgaben]

{#NChatServ-makeChatUI_O__table_mkt_lvj_npb}  
Das folgende Codebeispiel zeigt, wie diese Funktion aufgerufen wird, um die Chat-UI zu erstellen.

    func makeChatScreen() -> UIViewController? {
      guard let chatService = chatService else { return nil } 

      let closePrompt = NowChatConfiguration.ClosePrompt(header: "Close Window",
        message: "Are you sure you want to close the chat window?",
        acceptButtonTitle: "Yes",
        declineButtonTitle: "No") 

      let attachmentUploadButton = NowChatConfiguration.AttachmentUploadButton(isVisible: false) // default isVisible = true

      let chatConfiguration = NowChatConfiguration(closePrompt: closePrompt,
        disabledFeatures: [.startNewConversation],
        conversationOptions: [.forceNewConversation, .endConversationOnExit],
        uiConfiguration: NowChatConfiguration.UIConfiguration(closeButton: closeButtonImage(name: "arrow.left"), attachmentUploadButton: attachmentUploadButton))

      let result = chatService.makeChatUI(theme: CarrascoChatTheme(chatColors: ChatColors()), chatConfiguration: chatConfiguration)    

      switch result {
        case .success(let chatViewController):
          return chatViewController
        case .failure(let error):
          debugPrint("Chat screen creation failed with error: \(error)") 
          return nil
      }
    }

## Now ChatService -- shutdown() {#ariaid-title4}

Fährt den Chat-Service herunter, einschließlich aller aktiven Chatsitzungen.
Nach dem Aufrufen dieser Funktion wird der zugeordnet `Now Chatservice `Ist inaktiv und kann nicht wiederverwendet werden. Um eine weitere Chatsitzung einzurichten, erstellen Sie eine neue `Now Chatservice `Instanz durch Aufrufen von Now Chat.makeChatService() Funktion.
{#NChatServ-shutdown__table_zm2_tfk_npb__entry__3}

| Name | Typ | Beschreibung |
|-|-|-|
| Keine |   |   |
[Tabelle : 5. Parameter]

{#NChatServ-shutdown__table_zm2_tfk_npb} {#NChatServ-shutdown__table_an2_tfk_npb__entry__2}

| Typ | Beschreibung |
|-|-|
| Keine |   |
[Tabelle : 6. Rückgaben]

{#NChatServ-shutdown__table_an2_tfk_npb}  
Das folgende Codebeispiel zeigt, wie diese Funktion aufgerufen wird.

    private func resetChat() {
      chatService?.shutdown()
      chatService = nil
      initializeChatService()
      viewState = makeViewState()
    }

    func initializeChatService() {
      NowChat.makeChatService(instanceUrl: instanceUrl, delegate: self) { [weak self] result in
        guard let self = self else { return }
                
        switch result {
        case .success(let service):
          self.chatService = service
        case .failure(let error):
          debugPrint("Creating the chat service failed with error: \(error)")
        }
        self.viewState = self.makeViewState()
    }

    func makeViewState() -> ViewState {
      ViewState(chatEnabled: chatService != nil,
        menuItems: menuItems)
    }

## NowChatService -- startChat(contextData: \[Zeichenfolge: Beliebig\]? = Nil, _ Abschluss: @Escaping (Result\<Void, NowChatServiceError\>) -\> Annullieren) {#ariaid-title5}

Startet eine Chatsitzung und führt einen Abschlussblock aus, nachdem die Chatsitzung gestartet wurde.
{#NChatServ-startChat_O__table_tk1_bbk_npb__entry__3}

| Name | Typ | Beschreibung |
|-|-|-|
| ContextData | \[Zeichenfolge: Beliebig\]? | Optional. Wörterbuch mit Chat-Kontextvariablen, die an die Chatsitzung übergeben werden. Weitere Informationen zu Chat-Kontextvariablen finden Sie unter [Live agent chat context variables](https://www.servicenow.com/docs/access?context=live-agent-chat-context-vars&version=yokohama&pubname=yokohama-conversational-interfaces&ft:locale=en-US). |
| Abschluss | Objekt | Abschlussblock, der nach dem Start der Chatsitzung ausgeführt werden soll. |
[Tabelle : 7. Parameter]

{#NChatServ-startChat_O__table_tk1_bbk_npb} {#NChatServ-startChat_O__table_uk1_bbk_npb__entry__2}

| Typ | Beschreibung |
|-|-|
| Ungültig oder Zeichenfolge | Rückgabewerte für den Abschlussblock: * Erfolg: Ungültig * Fehler: NowChatServiceError Mögliche Fehler: * ChatServiceUngültiges Element * CoreServiceungültig * GastanwenderNichtAllow * Ungültige Anmeldeinformationen * Keine Sitzung * unbekannt * Nicht unterstütztServer {#NChatServ-startChat_O__ul_e1n_lpj_k1c} |
[Tabelle : 8. Rückgaben]

{#NChatServ-startChat_O__table_uk1_bbk_npb}  
Das folgende Codebeispiel zeigt, wie diese Funktion ohne Kontextdaten aufgerufen wird.

    func startChat() {
      guard let chatService = chatService else {
        debugPrint("Chat service is invalid")
        viewState = makeViewState()
        return
      }
      chatService.startChat { [weak self] result in
        if case .failure(let error) = result {
          debugPrint("Chat session initialization failed with error: \(error)")
          self?.resetChat()
        }
      }
    }

    func makeViewState() -> ViewState {
      ViewState(chatEnabled: chatService != nil,
        menuItems: menuItems)
    }

Das folgende Codebeispiel zeigt, wie diese Funktion mit Kontextdaten aufgerufen wird.

    func startChat() {
      guard let chatService = chatService else {
        debugPrint("Chat service is invalid")
        viewState = makeViewState()
        return
      }

      let contextData = ["sys_id": "123456789", "table_name": "wm_task", "active": true] as [String: Any]
      chatService.startChat(contextData: contextData) { [weak self] result in
        if case .failure(let error) = result {
          debugPrint("Chat session initialization failed with error: \(error)")
          self?.resetChat()
        }
      }
    }

    func makeViewState() -> ViewState {
      ViewState(chatEnabled: chatService != nil,
        menuItems: menuItems)
    }

## NowChatService -- subscribeToUnreadMessageCount(pollingInterval: TimeInterval, Abschluss: @Escape (Int) -\> Stornieren) {#ariaid-title6}

Abonniert den Listener für die Anzahl ungelesener Nachrichten.
{#NChatServ-subToUnreadMsgCount_S__table_pv1_3ln_1qb__entry__3}

| Name | Typ | Beschreibung |
|-|-|-|
| Abfrageintervall | Zeitintervall | Häufigkeit, mit der der der Webservice nach der Anzahl der ungelesenen Chatnachrichten abgefragt werden soll. Einheit: Sekunden |
| Abschluss | @Escaping (Int) -\> Annullieren) | Abschlusshandler, der aufgerufen werden soll, um die Anzahl der ungelesenen Chatnachrichten zu melden. Int: Anzahl der ungelesenen Chatnachrichten. |
[Tabelle : 9. Parameter]

{#NChatServ-subToUnreadMsgCount_S__table_pv1_3ln_1qb} {#NChatServ-subToUnreadMsgCount_S__table_qv1_3ln_1qb__entry__2}

| Typ | Beschreibung |
|-|-|
| Keine |   |
[Tabelle : 10. Rückgaben]

{#NChatServ-subToUnreadMsgCount_S__table_qv1_3ln_1qb}  
Das folgende Codebeispiel zeigt, wie diese Funktion aufgerufen wird.

    ...
    if viewModel.isPolling {
      viewModel.unsubscribeFromUnreadMessageCount()
      viewState.pollingInterval = ""
    } else {
      viewModel.subscribeToUnreadMessageCount(pollingInterval: timeInterval)
    }
    ...

    func subscribeToUnreadMessageCount(pollingInterval: TimeInterval) {
      chatService.subscribeToUnreadMessageCount(pollingInterval: pollingInterval) { [weak self] count in
        self?.unreadMessageCount = count
      }
      isPolling = true
    }

## NowChatService -- unsubscribeFromUnreadMessageCount() {#ariaid-title7}

Hebt den Empfang des Listeners für die Anzahl ungelesener Nachrichten ab.
{#NChatServ-unsubFromUnreadMsgCount__table_inn_ywn_1qb__entry__3}

| Name | Typ | Beschreibung |
|-|-|-|
| Keine |   |   |
[Tabelle : 11. Parameter]

{#NChatServ-unsubFromUnreadMsgCount__table_inn_ywn_1qb} {#NChatServ-unsubFromUnreadMsgCount__table_jnn_ywn_1qb__entry__2}

| Typ | Beschreibung |
|-|-|
| Keine |   |
[Tabelle : 12. Rückgaben]

{#NChatServ-unsubFromUnreadMsgCount__table_jnn_ywn_1qb}  
Das folgende Codebeispiel zeigt, wie diese Funktion aufgerufen wird.

    ...
    if viewModel.isPolling {
      viewModel.unsubscribeFromUnreadMessageCount()
      viewState.pollingInterval = ""
    } else {
      viewModel.subscribeToUnreadMessageCount(pollingInterval: timeInterval)
    }
    ...
    func unsubscribeFromUnreadMessageCount() {
      chatService.unsubscribeFromUnreadMessageCount()
      isPolling = false
      unreadMessageCount = 0
    }


