שימוש בתכונה "תמונה בתוך תמונה" (PiP)

כדאי לנסות את הכתיבה
‫Jetpack פיתוח נייטיב היא ערכת הכלים המומלצת לבניית ממשק משתמש ב-Android. איך מוסיפים תמיכה בתמונה בתוך תמונה בכלי הכתיבה
תמונה בתוך תמונה ←

החל מ-Android 8.0 (רמת API‏ 26), מערכת Android מאפשרת להפעיל פעילויות במצב 'תמונה בתוך תמונה' (PiP). תמונה בתוך תמונה היא סוג מיוחד של מצב ריבוי חלונות שמשמש להפעלת סרטונים, לשיחות וידאו ולניווט. התכונה מאפשרת למשתמש להצמיד את חלון הפעילות הקיים לפינת המסך בזמן שהוא עובר בין אפליקציות או מעיין בתוכן במסך הראשי.

התכונה 'תמונה בתוך תמונה' מסתמכת על ממשקי API של ריבוי חלונות שזמינים ב-Android 7.0 כדי לספק את חלון הווידאו הצף. כדי להוסיף PiP לאפליקציה, צריך לרשום את הפעילויות שתומכות ב-PiP, להעביר את הפעילות למצב PiP לפי הצורך ולוודא שרכיבי ממשק המשתמש מוסתרים והפעלת הסרטון נמשכת כשהפעילות במצב PiP.

חלון ה-PiP מופיע בשכבה העליונה ביותר של המסך, בפינה שנבחרה על ידי המערכת.

התכונה 'תמונה בתוך תמונה' נתמכת גם במכשירי Android TV OS תואמים עם Android 14 (רמת API 34) ואילך. יש הרבה דברים דומים, אבל יש גם שיקולים נוספים כשמשתמשים בתמונה בתוך תמונה בטלוויזיה.

איך משתמשים יכולים לבצע אינטראקציה עם חלון ה-PiP

המשתמשים יכולים לגרור את חלון ה-PiP למיקום אחר. החל מ-Android 12, משתמשים יכולים גם:

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

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

  • גוררים את החלון לקצה השמאלי או הימני כדי להסתיר אותו. כדי להוציא את החלון מהאחסון, מקישים על החלק הגלוי של החלון המאוחסן או גוררים אותו החוצה.

  • כדי לשנות את הגודל של חלון התמונה בתוך התמונה, עושים תנועת צביטה בזום.

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

  • פעילות יכולה לעבור למצב תמונה בתוך תמונה כשהמשתמש מקיש על הלחצן הראשי או מחליק למעלה אל המסך הראשי. כך מפות Google ממשיכה להציג את ההוראות בזמן שהמשתמש מבצע פעילות אחרת.

  • האפליקציה יכולה להעביר סרטון למצב PiP כשהמשתמש חוזר מהסרטון כדי לעיין בתוכן אחר.

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

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

הצהרה על תמיכה בתמונה בתוך תמונה

כברירת מחדל, המערכת לא תומכת אוטומטית בהפעלת אפליקציות במצב תמונה בתוך תמונה. אם רוצים להוסיף תמיכה ב-PiP לאפליקציה, צריך לרשום את פעילות הווידאו במניפסט על ידי הגדרת android:supportsPictureInPicture ל-true. בנוסף, צריך לציין שהפעילות מטפלת בשינויים בפריסת הרכיבים, כדי שהפעילות לא תופעל מחדש כשמתרחשים שינויים בפריסת הרכיבים במהלך מעברים למצב תמונה בתוך תמונה.

<activity android:name="VideoActivity"
    android:supportsPictureInPicture="true"
    android:configChanges=
        "screenSize|smallestScreenSize|screenLayout|orientation"
    ...

הטמעה של תמונה בתוך תמונה באמצעות Jetpack

כדי להטמיע את התכונה 'תמונה בתוך תמונה' (PiP), מומלץ להשתמש בספריית Jetpack Picture-in-Picture. כך אפשר לייעל את ההטמעה ולצמצם בעיות נפוצות באפליקציה. אפשר לעיין באפליקציה לדוגמה של הפלטפורמה כדי לראות דוגמה לשימוש בה. אבל אם אתם מעדיפים להטמיע את התכונה 'תמונה בתוך תמונה' באמצעות ממשקי API של הפלטפורמה, תוכלו לעיין במאמרי העזרה הבאים.

