בניית אפליקציית ברירת מחדל לטלפון

אפליקציית טלפון שמוגדרת כברירת מחדל מאפשרת למסגרת Android Telecom להודיע לאפליקציה על מצב השיחה באמצעות מנהל התפקידים והשירות במהלך השיחה, כדי ליצור תחליף לאפליקציית הטלפון שמוגדרת כברירת מחדל במכשיר Android, ולהטמיע את InCallService API. ההטמעה צריכה לעמוד בדרישות הבאות:

הוא לא יכול לכלול יכולת להתקשר, אלא רק את ממשק המשתמש לביצוע שיחות. הוא צריך לטפל בכל השיחות ש-Telecom framework מזהה, ולא להניח הנחות לגבי אופי השיחות. לדוגמה, אסור להניח שהשיחות הן שיחות טלפוניה מבוססות-SIM, או להטמיע הגבלות על שיחות שמבוססות על ConnectionService אחד, כמו אכיפה של הגבלות טלפוניה על שיחות וידאו.

אפליקציית שיחות מאפשרת למשתמשים לקבל או לבצע שיחות אודיו או וידאו במכשיר שלהם. אפליקציות שיחות משתמשות בממשק משתמש משלהן לשיחות במקום בממשק ברירת המחדל של אפליקציית "טלפון", כמו שמוצג בצילום המסך הבא.

דוגמה לאפליקציית שיחות
דוגמה לאפליקציית שיחות שמשתמשת בממשק משתמש משלה

מסגרת Android כוללת את החבילה android.telecom, שמכילה מחלקות שעוזרות לכם ליצור אפליקציית שיחות בהתאם למסגרת הטלקום. אם תפתחו את האפליקציה בהתאם למסגרת הטלקום, תוכלו ליהנות מהיתרונות הבאים:

  • האפליקציה פועלת בצורה תקינה עם תת-המערכת המקורית של הטלקום במכשיר.
  • האפליקציה פועלת בצורה תקינה עם אפליקציות שיחות אחרות שגם פועלות בהתאם למסגרת.
  • ה-framework עוזר לאפליקציה לנהל את הניתוב של האודיו והווידאו.
  • המסגרת עוזרת לאפליקציה לקבוע אם השיחות שלה נמצאות במוקד.

הצהרות והרשאות במניפסט

בקובץ המניפסט של האפליקציה, מצהירים שהאפליקציה משתמשת בהרשאה MANAGE_OWN_CALLS, כמו בדוגמה הבאה:

<manifest … >
    <uses-permission android:name="android.permission.MANAGE_OWN_CALLS"/>
</manifest>

מידע נוסף על הצהרה על הרשאות שניתנות לאפליקציה זמין במאמר הרשאות.

אתם צריכים להצהיר על שירות שמציין את המחלקה שמטמיעה את המחלקה ConnectionService באפליקציה. תת-המערכת של הטלקום דורשת שהשירות יצהיר על ההרשאה BIND_TELECOM_CONNECTION_SERVICE כדי שיהיה אפשר לקשר אליו. בדוגמה הבאה אפשר לראות איך להצהיר על השירות בקובץ המניפסט של האפליקציה:

<service android:name="com.example.MyConnectionService"
    android:permission="android.permission.BIND_TELECOM_CONNECTION_SERVICE">
    <intent-filter>
        <action android:name="android.telecom.ConnectionService" />
    </intent-filter>
</service>

מידע נוסף על הצהרה על רכיבי אפליקציה, כולל שירותים, זמין במאמר רכיבי אפליקציה.

הטמעת שירות החיבור

אפליקציית השיחות צריכה לספק הטמעה של המחלקה ConnectionService שתתת-המערכת של הטלקום תוכל להתחבר אליה. ההטמעה של ConnectionService צריכה לשנות את השיטות הבאות:

onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)

