עסקאות מקטעים

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

אפשר לשמור כל עסקה במקבץ אחורי שמנוהל על ידי FragmentManager, כך שהמשתמש יוכל לנווט אחורה שינויים במקטעים - בדומה לניווט אחורה בפעילויות.

אפשר לקבל מופע של FragmentTransaction מה-FragmentManager באמצעות קריאה ל-beginTransaction(), כמו בדוגמה הבאה:

Kotlin

val fragmentManager = ...
val fragmentTransaction = fragmentManager.beginTransaction()

Java

FragmentManager fragmentManager = ...
FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();

השיחה הסופית בכל FragmentTransaction חייבת לבצע את העסקה. הקריאה commit() מסמנת ל-FragmentManager שכל הפעולות נוספו לעסקה.

Kotlin

val fragmentManager = ...
// The fragment-ktx module provides a commit block that automatically
// calls beginTransaction and commit for you.
fragmentManager.commit {
    // Add operations here
}

Java

FragmentManager fragmentManager = ...
FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();

// Add operations here

fragmentTransaction.commit();

אפשר סידור מחדש של שינויים במצב המקטע

בכל FragmentTransaction צריך להשתמש ב-setReorderingAllowed(true):

Kotlin

supportFragmentManager.commit {
    ...
    setReorderingAllowed(true)
}

Java

FragmentManager fragmentManager = ...
fragmentManager.beginTransaction()
    ...
    .setReorderingAllowed(true)
    .commit();

עבור תאימות התנהגות, הדגל של סידור מחדש לא מופעל כברירת מחדל. עם זאת, נדרש כדי לאפשר ל-FragmentManager לפעול כראוי FragmentTransaction, במיוחד כאשר הוא פועל על המקבץ האחורי ולהפעיל אנימציות ומעברים. הפעלת הדגל מבטיחה עסקאות מרובות מתבצעות יחד, כל קטעי הביניים (כלומר, אלה שנוספים ולאחר מכן מוחלפים מיד) לא עוברים שינויים במחזור החיים או הפעלה של האנימציות או המעברים שלהן. שימו לב הדגל הזה משפיע גם על הביצוע הראשוני של העסקה וגם על הביטול העסקה עם popBackStack().

הוספה והסרה של מקטעים

כדי להוסיף מקטע אל FragmentManager, יש להפעיל את הפונקציה add() על העסקה. השיטה הזו מקבלת מזהה המאגר של המקטע, וגם שם המחלקה של המקטע של המקטע שרוצים להוסיף. המקטע שנוסף מועבר אל RESUMED . מומלץ מאוד שמאגר התגים יהיה FragmentContainerView שהיא חלק מהיררכיית התצוגות.

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

כדאי להשתמש replace() כדי להחליף שבר קיים בקונטיינר במופע של מחלקה חדשה שתספקו. חיוג אל replace() מקביל ל: קריאה ל-remove() עם שבר בקונטיינר והוספת קובץ חדש מקטע לאותו מאגר.

קטע הקוד הבא מראה איך להחליף מקטע אחד במקטע אחר:

Kotlin

// Create new fragment
val fragmentManager = // ...

// Create and commit a new transaction
fragmentManager.commit {
    setReorderingAllowed(true)
    // Replace whatever is in the fragment_container view with this fragment
    replace<ExampleFragment>(R.id.fragment_container)
}

Java

// Create new fragment and transaction
FragmentManager fragmentManager = ...
FragmentTransaction transaction = fragmentManager.beginTransaction();
transaction.setReorderingAllowed(true);

// Replace whatever is in the fragment_container view with this fragment
transaction.replace(R.id.fragment_container, ExampleFragment.class, null);

// Commit the transaction
transaction.commit();

בדוגמה הזו, מופע חדש של ExampleFragment מחליף את המקטע, אם קיים, שנמצא כרגע במאגר הפריסה שזוהה על ידי R.id.fragment_container.

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

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

הפונקציה Commit היא אסינכרונית

ביצוע שיחה commit() לא מבצע את העסקה באופן מיידי. במקום זאת, העסקה תוזמן לפעול בשרשור הראשי של ממשק המשתמש ברגע שהוא יוכל לעשות זאת. אם המיקום עם זאת, אתם יכולים לקרוא commitNow() כדי להריץ באופן מיידי את טרנזקציית המקטעים ב-thread של ממשק המשתמש.

הערה: commitNow לא תואם ל-addToBackStack. לחלופין, אפשר להוציא לפועל את כל FragmentTransactions הממתינים שנשלחו על ידי commit() שיחות שעדיין לא הופעלו על ידי חיוג אל executePendingTransactions(). הגישה הזו תואמת למדיניות addToBackStack.

לרוב המכריע של התרחישים לדוגמה, commit() הוא כל מה שצריך.

סדר הפעולות חשוב

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

Kotlin

supportFragmentManager.commit {
    setCustomAnimations(enter1, exit1, popEnter1, popExit1)
    add<ExampleFragment>(R.id.container) // gets the first animations
    setCustomAnimations(enter2, exit2, popEnter2, popExit2)
    add<ExampleFragment>(R.id.container) // gets the second animations
}

Java

getSupportFragmentManager().beginTransaction()
        .setCustomAnimations(enter1, exit1, popEnter1, popExit1)
        .add(R.id.container, ExampleFragment.class, null) // gets the first animations
        .setCustomAnimations(enter2, exit2, popEnter2, popExit2)
        .add(R.id.container, ExampleFragment.class, null) // gets the second animations
        .commit()

הגבלת מחזור החיים של המקטע

FragmentTransactions יכול להשפיע על מצב מחזור החיים של אנשים קטעים שנוספו במסגרת העסקה. כשיוצרים FragmentTransaction, setMaxLifecycle() מגדיר מצב מקסימלי עבור המקטע הנתון. לדוגמה, ViewPager2 משתמש/ת setMaxLifecycle() כדי להגביל את המקטעים שלא מופיעים במסך למצב STARTED.

הצגה והסתרה של תצוגות המקטע

שימוש ב-methods FragmentTransaction show() וגם hide() כדי להציג ולהסתיר את התצוגה של מקטעים שנוספו לקונטיינר. השיטות האלה מגדירות את החשיפה של תצוגות המקטע בלי להשפיע על את מחזור החיים של הקטע.

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

חיבור וניתוק של מקטעים

השיטה FragmentTransaction detach() מנתק את המקטע מממשק המשתמש ומוחק את היררכיית התצוגות שלו. המקטע נשאר באותו מצב (STOPPED) כמו כשמציבים אותו במקבץ האחורי. המשמעות היא שהמקטע הוסר מממשק המשתמש אבל עדיין מנוהל על ידי את מנהל המקטעים.

attach() מצרף מחדש מקטע שממנו הוא נותק קודם. פעולה זו גורמת ליצירת מחדש של היררכיית התצוגות שלה, המצורפת לממשק המשתמש, ומוצגת.

כ-FragmentTransaction מתייחסים למערך אטומי יחיד של פעולות, קריאות ל-detach וגם ל-attach באותו מופע המקטע של שאותה עסקה תבטל אחת את השנייה, וכך נמנעת השמדה ושחזור מיידי של ממשק המשתמש של הקטע. שימוש נפרד עסקאות, מופרדות באמצעות executePendingOperations() אם משתמשים ב-commit(), אם רוצים לנתק את המקטע ואז לחבר אותו מחדש.

הערה: השיטות attach() ו-detach() לא קשורות ל-Fragment שיטות של onAttach() וגם onDetach(). מידע נוסף על Fragment השיטות האלה זמין בכתובת מחזור החיים של מקטע.