העברת הפעילות למצב תמונה בתוך תמונה

החל מ-Android 12, אפשר להעביר את הפעילות למצב תמונה בתוך תמונה על ידי הגדרת הדגל setAutoEnterEnabled לערך true. ההגדרה הזו מאפשרת למערכת לעבור אוטומטית למצב תמונה בתוך תמונה לפי הצורך, בלי שתצטרכו להפעיל במפורש את enterPictureInPictureMode() ב-onUserLeaveHint. בנוסף, המעבר בין שיטות הבידינג יהיה חלק יותר. פרטים נוספים זמינים במאמר בנושא שיפור המעברים למצב תמונה בתוך תמונה מניווט באמצעות מחוות.

אם אתם מטרגטים את Android 11 או גרסאות קודמות, פעילות צריכה לקרוא ל-enterPictureInPictureMode() כדי לעבור למצב תמונה בתוך תמונה. לדוגמה, הקוד הבא מעביר פעילות למצב תמונה בתוך תמונה כשמשתמש לוחץ על לחצן ייעודי בממשק המשתמש של האפליקציה:

Kotlin

override fun onActionClicked(action: Action) {
    if (action.id.toInt() == R.id.lb_control_picture_in_picture) {
        activity?.enterPictureInPictureMode()
        return
    }
}

Java

@Override
public void onActionClicked(Action action) {
    if (action.getId() == R.id.lb_control_picture_in_picture) {
        getActivity().enterPictureInPictureMode();
        return;
    }
    ...
}

אולי תרצו לכלול לוגיקה שמעבירה פעילות למצב תמונה בתוך תמונה במקום להעביר אותה לרקע. לדוגמה, אפליקציית מפות Google עוברת למצב PiP אם המשתמש לוחץ על לחצן הבית או על לחצן האפליקציות האחרונות בזמן שהאפליקציה מנווטת. אפשר לטפל במקרה הזה על ידי שינוי ההגדרה של onUserLeaveHint():

Kotlin

override fun onUserLeaveHint() {
    if (iWantToBeInPipModeNow()) {
        enterPictureInPictureMode()
    }
}

Java

@Override
public void onUserLeaveHint () {
    if (iWantToBeInPipModeNow()) {
        enterPictureInPictureMode();
    }
}

מומלץ: לספק למשתמשים חוויית מעבר חלקה בין מצב רגיל למצב תמונה בתוך תמונה

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

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

השינויים האלה כוללים:

  • שיפור המעבר למצב תמונה בתוך תמונה (PiP) מניווט באמצעות תנועות
  • הגדרת sourceRectHint מתאים לכניסה למצב תמונה בתוך תמונה ויציאה ממנו
  • השבתת שינוי הגודל בצורה חלקה לתוכן שאינו וידאו

כדאי לעיין בדוגמה של Android Kotlin PictureInPicture כדי לקבל מידע על הפעלת חוויית מעבר חלקה.

שיפור המעבר למצב תמונה בתוך תמונה (PiP) מניווט באמצעות תנועות

החל מ-Android 12, הדגל setAutoEnterEnabled מספק אנימציה חלקה יותר למעבר לתוכן וידאו במצב 'תמונה בתוך תמונה' באמצעות ניווט במחוות – למשל, כשמחליקים למעלה כדי לחזור למסך הבית ממצב מסך מלא.

כדי לבצע את השינוי הזה, צריך:

  1. משתמשים ב-setAutoEnterEnabled כדי ליצור את PictureInPictureParams.Builder:

    Kotlin

    setPictureInPictureParams(PictureInPictureParams.Builder()
    .setAspectRatio(aspectRatio)
    .setSourceRectHint(sourceRectHint)
    .setAutoEnterEnabled(true)
    .build())

    Java

    setPictureInPictureParams(new PictureInPictureParams.Builder()
    .setAspectRatio(aspectRatio)
    .setSourceRectHint(sourceRectHint)
    .setAutoEnterEnabled(true)
    .build());

  2. כדאי להתקשר למספר setPictureInPictureParams עם הגרסה העדכנית של PictureInPictureParams מוקדם. האפליקציה לא מחכה לקריאה החוזרת onUserLeaveHint (כמו שהיא הייתה עושה ב-Android 11).

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

  3. תתקשר אל setAutoEnterEnabled(false), אבל רק אם זה הכרחי. לדוגמה, כנראה שלא תרצו להיכנס למצב תמונה בתוך תמונה אם ההפעלה הנוכחית מושהית.