תת-המערכת של הטלקום קוראת ל-method הזו בתגובה לכך שהאפליקציה קוראת ל-placeCall(Uri, Bundle) כדי ליצור שיחה יוצאת חדשה. האפליקציה מחזירה מופע חדש של הטמעת המחלקה Connection (למידע נוסף, ראו הטמעת החיבור) כדי לייצג את השיחה היוצאת החדשה. כדי להתאים אישית את החיבור היוצא, אפשר לבצע את הפעולות הבאות:

onCreateOutgoingConnectionFailed(PhoneAccountHandle, ConnectionRequest)

תת-המערכת של הטלקום מפעילה את ה-method הזו כשהאפליקציה מפעילה את ה-method‏ placeCall(Uri, Bundle) ואי אפשר לבצע את השיחה היוצאת. במצב כזה, האפליקציה צריכה להודיע למשתמש (לדוגמה, באמצעות תיבת התראה או הודעה קצרה) שלא ניתן לבצע את השיחה היוצאת. יכול להיות שהאפליקציה לא תוכל להתקשר אם יש שיחת חירום פעילה, או אם יש שיחה פעילה באפליקציה אחרת שאי אפשר להשהות לפני שמתקשרים.

onCreateIncomingConnection(PhoneAccountHandle, ConnectionRequest)

תת-המערכת של הטלקום מפעילה את ה-method הזה כשהאפליקציה מפעילה את ה-method‏ addNewIncomingCall(PhoneAccountHandle, Bundle) כדי להודיע למערכת על שיחה נכנסת חדשה באפליקציה. האפליקציה מחזירה מופע חדש של ההטמעה של Connection (מידע נוסף זמין בקטע הטמעת החיבור) כדי לייצג את השיחה הנכנסת החדשה. כדי להתאים אישית את החיבור הנכנס, אפשר לבצע את הפעולות הבאות:

onCreateIncomingConnectionFailed(PhoneAccountHandle, ConnectionRequest)

תת-המערכת של Telecom מפעילה את השיטה הזו כשהאפליקציה מפעילה את השיטה addNewIncomingCall(PhoneAccountHandle, Bundle) כדי להודיע ל-Telecom על שיחה נכנסת חדשה, אבל השיחה הנכנסת לא מותרת (מידע נוסף זמין בקטע אילוצים בשיחות). האפליקציה צריכה לדחות את השיחה הנכנסת בלי להשמיע צליל, ואפשר להציג התראה כדי ליידע את המשתמש על השיחה שלא נענתה.

הטמעת החיבור

האפליקציה צריכה ליצור מחלקת משנה של Connection כדי לייצג את השיחות באפליקציה. צריך לשנות את השיטות הבאות בהטמעה:

onShowIncomingCallUi()

תת-המערכת של הטלקום קוראת ל-method הזו כשמוסיפים שיחה נכנסת חדשה, והאפליקציה אמורה להציג את ממשק המשתמש של השיחה הנכנסת.

onCallAudioStateChanged(CallAudioState)

תת-המערכת של הטלקום קוראת ל-method הזה כדי להודיע לאפליקציה שהמצב או הנתיב הנוכחיים של האודיו השתנו. הפונקציה הזו מופעלת בתגובה לשינוי של מצב האודיו באפליקציה באמצעות השיטה setAudioRoute(int). יכול להיות שהשיטה הזו תופעל גם אם המערכת תשנה את נתיב האודיו (לדוגמה, כשאוזניות Bluetooth מתנתקות).

onHold()

תת-המערכת של הטלקום מפעילה את ה-method הזו כשהיא רוצה להעביר שיחה להמתנה. בתגובה לבקשה הזו, האפליקציה צריכה להשהות את השיחה ואז להפעיל את ה-method‏ setOnHold() כדי להודיע למערכת שהשיחה מושהית. יכול להיות שתת-המערכת של הטלקום תפעיל את השיטה הזו כששירות בשיחה, כמו Android Auto, שמציג את השיחה, רוצה להעביר בקשה של משתמש להעביר את השיחה למצב המתנה. תת-המערכת של הטלקום גם קוראת לשיטה הזו אם המשתמש מפעיל שיחה באפליקציה אחרת. מידע נוסף על שירותים במהלך שיחה זמין בכתובת InCallService.

