אסטרטגיית ההעברה

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

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

שלבי ההעברה של אפליקציה מבוססת-צפייה לכתיבה
איור 1. שלבי ההעברה של אפליקציה מבוססת-צפייה לכתיבה

כדי להעביר את האפליקציה ל'כתיבה', צריך לבצע את השלבים הבאים:

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

בניית מסכים חדשים באמצעות 'כתיבה'

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

מסך חדש נכתב במצב 'כתיבה'
איור 2. מסך חדש כתוב ב'כתיבה'

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

כדי להשתמש ב'כתיבה' במקטע, מוחזר ComposeView שיטת מחזור החיים onCreateView() של ה-Fragment. ל-ComposeView יש השיטה setContent() שבה אפשר לספק פונקציה קומפוזבילית.

class NewFeatureFragment : Fragment() {
    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        return ComposeView(requireContext()).apply {
            setViewCompositionStrategy(ViewCompositionStrategy.DisposeOnViewTreeLifecycleDestroyed)
            setContent {
                NewFeatureScreen()
            }
        }
    }
}
MigrationStrategySnippets.kt

למידע נוסף, ראו ComposeView ב-Fragments.

הוספת תכונות חדשות במסכים קיימים

מסך קיים עם 'תצוגות' ו'כתיבה'
איור 3. מסך קיים עם 'תצוגות' ו'כתיבה'

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

לדוגמה, נניח שרוצים להוסיף תצוגת צאצא ל-LinearLayout. אפשר לעשות זאת ב-XML באופן הבא:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

  <TextView
      android:id="@+id/text"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content" />

  <androidx.compose.ui.platform.ComposeView
      android:id="@+id/compose_view"
      android:layout_width="match_parent"
      android:layout_height="match_parent" />
</LinearLayout>
migration_strategy_existing_screens.xml

אחרי שהתצוגה תנפח, אפשר יהיה להפנות יותר אל ComposeView ב- ההיררכיה וקריאה ל-setContent().

מידע נוסף על ComposeView זמין בממשקי API של יכולת פעולה הדדית.

יצירת ספרייה של רכיבים נפוצים בממשק המשתמש

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

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

החלפת התכונות הקיימות ב'כתיבה'

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

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

מסכים פשוטים

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

לוקחים את קובץ ה-XML הבא:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

  <TextView
      android:id="@+id/title_text"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:text="@string/title"
      android:textAppearance="?attr/textAppearanceHeadline2" />

  <TextView
      android:id="@+id/subtitle_text"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:text="@string/subtitle"
      android:textAppearance="?attr/textAppearanceHeadline6" />

  <TextView
      android:id="@+id/body_text"
      android:layout_width="wrap_content"
      android:layout_height="0dp"
      android:layout_weight="1"
      android:text="@string/body"
      android:textAppearance="?attr/textAppearanceBody1" />

  <Button
      android:id="@+id/confirm_button"
      android:layout_width="match_parent"
      android:layout_height="wrap_content"
      android:text="@string/confirm"/>
</LinearLayout>
migration_strategy_xml_example.xml

אפשר לשכתב את קובץ ה-XML באמצעות 'כתיבה' בכמה שורות:

@Composable
fun SimpleScreen() {
    Column(Modifier.fillMaxSize()) {
        Text(
            text = stringResource(R.string.title),
            style = MaterialTheme.typography.headlineMedium
        )
        Text(
            text = stringResource(R.string.subtitle),
            style = MaterialTheme.typography.headlineSmall
        )
        Text(
            text = stringResource(R.string.body),
            style = MaterialTheme.typography.bodyMedium
        )
        Spacer(modifier = Modifier.weight(1f))
        Button(onClick = { /* Handle click */ }, Modifier.fillMaxWidth()) {
            Text(text = stringResource(R.string.confirm))
        }
    }
}
MigrationStrategySnippets.kt

מסכי תצוגה משולבת ו'כתיבה'

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

גישה מלמטה למעלה – העברת תצוגות משולבות וממשק משתמש של כתיבה לכתיבה
איור 4. גישה מלמטה למעלה – העברת תצוגות משולבות וממשק משתמש של כתיבה לכתיבה

הסרת מקטעים ורכיב ניווט

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

מקורות מידע נוספים

כדאי לעיין במקורות המידע הנוספים הבאים כדי לקבל מידע נוסף על ההעברה אפליקציה קיימת מבוססת-תצוגה כדי לכתוב:

השלבים הבאים

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