הגדרת sourceRectHint מתאים לכניסה למצב תמונה בתוך תמונה ויציאה ממנו

החל מההשקה של מצב 'תמונה בתוך תמונה' ב-Android 8.0, ‏ setSourceRectHint מציין את האזור של הפעילות שגלוי אחרי המעבר למצב 'תמונה בתוך תמונה' – לדוגמה, גבולות התצוגה של הסרטון בנגן וידאו.

ב-Android 12, המערכת משתמשת ב-sourceRectHint כדי להטמיע אנימציה חלקה יותר כשנכנסים למצב PiP ויוצאים ממנו.

כדי להגדיר את sourceRectHint בצורה נכונה לכניסה למצב תמונה בתוך תמונה ויציאה ממנו:

  1. בניית PictureInPictureParams באמצעות הגבולות המתאימים כ-sourceRectHint. מומלץ גם לצרף מאזין לשינוי פריסה לנגן הווידאו:

    Kotlin

    val mOnLayoutChangeListener =
OnLayoutChangeListener { v: View?, oldLeft: Int,
        oldTop: Int, oldRight: Int, oldBottom: Int, newLeft: Int, newTop:
        Int, newRight: Int, newBottom: Int ->
    val sourceRectHint = Rect()
    mYourVideoView.getGlobalVisibleRect(sourceRectHint)
    val builder = PictureInPictureParams.Builder()
        .setSourceRectHint(sourceRectHint)
    setPictureInPictureParams(builder.build())
}

mYourVideoView.addOnLayoutChangeListener(mOnLayoutChangeListener)

    Java

    private final View.OnLayoutChangeListener mOnLayoutChangeListener =
        (v, oldLeft, oldTop, oldRight, oldBottom, newLeft, newTop, newRight,
        newBottom) -> {
    final Rect sourceRectHint = new Rect();
    mYourVideoView.getGlobalVisibleRect(sourceRectHint);
    final PictureInPictureParams.Builder builder =
        new PictureInPictureParams.Builder()
            .setSourceRectHint(sourceRectHint);
    setPictureInPictureParams(builder.build());
};

mYourVideoView.addOnLayoutChangeListener(mOnLayoutChangeListener);

  2. אם צריך, מעדכנים את sourceRectHint לפני שהמערכת מתחילה את המעבר ליציאה. כשהמערכת עומדת לצאת ממצב תמונה בתוך תמונה, היררכיית התצוגה של הפעילות מסודרת לפי הגדרת היעד שלה (לדוגמה, מסך מלא). האפליקציה יכולה לצרף listener לשינוי פריסה לתצוגת הבסיס או לתצוגת היעד (כמו תצוגת נגן הווידאו) כדי לזהות את האירוע ולעדכן את sourceRectHint לפני תחילת האנימציה.

    Kotlin

    // Listener is called immediately after the user exits PiP but before animating.
playerView.addOnLayoutChangeListener { _, left, top, right, bottom,
                    oldLeft, oldTop, oldRight, oldBottom ->
    if (left != oldLeft
        || right != oldRight
        || top != oldTop
        || bottom != oldBottom) {
        // The playerView's bounds changed, update the source hint rect to
        // reflect its new bounds.
        val sourceRectHint = Rect()
        playerView.getGlobalVisibleRect(sourceRectHint)
        setPictureInPictureParams(
            PictureInPictureParams.Builder()
                .setSourceRectHint(sourceRectHint)
                .build()
        )
    }
}

    Java

    // Listener is called right after the user exits PiP but before animating.