onUnhold()

תת-המערכת של הטלקום קוראת ל-method הזו כשהיא רוצה להמשיך שיחה שהושהתה. אחרי שהאפליקציה ממשיכה את השיחה, היא צריכה להפעיל את השיטה setActive() כדי להודיע למערכת שהשיחה כבר לא בהמתנה. תת-המערכת של הטלקום יכולה להפעיל את השיטה הזו כששירות במהלך שיחה, כמו Android Auto, שבו מוצגת השיחה, רוצה להעביר בקשה להמשך השיחה. מידע נוסף על שירותים במהלך שיחה זמין במאמר InCallService.

onAnswer()

תת-המערכת של הטלקום קוראת ל-method הזו כדי להודיע לאפליקציה שצריך לענות לשיחה נכנסת. אחרי שהאפליקציה עונה לשיחה, היא צריכה להפעיל את ה-method‏ setActive() כדי להודיע למערכת שהשיחה נענתה. יכול להיות שתת-המערכת של הטלקום תפעיל את השיטה הזו כשהאפליקציה שלכם תוסיף שיחה נכנסת חדשה, וכבר תהיה שיחה פעילה באפליקציה אחרת שאי אפשר להעביר להמתנה. במקרים כאלה, תת-המערכת של הטלקום מציגה את ממשק המשתמש של השיחה הנכנסת בשם האפליקציה. ה-framework מספקת שיטה עמוסה (overloaded) שמאפשרת לציין את מצב הווידאו שבו השיחה תיענה. מידע נוסף זמין במאמר onAnswer(int).

onReject()

תת-המערכת של הטלקום קוראת ל-method הזו כשהיא רוצה לדחות שיחה נכנסת. אחרי שהאפליקציה דוחה את השיחה, היא צריכה לשלוח קריאה אל setDisconnected(DisconnectCause) ולציין את REJECTED כפרמטר. לאחר מכן, האפליקציה צריכה להפעיל את ה-method‏ destroy() כדי להודיע למערכת שהאפליקציה עיבדה את השיחה. תת-המערכת של הטלקום מפעילה את השיטה הזו כשהמשתמש דוחה שיחה נכנסת מהאפליקציה.

onDisconnect()

תת-המערכת של הטלקום קוראת ל-method הזה כשהיא רוצה לנתק שיחה. בסיום השיחה, האפליקציה צריכה להפעיל את ה-method‏ setDisconnected(DisconnectCause) ולציין את הפרמטר LOCAL כדי לציין שבקשת משתמש גרמה לניתוק השיחה. לאחר מכן, האפליקציה צריכה להפעיל את ה-method‏ destroy() כדי להודיע לתת-המערכת של הטלקום שהאפליקציה עיבדה את השיחה. המערכת עשויה להפעיל את השיטה הזו כשהמשתמש מנתק שיחה דרך שירות אחר שפועל במהלך השיחה, כמו Android Auto. המערכת גם מפעילה את ה-method הזה כשהשיחה צריכה להתנתק כדי לאפשר שיחה אחרת, למשל אם המשתמש רוצה לבצע שיחת חירום. מידע נוסף על שירותים במהלך שיחה זמין במאמר InCallService.

איך מטפלים בתרחישי שיחות נפוצים

כדי להשתמש ב-API של ConnectionService בתהליך השיחה, צריך לבצע אינטראקציה עם המחלקות האחרות בחבילה android.telecom. בקטעים הבאים מתוארים תרחישים נפוצים של שיחות ואיך האפליקציה צריכה להשתמש בממשקי ה-API כדי לטפל בהם.

