במאמר הזה מוסבר איך לשלב את Headless Mobile SDK באפליקציה ל-Android ולהתאים אותו אישית. המאמר כולל את כל מה שמוסיף מידע עשיר ומובנה לסשנים של התמיכה: פעולות חכמות לפני הסשן לתיעוד ההקשר, פעולות חכמות במהלך הסשן שמופעלות על ידי נציגים (כולל אימות ביומטרי באמצעות LocalAuthentication), טפסים באינטרנט וטפסים מותאמים אישית, קבצים מצורפים שצרכנים ונציגים יוזמים, וטיפול בהפניית שיחות לתרחישים שבהם אין נציגים זמינים או שהנציגים עסוקים.
הגדרת פעולות חכמות וקבצים מצורפים
פעולות חכמות מאפשרות לנציגים וללקוחות להחליף מידע עשיר ומובנה, כמו תמונות, סרטונים, קטעי טקסט ואימות ביומטרי (Face ID ו-Touch ID).
בארכיטקטורה Headless, ערכת ה-SDK פועלת אך ורק כשכבת התעבורה המאובטחת. הוא מציין מתי נדרשת או מתבקשת פעולה, ומעביר את הנתונים בצורה מאובטחת אל Google Cloud פלטפורמת הפרויקט. מכיוון שאתם הבעלים של ממשק המשתמש, האפליקציה שלכם אחראית באופן מלא לציור של מסכי המצלמה, הכלי לבחירת תמונות, תיבות הטקסט והפעלת ההנחיות של Face ID של Apple.
פעולות חכמות לפני הפגישה
פעולות לפני סשן מאפשרות לאסוף נתונים (כמו מספר חשבון או סרטון של מוצר מקולקל) לפני שהמשתמש מצטרף לתור, וכך לקצר משמעותית את זמן הטיפול של הנציג.
מה ה-SDK מספק: הכללים והדרישות לתור ספציפי (לדוגמה, האם אימות ביומטרי, העלאת תמונה או הזנת טקסט הם אופציונליים או חובה לפני ההצטרפות).
מה יוצרים: מסכי ממשק המשתמש שלפני ההצטרפות לשיחה (הנחיות למצלמה, להזנת טקסט ולזיהוי פנים) שמופיעים בין הרגע שבו המשתמש מקיש על התור לבין הרגע שבו הוא נכנס לחדר ההמתנה, וגם הלוגיקה של שמירת נתונים במטמון בדיסק כדי לשמור בבטחה את המדיה עד שהשיחה תתחיל.
דוגמה להטמעה
הקוד הזה בודק את ההגדרה של ה-SDK כדי לראות אם יש דרישות לפני הפעלת הסשן בתור שנבחר. הוא מדגים איך לטפל בדרישה לסרטון על ידי שמירת הפניה לכתובת URL של קובץ בדיסק, במקום לשמור את הסרטון בזיכרון.
// 1. Check requirements and collect data BEFORE joining the queue
func checkPreSessionRequirements(for menu: QueueMenu) {
guard let smartActions = menu.settings else {
startChat(for: menu)
return
}
// Example: handle a video requirement
presentVideoPicker { (localFileURL) in
// IMPORTANT: localFileURL should point to NSTemporaryDirectory()
MySessionStateManager.shared.pendingPreSessionVideo = localFileURL
self.startChat(for: menu)
}
}
// 2. Upload and clean up AFTER the session officially connects
func handleSessionConnected() {
guard let pendingVideoURL = MySessionStateManager.shared.pendingPreSessionVideo else { return }
// Upload using the standard in-session pipeline
// then clean up the temporary file
try? FileManager.default.removeItem(at: pendingVideoURL)
MySessionStateManager.shared.pendingPreSessionVideo = nil
}
קריאת ההגדרות של פעולות חכמות לפני סשן
ה-SDK חושף הגדרת פעולות חכמות לפני הפעלה דרך שני נתיבים משלימים. כדאי לבדוק את שניהם כדי לקבוע אם נדרש תיעוד לפני תחילת הסשן בתור או בערוץ מסוימים.
נתיב א' – ברמת התור (QueueMenu.settings[].sdk.preSessionSmartAction):
public struct QueueMenuSetting: Decodable {
public let sdk: QueueMenuSDKSetting?
// ... other fields ...
}
public struct QueueMenuSDKSetting: Decodable {
public let preSessionSmartAction: Bool?
// ... other fields ...
}
// Usage - "does any queue-level setting require a pre-session smart action?"
func queueRequiresPreSession(_ menu: QueueMenu) -> Bool {
return menu.settings?.contains { $0.sdk?.preSessionSmartAction == true } ?? false
}
נתיב ב' – ברמת הערוץ (VoiceCallChannel.preSessionSmartAction):
// Usage - "does the voice channel specifically require pre-session capture?"
let requiresPreSessionOnVoice =
menu.channels?.voiceCall?.preSessionSmartAction == true
משתמשים בנתיב א' כדי להחליט אם להציג שער לפני הפעלת התוכן לפני שהמשתמש בוחר ערוץ. משתמשים בנתיב ב' לשיפורים ספציפיים לערוץ אחרי בחירת ערוץ (לדוגמה, הצגת הנחיה רק לפני שיחת טלפון מיידית).
פעולות חכמות במהלך סשן (שהסוכן יזם)
במהלך שיחה פעילה בצ'אט או שיחה קולית, נציג יכול ללחוץ על לחצן בלוח הבקרה כדי לבקש נתונים מהמשתמש (לדוגמה, "שלח תמונה של התעודה המזהה שלך" או "אימות באמצעות Face ID").
מה ה-SDK מספק: התראות על אירועים בזמן אמת, שמודיעות לאפליקציה שהסוכן ביקש סוג מסוים של פעולה חכמה.
מה שאתם יוצרים: התראה בשיחה או בצ'אט שמיידעת את המשתמש על הבקשה, מפעילה את הכלי המובנה המתאים (מצלמה, ספריית תמונות, שדה טקסט או Face ID) ומעבירה את התוצאה בחזרה ל-SDK.
דוגמה להטמעה
כאן האפליקציה מאזינה לאירועים של ה-SDK. כשהוא מזהה בקשה מסוכן, הוא מציג התראה ואז פותח את הכלי המתאים ב-iOS.
// Listen for Smart Action requests from the active SDK session.
//
// `SmartActionType` exposes the following cases: `.photo`, `.video`,
// `.screenshot`, `.text`, `.verification`, `.screenShare`, `.unknown`.
// Use `.verification` (not `.biometric`) for Face ID / Touch ID flows -
// there is no `.biometric` case on the enum.
func handleSmartActionRequest(_ request: SmartActionRequest) {
switch request.type {
case .photo:
promptUserForPhoto(message: "The agent requested a photo.") { capturedImage in
// Send the image back to the agent using the SDK
self.sendAttachment(image: capturedImage)
}
case .video:
// Agent-requested video capture. Reuse the same disk-caching pattern
// recommended for pre-session media - keep the recording on disk and
// pass the file URL to the SDK rather than holding the raw `Data` in
// memory.
promptUserForVideo(message: "The agent requested a video.") { capturedVideoURL in
self.sendAttachment(videoURL: capturedVideoURL)
}
case .screenshot:
// The SDK exposes `.screenshot` as a distinct request type - the user
// captures (or selects) a single still image of the current screen.
// This is **not** the same as the following `.screenShare` case, which starts a
// live co-browse session.
promptUserForScreenshot(message: "The agent requested a screenshot.") { capturedImage in
self.sendAttachment(image: capturedImage)
}
case .verification:
// Use Face ID / Touch ID using LocalAuthentication. The SDK exposes
// this case as `.verification`; there is no `.biometric` case on
// `SmartActionType`.
performAppleBiometricAuth { success in
self.sendBiometricResult(success: success)
}
case .text:
presentTextInputPrompt(message: "The agent requested text input.") { text in
self.sendSmartActionText(text)
}
case .screenShare:
// Hand off to the full screen share flow (see Headless Mobile SDK for iOS: Voice, Screen Share, Scheduled Call, and Email).
// Don't confuse this with `.screenshot` described earlier - `.screenShare` starts a
// live co-browse session using `CCAIScreenShare`, while `.screenshot`
// captures a single still frame.
startScreenShareFlow()
case .unknown:
// Future-proof: a smart action type the SDK doesn't recognize.
// Log and continue - don't block the user.
print("CCAI: received unknown smart action type")
@unknown default:
// Defensive: handle any cases added to `SmartActionType` in future
// SDK releases.
break
}
}
התראות ומעקב על פעולות חכמות
אפשר להשתמש ב-smartActionService כדי לאשר ולעדכן פעולות חכמות כשהמשתמש מתקדם בהן.
let router = CommunicationRouter(id: chatId, type: .chat)
// Notify the server that a smart action has been received
do {
try await CCAI.shared.smartActionService?.notifySmartActionReceived(
router: router,
smartActionId: smartActionId
)
print("Smart action notification sent successfully")
} catch {
print("Failed to notify smart action: \(error)")
}
// Update the smart action status as the user completes it
do {
try await CCAI.shared.smartActionService?.updateSmartActionStatus(
router: router,
smartActionId: smartActionId,
status: .finished
)
print("Smart action status updated successfully")
} catch {
print("Failed to update smart action status: \(error)")
}
אם הפעולה דורשת קלט טקסט, צריך לאסוף את הטקסט בממשק המשתמש ולשלוח אותו דרך שירות הפעולות החכמות לפני שמסמנים את הפעולה כהושלמה.
טפסים באינטרנט
מה ערכת ה-SDK מספקת: ממשקי API לאחזור, להצגה ולבדיקה של טפסים באינטרנט שמופעלים על ידי נציגים במהלך סשן צ'אט.
מה יוצרים: ממשק משתמש לעיבוד טופס האינטרנט ותהליך השליחה שכולל את התשובות של המשתמש.
דוגמה להטמעה
הקוד הזה מאחזר טופס אינטרנט לפי מזהה הפעולה החכמה ומזהה הטופס החיצוני, ואז מאמת את התשובה לפני השליחה.
// Fetch a web form - WebFormRequest has no `signature` parameter on iOS
let webFormRequest = WebFormRequest(
smartActionId: 123,
externalFormId: "form123"
)
do {
let webFormResponse = try await CCAI.shared.chatService?.fetchWebForm(webFormRequest)
if let response = webFormResponse {
print("Web form received: \(response)")
}
} catch {
print("Failed to fetch web form: \(error)")
}
// Validate a web form response
do {
let isValid = try await CCAI.shared.chatService?.validateWebForm(webFormResponse)
if isValid == true {
print("Web form is valid")
} else {
print("Web form validation failed")
}
} catch {
print("Failed to validate web form: \(error)")
}
הגדרות המבנה המלאות של WebFormResponse, FormPayload ו-WebFormData מופיעות במאמרי העזרה של ה-API של Headless Mobile SDK – iOS.
טפסים בהתאמה אישית
מה ה-SDK מספק: ממשקי API לאחזור הגדרות של טפסים שאפשר להגדיר (עם כמה סוגים של שאלות) ולשליחת התשובות של המשתמשים.
מה יוצרים: ממשק משתמש דינמי של טופס שמציג כל סוג של שאלה (כמו שדות טקסט ותפריטים נפתחים), מאמת את הקלט ואוסף תשובות לשליחה.
דוגמה להטמעה
הקוד הזה מאחזר את הגדרות השאלות של טופס מותאם אישית, ואז אורז ושולח את התשובות של המשתמש.
// Retrieve custom form details
do {
let form = CustomForm(
id: 123,
name: nil,
title: nil,
subtitle: nil,
smartActionId: nil,
image: nil,
header: nil,
footer: nil
)
let formDetails = try await CCAI.shared.chatService?.getCustomFormDetails(form)
if let details = formDetails {
print("Form Title: \(details.title ?? "No title")")
print("Questions: \(details.questions.count)")
}
} catch {
print("Failed to get custom form details: \(error)")
}
// Submit a custom form
let request = SubmitCustomFormRequest(
smartActionId: 123,
formResponse: [
SubmitCustomFormRequest.Answer(questionId: 1, value: "John Doe"),
SubmitCustomFormRequest.Answer(questionId: 2, value: "john@example.com")
]
)
do {
try await CCAI.shared.chatService?.submitCustomForm(request: request)
print("Form submitted successfully")
} catch {
print("Failed to submit form: \(error)")
}
להגדרות ה-enum המלאות של CustomFormDetailsResponse, CustomFormQuestion,
CustomFormQuestionOption ו-CustomFormQuestionType, ראו את מאמרי העזרה של ה-API של Headless Mobile SDK – iOS.
קבצים מצורפים ביוזמת הצרכן (צ'אט)
המשתמשים לא צריכים לחכות שהנציג יבקש, הם יכולים לשלוח תמונות וסרטונים באופן יזום במהלך הצ'אט. ה-SDK אוכף מגבלות קפדניות על גודל הקובץ ומנסה לדחוס אותו באופן אוטומטי לפני ההעברה.
מגבלות הגודל של קבצים מצורפים
תמונות: עד 2MB
סרטונים: עד 20MB
מה ה-SDK מספק: צינור מאובטח להעלאה שמטפל בהעברה ברשת ודוחס קבצים באופן אוטומטי כדי לעמוד במגבלות של פרויקט Google Cloud .
מה אתם בונים: לחצן האטב / הקובץ המצורף בממשק המשתמש של הצ'אט, הכלי לבחירת תמונות / סרטונים ובועת הצ'אט החזותית שמציגה את סטטוס ההעלאה (טעינה, נשלח או נכשל).
דוגמה להטמעה
כשמשתמש בוחר תמונה או סרטון מתוך זיכרון המצלמה, צריך להמיר אותם ל-Data (לתמונות) או לאחזר את כתובת ה-URL של הקובץ המקומי (לסרטונים), ואז להעביר אותם ל-SDK באמצעות אותו API sendMessage שמשמש לכל ההודעות היוצאות (ראו את הקטע שליחת הודעות במאמר Headless Mobile SDK for iOS: Queues, channels, and chat). ה-SDK מטפל בדחיסה ובהעלאה.
import PhotosUI
// Called when the user picks an image from their photo library
func userDidSelectImage(_ image: UIImage) {
guard let imageData = image.jpegData(compressionQuality: 0.8) else { return }
// Show a loading bubble in your custom chat UI
let messageBubble = myChatUI.addLoadingImageBubble()
Task {
do {
// Wrap the raw data in an UploadableImage
let uploadableImage = UploadableImage(data: imageData, mimeType: "image/jpeg")
// Pass to the SDK - compression and upload are handled automatically
try await CCAI.shared.chatService?.sendMessage(
.images(images: [uploadableImage], smartAction: nil)
)
messageBubble.markAsSent()
} catch {
// The SDK returns an error if the file exceeds limits even after compression
messageBubble.showError("Failed to send: \(error.localizedDescription)")
}
}
}
// Called when the user picks a video from their photo library
func userDidSelectVideo(at localURL: URL) {
let messageBubble = myChatUI.addLoadingVideoBubble()
Task {
do {
let uploadableVideo = UploadableVideo(url: localURL, mimeType: "video/mp4")
try await CCAI.shared.chatService?.sendMessage(
.videos(videos: [uploadableVideo], smartAction: nil)
)
messageBubble.markAsSent()
} catch {
messageBubble.showError("Failed to send: \(error.localizedDescription)")
}
}
}
קבצים מצורפים שנשלחו על ידי נציג (צ'אט)
סוכנים יכולים לשלוח קבצים בחזרה למשתמש, כולל תמונות, סרטונים, קטעי אודיו ומסמכים (קובצי PDF, קובצי CSV וכו').
סוגי קבצים נתמכים
בפלטפורמת Google Cloud הפרויקט אפשר להשתמש ב-19 סוגי קבצים ב-4 קטגוריות. ממשק המשתמש המותאם אישית צריך לטפל בכל קטגוריה בצורה חלקה (תצוגה מקדימה של תמונה, נגן וידאו, נגן אודיו, הורדת מסמך).
| קטגוריה | סוגים נתמכים |
|---|---|
| תמונות | JPEG, PNG, GIF ו-WebP. |
| וידאו | MP4, MOV, AVI, WMV ו-WebM. |
| אודיו | MP3, WAV, M4A ו-WEBA. |
| מסמכים | PDF, DOC, XLS, PPT, CSV ו-TXT. |
מה ש-SDK מספק: מטען ייעודי (payload) של הודעות צ'אט נכנסות (מועבר באמצעות messagesReceived Combine publisher – אפשר לעיין בקטע Reactive patterns with Combine במאמר Headless Mobile SDK for iOS: Post-session and advanced topics) שכולל מטא-נתונים של קבצים מצורפים. שירות הצ'אט מספק גם downloadMedia
לשליפה מאובטחת של מדיה שנשלחה על ידי נציג).
מה שאתם יוצרים: ממשק המשתמש להצגת הקבצים המצורפים בפיד הצ'אט. האפליקציה שלכם מחליטה אם להציג תצוגות מקדימות של תמונות, תמונות ממוזערות של סרטונים, אמצעי בקרה להפעלת אודיו או לחצנים להורדת מסמכים.
דוגמה להטמעה
להירשם לקבלת הודעות נכנסות באמצעות messagesReceived. אם הודעה חדשה כוללת מטא-נתונים של מדיה, צריך להפעיל את downloadMedia לפני העיבוד או הפתיחה של הקובץ.
downloadMedia מחזירה DownloadMediaResponse { data: Data, fileName: String?
} – הבייטים שהורדו במלואם בתוספת שם קובץ אופציונלי לתצוגה. ה-SDK לא שומר הורדות במטמון. אם ממשק המשתמש גולל חזרה לבועה ישנה יותר או נכנס מחדש לתצוגת הצ'אט, האפליקציה אחראית לשמירת התמונה המפוענחת במטמון או לשמירת הבייטים. קריאה חוזרת ל-downloadMedia מפעילה אחזור נוסף מהרשת.
import Combine
private var cancellables = Set<AnyCancellable>()
CCAI.shared.chatService?.messagesReceived
.receive(on: DispatchQueue.main)
.sink { [weak self] messages in
for message in messages {
self?.renderIncomingMessage(message)
}
}
.store(in: &cancellables)
func renderIncomingMessage(_ message: ChatMessage) {
guard let media = message.media else {
myChatUI.insertTextBubble(text: message.text)
return
}
Task {
do {
// `downloadMedia` returns the raw bytes plus an optional filename.
// First arg is unlabeled.
let response = try await CCAI.shared.chatService?.downloadMedia(
media.id,
mediaType: media.type
)
guard let response else { return }
await MainActor.run {
switch media.type {
case .photo:
// Decode in-memory - no disk write needed.
if let image = UIImage(data: response.data) {
myChatUI.insertImageBubble(
image: image,
fileName: response.fileName
)
}
case .video, .audio, .document:
// Larger media usually needs an on-disk URL for AVPlayer
// or QLPreviewController. Write to the temp directory
// yourself and hand the resulting URL to your UI helper.
let url = FileManager.default
.temporaryDirectory
.appendingPathComponent(response.fileName ?? "attachment")
try? response.data.write(to: url)
myChatUI.insertAttachmentBubble(
fileURL: url,
mediaType: media.type
)
}
}
} catch {
await MainActor.run {
myChatUI.insertAttachmentErrorBubble(fileName: message.media?.name)
}
}
}
}
למידע על סוגי המטא-נתונים המדויקים של הודעות צ'אט וקבצי מדיה, אפשר לעיין במאמרי העזרה של ה-API של Headless Mobile SDK — iOS.
הפניית שיחות (אחרי שעות הפתיחה ומעבר לקיבולת)
הפניית שיחות היא תכונה חשובה במוקד שירות הלקוחות, שמעבירה את המשתמשים למקום אחר כשהצוות שלכם לא זמין. בדרך כלל זה קורה באחד משני תרחישים:
אחרי שעות הפעילות: המשתמש מנסה ליצור קשר עם התמיכה מחוץ לשעות הפעילות שהגדרתם.
קיבולת יתר: התור פתוח, אבל זמן ההמתנה חורג מהסף המקסימלי שהוגדר על ידי האדמינים.
בארכיטקטורה ללא ראש, ה-SDK לא חוסם את המשתמש באופן אוטומטי ולא מציג מסך שגיאה. במקום זאת, הוא מעביר בשקט לאפליקציה את סטטוס ההפניה ואת אפשרויות הגיבוי שהוגדרו על ידי האדמין. האפליקציה צריכה לבדוק את הסטטוס הזה לפני שהיא מנסה להתחיל סשן.
טיפול במצבי הפניה
מה ה-SDK מספק: deflectionFrom: [QueueMenuDeflection]? ב-QueueMenu שמפרט את כללי ההפניה הנכנסים להפניית תורים אחרים לתור הזה. כל QueueMenuDeflection מכיל רק שני שדות:
deflectionType: DeflectionType?– קטגוריית ההפניה (לדוגמה, אחרי שעות הפעילות או מעבר לקיבולת).
menuId: Int?– המזהה של תור המקור שממנו מועברות שיחות לתור הזה.
QueueMenuDeflection לא כולל הודעה להצגה או תווית שאנשים יכולים לקרוא.
לגבי טקסט שמוצג למשתמשים, צריך לעבור על המערך settings בעצמכם (או לחזור למחרוזות שהוגדרו על ידי האדמין). כדי לחפש את השם לתצוגה של תור המקורות שנפתרו, משתמשים בתוסף findMenu(byId:) ב-[QueueMenu] כדי לחפש אותו בעץ התפריטים שכבר אוחזר.
מה בונים: הלוגיקה לבדיקת מצבי ההפניה האלה לפני שמכניסים משתמש לתור, וממשק המשתמש המותאם אישית (כמו התראה במסך מלא או באנר) שמציג את ההודעה המתאימה ואת לחצני הניתוב החלופיים.
דוגמה להטמעה
הקוד הבא מיירט ניסיון של משתמש להתחיל צ'אט. הוא בודק את המטא-נתונים של ההפניה של ה-SDK ב-QueueMenu, ואם כלל פעיל, הוא פותר את ההודעה מחוץ לשעות הפעילות מההגדרות של התור ומציג מסך הפניה.
// Helper - pull the first after-hours message text out of the queue's settings
func afterHoursMessageText(for menu: QueueMenu) -> String? {
return menu.settings?
.compactMap { $0.afterHours?.message?.text }
.first
}
// Called when the user taps "Start Chat" in your app
func attemptToStartChat(for menu: QueueMenu) {
// 1. Check if any deflection rules route into this queue
if let deflections = menu.deflectionFrom, !deflections.isEmpty {
let message = afterHoursMessageText(for: menu)
?? "Support is currently unavailable."
showDeflectionScreen(message: message, deflections: deflections)
} else {
// No deflection rules apply. Safe to start the chat.
Task {
await startChat(for: menu)
}
}
}
אפשרויות להפניית עיבוד
כשכלל להפניית שיחות פעיל, האדמינים שלכם בדרך כלל יגדירו דרכים חלופיות למשתמש לקבל עזרה – בדרך כלל על ידי הפניה לתור אחר (שאפשר לפתור את הבעיה באמצעות menuId) או על ידי הצגת הטקסט של התור הנוכחי אחרי שעות הפעילות.
מה ה-SDK מספק: רשימת הערכים של QueueMenuDeflection ב-deflectionFrom, כל אחד עם deflectionType ו-menuId.
מה יוצרים: תפריט דינמי שחוזר על הרשומות האלה, מפענח כל menuId מול עץ התפריט שכבר אוחזר כדי לקבל שם לתצוגה, ויוצר את הלחצנים המתאימים.
דוגמה להטמעה
הקוד הזה לוקח את רשומות ההפניה ויוצר מסך באופן דינמי. הוא פותר את השם של תור המקור באמצעות התוסף findMenu(byId:) שסופק על ידי ה-SDK ב-[QueueMenu], וחוזר לשם deflectionType אם שם התור לא זמין.
func showDeflectionScreen(
message: String,
deflections: [QueueMenuDeflection],
cachedRootMenus: [QueueMenu]
) {
// 1. Update your UI with the resolved message (or your fallback)
deflectionTitleLabel.text = message
// 2. Loop through the incoming deflection rules and generate buttons
for deflection in deflections {
let sourceMenu = deflection.menuId.flatMap { cachedRootMenus.findMenu(byId: $0) }
let label = sourceMenu?.name
?? deflection.deflectionType.map { String(describing: $0) }
?? "Alternative option"
let button = createButton(title: label) {
self.handleDeflectionAction(deflection)
}
menuStackView.addArrangedSubview(button)
}
// 3. Present the compiled screen to the user
present(deflectionViewController, animated: true)
}
deflectionFrom היא רשימת כללי ההפניה האוטומטית שמובילים לתפריט הזה –
כל רשומה menuId מזהה תור מקור שמפנה אוטומטית לתור הנוכחי. האפליקציה שלכם מחליטה איך להציג את ההודעות האלה: בשילובים מסוימים, תור היעד מוצג כהודעה בסגנון 'כאן נשלח אותך במקום זאת', ובשילובים אחרים, נוכחות של כלל כלשהו משמשת כשער להצגת מסך כללי בסגנון 'נסה שוב מאוחר יותר'.