playerView.addOnLayoutChangeListener((v, left, top, right, bottom,
                    oldLeft, oldTop, oldRight, oldBottom) -> {
    if (left != oldLeft
        || right != oldRight
        || top != oldTop
        || bottom != oldBottom) {
        // The playerView's bounds changed, update the source hint rect to
        // reflect its new bounds.
        final Rect sourceRectHint = new Rect();
        playerView.getGlobalVisibleRect(sourceRectHint);
        setPictureInPictureParams(
            new PictureInPictureParams.Builder()
                .setSourceRectHint(sourceRectHint)
                .build());
    }
});

השבתת שינוי הגודל של תוכן שאינו וידאו

ב-Android 12 נוסף הדגל setSeamlessResizeEnabled, שמאפשר אנימציית מעבר חלקה יותר כשמשנים את הגודל של תוכן שאינו וידאו בחלון PiP. בעבר, שינוי הגודל של תוכן שאינו וידאו בחלון של 'תמונה בתוך תמונה' עלול היה ליצור ארטיפקטים חזותיים בולטים.

כדי להפעיל שינוי גודל חלק של תוכן וידאו:

Kotlin

setPictureInPictureParams(PictureInPictureParams.Builder()
    .setSeamlessResizeEnabled(true)
    .build())

Java

setPictureInPictureParams(new PictureInPictureParams.Builder()
    .setSeamlessResizeEnabled(true)
    .build());

הצגת ממשק המשתמש במהלך הפעלת תמונה בתוך תמונה

כשהפעילות נכנסת למצב תמונה בתוך תמונה (PiP) או יוצאת ממנו, המערכת קוראת ל-Activity.onPictureInPictureModeChanged() או ל-Fragment.onPictureInPictureModeChanged().

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

מפתחים משתמשים בקריאה החוזרת onPictureInPictureModeChanged() כדי להגדיר לוגיקה שמשנה את מצב החשיפה של רכיבי ממשק המשתמש שמוצגים בשכבת-על. הקריאה החוזרת הזו מופעלת כשהאנימציה של הכניסה למצב תמונה בתוך תמונה או היציאה ממנו מסתיימת. החל מ-Android 15, המחלקה PictureInPictureUiState כוללת מצב חדש.

במצב החדש של ממשק המשתמש, אפליקציות שמטרגטות ל-Android 15 מקבלות את הקריאה החוזרת Activity#onPictureInPictureUiStateChanged() עם הערך isTransitioningToPip() ברגע שאנימציית ה-PiP מתחילה. יש הרבה רכיבי ממשק משתמש שלא רלוונטיים לאפליקציה כשהיא במצב תמונה בתוך תמונה. לדוגמה, תצוגות או פריסות שכוללות מידע כמו הצעות, סרטון שיגיע בקרוב, דירוגים ושמות. כשהאפליקציה עוברת למצב תמונה בתוך תמונה, משתמשים בקריאה החוזרת onPictureInPictureUiStateChanged() כדי להסתיר את רכיבי ממשק המשתמש האלה. כשהאפליקציה עוברת ממצב חלון צף למצב מסך מלא, צריך להשתמש בקריאה החוזרת (callback) onPictureInPictureModeChanged() כדי להציג את הרכיבים האלה, כמו שמוצג בדוגמאות הבאות:

Kotlin

override fun onPictureInPictureUiStateChanged(pipState: PictureInPictureUiState) {
        if (pipState.isTransitioningToPip()) {
          // Hide UI elements.
        }
    }

Java

@Override
public void onPictureInPictureUiStateChanged(PictureInPictureUiState pipState) {
        if (pipState.isTransitioningToPip()) {
          // Hide UI elements.
        }
    }

Kotlin

override fun onPictureInPictureModeChanged(isInPictureInPictureMode: Boolean) {
        if (isInPictureInPictureMode) {
          // Unhide UI elements.
        }
    }

Java

@Override
public void onPictureInPictureModeChanged(boolean isInPictureInPictureMode) {
        if (isInPictureInPictureMode) {
          // Unhide UI elements.
        }
    }

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

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

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

הוספת פקדים

כשמשתמש פותח את התפריט של חלון ה-PiP (בהקשה על החלון במכשיר נייד או בבחירת התפריט בשלט של הטלוויזיה), יכולים להופיע בו אמצעי בקרה.

אם לאפליקציה יש סשן מדיה פעיל, יופיעו אמצעי הבקרה להפעלה, להשהיה, להפעלה של הפריט הבא ולהפעלה של הפריט הקודם.