מענה לשיחות נכנסות

התהליך לטיפול בשיחות נכנסות משתנה אם יש שיחות באפליקציות אחרות או לא. הסיבה להבדל בתהליכים היא ש-Telecom Framework צריך להגדיר כמה מגבלות כשיש שיחות פעילות באפליקציות אחרות, כדי להבטיח סביבה יציבה לכל אפליקציות השיחות במכשיר. מידע נוסף מופיע במאמר אילוצים של קריאות.

אין שיחות פעילות באפליקציות אחרות

כדי לענות לשיחות נכנסות כשאין שיחות פעילות באפליקציות אחרות, פועלים לפי השלבים הבאים:

  1. האפליקציה מקבלת שיחה נכנסת חדשה באמצעות המנגנונים הרגילים שלה.
  2. משתמשים ב-method‏ addNewIncomingCall(PhoneAccountHandle, Bundle) כדי להודיע לתת-המערכת של הטלקום על השיחה הנכנסת החדשה.
  3. תת-המערכת של הטלקום נקשרת להטמעה של ConnectionService באפליקציה ומבקשת מופע חדש של המחלקה Connection שמייצגת את השיחה הנכנסת החדשה באמצעות ה-method‏ onCreateIncomingConnection(PhoneAccountHandle, ConnectionRequest).
  4. תת-המערכת של הטלקום מודיעה לאפליקציה שהיא צריכה להציג את ממשק המשתמש של השיחה הנכנסת באמצעות השיטה onShowIncomingCallUi().
  5. האפליקציה מציגה את ממשק המשתמש של השיחה הנכנסת באמצעות התראה עם intent במסך מלא משויך. מידע נוסף זמין במידע לגבי קוד onShowIncomingCallUi().
  6. מפעילים את ה-method‏ setActive() אם המשתמש מקבל את השיחה הנכנסת, או את setDisconnected(DisconnectCause) עם הפרמטר REJECTED ואחריו את ה-method‏ destroy() אם המשתמש דוחה את השיחה הנכנסת.

שיחות פעילות באפליקציות אחרות שאי אפשר להעביר להמתנה

כדי לענות לשיחות נכנסות כשיש שיחות פעילות באפליקציות אחרות שאי אפשר להעביר להמתנה, פועלים לפי השלבים הבאים:

  1. האפליקציה מקבלת שיחה נכנסת חדשה באמצעות המנגנונים הרגילים שלה.
  2. משתמשים ב-method‏ addNewIncomingCall(PhoneAccountHandle, Bundle) כדי להודיע לתת-המערכת של הטלקום על השיחה הנכנסת החדשה.
  3. תת-המערכת של הטלקום נקשרת להטמעה של ConnectionService באפליקציה ומבקשת מופע חדש של האובייקט Connection שמייצג את השיחה הנכנסת החדשה באמצעות ה-method‏ onCreateIncomingConnection(PhoneAccountHandle, ConnectionRequest).
  4. תת-המערכת של הטלקום מציגה את ממשק המשתמש של השיחה הנכנסת.
  5. אם המשתמש מקבל את השיחה, תת-המערכת של הטלקום קוראת ל-method‏ onAnswer(). כדי לציין לתת-המערכת של הטלקום שהשיחה מחוברת עכשיו, צריך להפעיל את ה-method‏ setActive().
  6. אם המשתמש דוחה את השיחה, תת-המערכת של הטלקום קוראת ל-method‏ onReject(). צריך להפעיל את ה-method‏ setDisconnected(DisconnectCause) ולציין את REJECTED כפרמטר, ואז להפעיל את ה-method‏ destroy().

לבצע שיחות יוצאות

התהליך של ביצוע שיחה יוצאת כולל טיפול באפשרות שלא ניתן לבצע את השיחה בגלל מגבלות שהוטלו על ידי מסגרת הטלקום. מידע נוסף זמין במאמר אילוצים של שיחות.

