הוספת סרטונים באמצעות 'תמונה בתוך תמונה' (PiP)

רוצה לנסות את שיטת הכתיבה?
Jetpack Compose היא ערכת הכלים המומלצת לבניית ממשק משתמש ב-Android. הסבר על התכונה 'תמונה בתוך תמונה' במצב 'כתיבה'.
תמונה בתוך תמונה →

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

KotlinJava
override fun onActionClicked(action: Action) {
    if (action.id.toInt() == R.id.lb_control_picture_in_picture) {
        activity?.enterPictureInPictureMode()
        return
    }
}
 
@Override
public void onActionClicked(Action action) {
    if (action.getId() == R.id.lb_control_picture_in_picture) {
        getActivity().enterPictureInPictureMode();
        return;
    }
    ...
}

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

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

מומלץ: לספק למשתמשים חוויית מעבר מטופחת ב'תמונה בתוך תמונה'

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

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

השינויים האלה כוללים את הדברים הבאים.

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

תוכלו להיעזר בדוגמה של Android PictureInPicture כדי ליצור חוויית מעבר מטופחת.

מעבר חלק יותר למצב PIP באמצעות ניווט באמצעות תנועות

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

מבצעים את השלבים הבאים כדי לבצע את השינוי ומעיינים בדוגמה הזו לקבלת מידע נוסף:

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

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

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

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

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

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

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

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

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

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

    KotlinJava
    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)
     
    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 לפני שהמערכת מתחילה את המעבר ליציאה. כשהמערכת עומדת לצאת ממצב PiP, היררכיית התצוגה של הפעילות מסודרת בהתאם להגדרות היעד שלה (לדוגמה, מסך מלא). האפליקציה יכולה לצרף מאזין לשינוי פריסה לתצוגת הבסיס או לתצוגת היעד שלה (למשל תצוגת נגן הווידאו) כדי לזהות את האירוע ולעדכן את sourceRectHint לפני שהאנימציה מתחילה.

    KotlinJava
    // 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()
        )
    }
}
     
    // 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, שמספק אנימציה חלקה יותר במעבר בין השקפים כשמשנים את הגודל של תוכן שאינו וידאו בחלון 'תמונה בתוך תמונה'. בעבר, שינוי הגודל של תוכן שאינו וידאו בחלון של 'תמונה בתוך תמונה' יכול היה ליצור פגמים חזותיים מטרידים.

כדי להשבית את התכונה 'שינוי גודל חלק' בתוכן שאינו וידאו:

KotlinJava
setPictureInPictureParams(PictureInPictureParams.Builder()
    .setSeamlessResizeEnabled(false)
    .build())
 
setPictureInPictureParams(new PictureInPictureParams.Builder()
    .setSeamlessResizeEnabled(false)
    .build());

טיפול בממשק המשתמש במהלך 'תמונה בתוך תמונה'

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

ב-Android 15 יש שינויים שמבטיחים מעבר חלק יותר כשנכנסים למצב PIP. האפשרות הזו שימושית לאפליקציות עם רכיבי ממשק משתמש בשכבת-על מעל ממשק המשתמש הראשי, שעובר אל 'תמונה בתוך תמונה'.

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

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

KotlinJava
override fun onPictureInPictureUiStateChanged(pipState: PictureInPictureUiState) {
        if (pipState.isTransitioningToPip()) {
          // Hide UI elements.
        }
    }
 
@Override
public void onPictureInPictureUiStateChanged(PictureInPictureUiState pipState) {
        if (pipState.isTransitioningToPip()) {
          // Hide UI elements.
        }
    }
KotlinJava
override fun onPictureInPictureModeChanged(isInPictureInPictureMode: Boolean) {
        if (isInPictureInPictureMode) {
          // Unhide UI elements.
        }
    }
 
@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(), תקבלו רק את המספר המקסימלי.

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

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

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

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

KotlinJava
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.
    }
}
 
@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.
        ...
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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