אפשר גם לציין פעולות מותאמות אישית באופן מפורש על ידי יצירת PictureInPictureParams באמצעות PictureInPictureParams.Builder.setActions() לפני הכניסה למצב תמונה בתוך תמונה, ולהעביר את הפרמטרים כשנכנסים למצב תמונה בתוך תמונה באמצעות enterPictureInPictureMode(android.app.PictureInPictureParams) או setPictureInPictureParams(android.app.PictureInPictureParams). חשוב לפעול בזהירות. אם תנסו להוסיף יותר מ-getMaxNumPictureInPictureActions(), תקבלו רק את המספר המקסימלי.

המשך הפעלת הסרטון במצב תמונה בתוך תמונה

כשפעילות עוברת למצב תמונה בתוך תמונה, המערכת מעבירה את הפעילות למצב מושהה וקוראת לשיטה onPause() של הפעילות. ההפעלה של סרטון לא צריכה להיות מושהית, אלא להמשיך לפעול אם הפעילות מושהית בזמן המעבר למצב תמונה בתוך תמונה.

ב-Android 7.0 ואילך, צריך להשהות את הפעלת הסרטון ולהמשיך אותה כשמערכת קוראת לפעילות onStop() ו-onStart(). כך לא תצטרכו לבדוק אם האפליקציה שלכם במצב תמונה בתוך תמונה ב-onPause() ולהמשיך את ההפעלה באופן מפורש.

אם לא הגדרתם את הדגל setAutoEnterEnabled לערך true ואתם צריכים להשהות את ההפעלה בהטמעה של onPause(), אתם יכולים לבדוק אם מצב התמונה בתוך תמונה מופעל על ידי קריאה ל-isInPictureInPictureMode() ולטפל בהפעלה בהתאם. לדוגמה:

Kotlin

override fun onPause() {
    super.onPause()
    // If called while in PiP mode, do not pause playback.
    if (isInPictureInPictureMode) {
        // Continue playback.
    } else {
        // Use existing playback logic for paused activity behavior.
    }
}

Java

@Override
public void onPause() {
    // If called while in PiP mode, do not pause playback.
    if (isInPictureInPictureMode()) {
        // Continue playback.
        ...
    } else {
        // Use existing playback logic for paused activity behavior.
        ...
    }
}

כשהפעילות יוצאת ממצב תמונה בתוך תמונה וחוזרת למצב מסך מלא, המערכת מפעילה מחדש את הפעילות וקוראת לשיטה onResume().

שימוש בפעילות הפעלה אחת לתמונה בתוך תמונה

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

כדי להבטיח שפעילות אחת תשמש לבקשות הפעלה של סרטונים ותעבור למצב PiP או תצא ממנו לפי הצורך, צריך להגדיר את android:launchMode של הפעילות ל-singleTask במניפסט:

<activity android:name="VideoActivity"
    ...
    android:supportsPictureInPicture="true"
    android:launchMode="singleTask"
    ...

בפעילות, מחליפים את הסרטון הקיים בחדש באמצעות הפונקציה onNewIntent() ומטפלים בסרטון החדש, ומפסיקים את ההפעלה של הסרטון הקיים אם צריך.

שיטות מומלצות

יכול להיות שהתכונה 'תמונה בתוך תמונה' מושבתת במכשירים עם זיכרון RAM נמוך. לפני שהאפליקציה משתמשת ב-PiP, צריך לבדוק אם הוא זמין באמצעות הקריאה ל-hasSystemFeature(PackageManager.FEATURE_PICTURE_IN_PICTURE).

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

כשפעילות נמצאת במצב PiP, כברירת מחדל היא לא מקבלת פוקוס קלט. כדי לקבל אירועי קלט בזמן שמצב התמונה בתוך תמונה מופעל, משתמשים ב-MediaSession.setCallback(). מידע נוסף על השימוש ב-setCallback() זמין במאמר הצגת כרטיס 'מה מושמע עכשיו'.

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

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

קוד לדוגמה נוסף

כדי להוריד אפליקציה לדוגמה שנכתבה ב-Kotlin, אפשר לעיין במאמר Android PictureInPicture Sample (Kotlin).