כדי לבצע שיחה יוצאת:

  1. המשתמש מתחיל שיחה יוצאת באפליקציה.
  2. משתמשים ב-method‏ placeCall(Uri, Bundle) כדי להודיע לתת-המערכת של הטלקום על השיחה היוצאת החדשה. חשוב לשים לב לפרמטרים הבאים של השיטה:
    • הפרמטר Uri מייצג את הכתובת שאליה מתבצעת השיחה. למספרי טלפון רגילים, משתמשים בסכמת ה-URI‏ tel:.
    • הפרמטר Bundle מאפשר לכם לספק מידע על אפליקציית השיחות שלכם על ידי הוספת האובייקט PhoneAccountHandle של האפליקציה לתוספת EXTRA_PHONE_ACCOUNT_HANDLE. האפליקציה צריכה לספק את האובייקט PhoneAccountHandle לכל שיחה יוצאת.
    • הפרמטר Bundle מאפשר גם לציין אם השיחה היוצאת כוללת וידאו, על ידי ציון הערך STATE_BIDIRECTIONAL בתוספת EXTRA_START_CALL_WITH_VIDEO_STATE. חשוב לזכור שכברירת מחדל, תת-המערכת של הטלקום מנתבת שיחות וידאו למצב רמקול.
  3. תת-המערכת של הטלקום נקשרת להטמעה של ConnectionService באפליקציה.
  4. אם האפליקציה לא יכולה לבצע שיחה יוצאת, תת-המערכת של הטלקום קוראת ל-method‏ onCreateOutgoingConnectionFailed(PhoneAccountHandle, ConnectionRequest) כדי להודיע לאפליקציה שאי אפשר לבצע את השיחה כרגע. האפליקציה צריכה להודיע למשתמש שאי אפשר לבצע את השיחה.
  5. אם האפליקציה יכולה לבצע את השיחה היוצאת, תת-המערכת של הטלקום קוראת ל-method‏ onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest). האפליקציה צריכה להחזיר מופע של המחלקה Connection כדי לייצג את השיחה היוצאת החדשה. למידע נוסף על המאפיינים שצריך להגדיר בחיבור, קראו את המאמר הטמעת שירות החיבור.
  6. אחרי שהשיחה היוצאת מתחברת, מפעילים את ה-method‏ setActive() כדי להודיע לתת-המערכת של הטלקום שהשיחה פעילה.

איך מסיימים שיחות

כדי לסיים שיחה:

  1. קוראים ל-setDisconnected(DisconnectCause) ושולחים את LOCAL כפרמטר אם המשתמש סיים את השיחה, או שולחים את REMOTE כפרמטר אם הצד השני סיים את השיחה.
  2. מבצעים קריאה ל-destroy().

מגבלות על שיחות

כדי להבטיח חוויית שיחה עקבית ופשוטה למשתמשים, מסגרת הטלקום אוכפת כמה מגבלות על ניהול השיחות במכשיר. לדוגמה, נניח שהמשתמש התקין שתי אפליקציות לשיחות שמטמיעות את ה-API לניהול עצמי של ConnectionService, FooTalk ו-BarTalk. במקרה כזה, חלות המגבלות הבאות:

  • במכשירים עם API ברמה 27 או נמוכה יותר, רק אפליקציה אחת יכולה לנהל שיחה פעילה בכל זמן נתון. המשמעות של האילוץ הזה היא שכל עוד המשתמש נמצא בשיחה פעילה באפליקציה FooTalk, האפליקציה BarTalk לא יכולה להתחיל או לקבל שיחה חדשה.

    במכשירים שפועלים ברמת API‏ 28 ומעלה, אם גם FooTalk וגם BarTalk מצהירות על ההרשאות CAPABILITY_SUPPORT_HOLD ו-CAPABILITY_HOLD, המשתמש יכול לנהל יותר משיחה אחת בו-זמנית על ידי מעבר בין האפליקציות כדי להתחיל שיחה אחרת או לענות לה.

  • אם המשתמש נמצא בשיחות מנוהלות רגילות (לדוגמה, באמצעות אפליקציית הטלפון או החייגן המובנית), הוא לא יכול להיות בשיחות שמקורן באפליקציות שיחות. כלומר, אם המשתמש נמצא בשיחה רגילה דרך ספק הסלולר, הוא לא יכול להיות בו-זמנית בשיחה ב-FooTalk או ב-BarTalk.

  • תת-המערכת של הטלקום מנתקת את השיחות של האפליקציה אם המשתמש מחייג שיחת חירום.

  • האפליקציה לא יכולה לקבל או להוציא שיחות בזמן שהמשתמש נמצא בשיחת חירום.

  • אם יש שיחה פעילה באפליקציית שיחות אחרת כשהאפליקציה שלכם מקבלת שיחה נכנסת, מענה לשיחה הנכנסת מסיים את כל השיחות הפעילות באפליקציה האחרת. האפליקציה שלכם לא אמורה להציג את ממשק המשתמש הרגיל של שיחה נכנסת. מסגרת הטלקום מציגה את ממשק המשתמש של השיחה הנכנסת ומודיעה למשתמש שמענה לשיחה החדשה יסיים את השיחות הפעילות. כלומר, אם המשתמש נמצא בשיחה ב-FooTalk ואפליקציית BarTalk מקבלת שיחה נכנסת, מסגרת הטלקום מודיעה למשתמש שיש לו שיחה נכנסת חדשה ב-BarTalk, ושאם הוא יענה לשיחה ב-BarTalk, השיחה ב-FooTalk תסתיים.

הגדרת אפליקציית "טלפון" כברירת המחדל

אפליקציית החייגן/אפליקציית "טלפון" שמוגדרת כברירת מחדל היא זו שמספקת את ממשק המשתמש של השיחה בזמן שהמכשיר נמצא בשיחה. היא גם מאפשרת למשתמשים להתחיל שיחות ולראות את היסטוריית השיחות במכשיר שלהם. המכשיר מגיע עם אפליקציית חייגן/טלפון שמוגדרת כברירת מחדל במערכת. המשתמש יכול לבחור אפליקציה אחת שתחליף את אפליקציית המערכת בתפקיד הזה. אפליקציה שרוצה למלא את התפקיד הזה משתמשת ב-RoleManager כדי לבקש למלא את התפקיד RoleManager.ROLE_DIALER.

אפליקציית הטלפון שמוגדרת כברירת מחדל מספקת ממשק משתמש כשהמכשיר נמצא בשיחה, והמכשיר לא נמצא במצב רכב (כלומר, UiModeManager#getCurrentModeType() הוא לא Configuration.UI_MODE_TYPE_CAR).

כדי למלא את התפקיד RoleManager.ROLE_DIALER, האפליקציה צריכה לעמוד בכמה דרישות:

  • היא צריכה לטפל ב-Intent של Intent#ACTION_DIAL. כלומר, האפליקציה צריכה לספק ממשק משתמש של לוח חיוג כדי שהמשתמש יוכל לבצע שיחות יוצאות.
  • היא צריכה להטמיע באופן מלא את ה-API של InCallService ולספק ממשק משתמש לשיחות נכנסות וממשק משתמש לשיחות פעילות.

החייגן שנטען מראש תמיד ישמש את המשתמש לביצוע שיחת חירום, גם אם האפליקציה שלך ממלאת את התפקיד RoleManager.ROLE_DIALER. כדי להבטיח חוויית שימוש אופטימלית כשמבצעים שיחת חירום, חייגן ברירת המחדל צריך תמיד להשתמש ב-TelecomManager.placeCall(Uri, Bundle) כדי לבצע שיחות (כולל שיחות חירום). כך הפלטפורמה יכולה לוודא שהבקשה הגיעה מהחייגן שמוגדר כברירת מחדל. אם אפליקציית חייגן שלא נטענה מראש משתמשת ב-Intent#ACTION_CALL כדי לבצע שיחת חירום, היא תועבר לאפליקציית החייגן שנטענה מראש באמצעות Intent#ACTION_DIAL לצורך אישור. זו חוויית משתמש לא אופטימלית.

בהמשך מופיעה דוגמה לרישום מניפסט של InCallService. המטא-נתונים TelecomManager#METADATA_IN_CALL_SERVICE_UI מציינים שההטמעה הספציפית הזו של InCallService נועדה להחליף את ממשק המשתמש המובנה בשיחה. המטא-נתונים TelecomManager#METADATA_IN_CALL_SERVICE_RINGING מציינים שה-InCallService הזה ישמיע את הרינגטון לשיחות נכנסות. בהמשך מוסבר איך להציג את ממשק המשתמש של השיחה הנכנסת ולהשמיע את הרינגטון באפליקציה.

 <service android:name="your.package.YourInCallServiceImplementation"
          android:permission="android.permission.BIND_INCALL_SERVICE"
          android:exported="true">
      <meta-data android:name="android.telecom.IN_CALL_SERVICE_UI" android:value="true" />
      <meta-data android:name="android.telecom.IN_CALL_SERVICE_RINGING"
          android:value="true" />
      <intent-filter>
          <action android:name="android.telecom.InCallService"/>
      </intent-filter>
 </service>

הערה: אין לסמן את InCallService במאפיין android:exported="false". אם תעשו זאת, יכול להיות שהמערכת לא תצליח לקשר להטמעה שלכם במהלך שיחות.

בנוסף להטמעת ה-API של InCallService, צריך גם להצהיר על פעילות במניפסט שמטפלת ב-Intent של Intent#ACTION_DIAL. הדוגמה הבאה ממחישה איך עושים את זה:

 <activity android:name="your.package.YourDialerActivity"
           android:label="@string/yourDialerActivityLabel">
      <intent-filter>
           <action android:name="android.intent.action.DIAL" />
           <category android:name="android.intent.category.DEFAULT" />
      </intent-filter>
      <intent-filter>
           <action android:name="android.intent.action.DIAL" />
           <category android:name="android.intent.category.DEFAULT" />
           <data android:scheme="tel" />
      </intent-filter>
 </activity>

כשמשתמש מתקין את האפליקציה ומפעיל אותה בפעם הראשונה, צריך להשתמש ב-RoleManager כדי להציג למשתמש בקשה להגדיר את האפליקציה כאפליקציית "טלפון" החדשה כברירת מחדל.

הקוד הבא מראה איך האפליקציה יכולה לבקש להפוך לאפליקציית הטלפון או החייגן שמוגדרת כברירת מחדל:

 private static final int REQUEST_ID = 1;

 public void requestRole() {
     RoleManager roleManager = (RoleManager) getSystemService(ROLE_SERVICE);
     Intent intent = roleManager.createRequestRoleIntent(RoleManager.ROLE_DIALER);
     startActivityForResult(intent, REQUEST_ID);
 }

 public void onActivityResult(int requestCode, int resultCode, Intent data) {
     if (requestCode == REQUEST_ID) {
         if (resultCode == android.app.Activity.RESULT_OK) {
             // Your app is now the default dialer app
         } else {
             // Your app is not the default dialer app
         }
     }
 }

גישה ל-InCallService במכשירים לבישים

אם האפליקציה שלכם היא אפליקציה נלווית של צד שלישי והיא צריכה לגשת לממשקי ה-API של InCallService, אתם יכולים:

  1. הצהרה על ההרשאה MANAGE_ONGOING_CALLS במניפסט
  2. לשייך למכשיר לביש פיזי באמצעות ה-API של CompanionDeviceManager כאפליקציה נלווית. מידע נוסף זמין במאמר התאמת מכשירים נלווים.
  3. צריך להטמיע את InCallService עם הרשאת BIND_INCALL_SERVICE

הצגת ההתראה על שיחה נכנסת

כשהאפליקציה מקבלת שיחה נכנסת חדשה דרך InCallService#onCallAdded(Call), היא אחראית להציג ממשק משתמש לשיחה הנכנסת. כדי לעשות את זה, האפליקציה צריכה להשתמש בממשקי ה-API של NotificationManager כדי לפרסם התראה חדשה על שיחה נכנסת.

אם האפליקציה מצהירה על המטא-נתונים TelecomManager#METADATA_IN_CALL_SERVICE_RINGING, היא אחראית להשמעת הרינגטון לשיחות נכנסות. האפליקציה צריכה ליצור NotificationChannel שמציין את הרינגטון הרצוי. לדוגמה:

 NotificationChannel channel = new NotificationChannel(YOUR_CHANNEL_ID, "Incoming Calls",
          NotificationManager.IMPORTANCE_MAX);
 // other channel setup stuff goes here.

 // We'll use the default system ringtone for our incoming call notification channel.  You can
 // use your own audio resource here.
 Uri ringtoneUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE);
 channel.setSound(ringtoneUri, new AudioAttributes.Builder()
          // Setting the AudioAttributes is important as it identifies the purpose of your
          // notification sound.
          .setUsage(AudioAttributes.USAGE_NOTIFICATION_RINGTONE)
          .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
      .build());

 NotificationManager mgr = getSystemService(NotificationManager.class);
 mgr.createNotificationChannel(channel);

כשהאפליקציה מקבלת שיחה נכנסת חדשה, היא יוצרת Notification לשיחה הנכנסת ומשייכת אותה לערוץ התראות על שיחות נכנסות. אתם יכולים לציין PendingIntent בהתראה, שתפעיל את ממשק המשתמש של השיחה הנכנסת במסך מלא. אם המשתמש משתמש בטלפון באופן פעיל, מסגרת ה-NotificationManager תציג את ההתראה כהתראת "שימו לב". כשהמשתמש לא משתמש בטלפון, מוצג ממשק המשתמש של השיחה הנכנסת במסך מלא. לדוגמה:

 // Create an intent which triggers your fullscreen incoming call user interface.
 Intent intent = new Intent(Intent.ACTION_MAIN, null);
 intent.setFlags(Intent.FLAG_ACTIVITY_NO_USER_ACTION | Intent.FLAG_ACTIVITY_NEW_TASK);
 intent.setClass(context, YourIncomingCallActivity.class);
 PendingIntent pendingIntent = PendingIntent.getActivity(context, 1, intent, PendingIntent.FLAG_MUTABLE_UNAUDITED);
 // Build the notification as an ongoing high priority item; this ensures it will show as
 // a heads up notification which slides down over top of the current content.
 final Notification.Builder builder = new Notification.Builder(context);
 builder.setOngoing(true);
 builder.setPriority(Notification.PRIORITY_HIGH);
 // Set notification content intent to take user to the fullscreen UI if user taps on the
 // notification body.
 builder.setContentIntent(pendingIntent);
 // Set full screen intent to trigger display of the fullscreen UI when the notification
 // manager deems it appropriate.
 builder.setFullScreenIntent(pendingIntent, true);
 // Setup notification content.
 builder.setSmallIcon( yourIconResourceId );
 builder.setContentTitle("Your notification title");
 builder.setContentText("Your notification content.");
 // Use builder.addAction(..) to add buttons to answer or reject the call.
 NotificationManager notificationManager = mContext.getSystemService(
     NotificationManager.class);
 notificationManager.notify(YOUR_CHANNEL_ID, YOUR_TAG, YOUR_ID, builder.build());
```