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

אפשר להריץ את כל משימות ה-build שזמינות לפרויקט Android באמצעות כלי שורת הפקודה Gradle wrapper. הוא זמין כקובץ באצווה ל-Windows‏ (gradlew.bat) וכסקריפט מעטפת ל-Linux ול-Mac‏ (gradlew.sh), וניתן לגשת אליו מהשורש של כל פרויקט שיוצרים באמצעות Android Studio.

כדי להריץ משימה באמצעות המעטפת, משתמשים באחת מהפקודות הבאות מחלון מסוף (ב-Android Studio, בוחרים באפשרות View > Tool Windows > Terminal):

• במסוף הפקודה של Windows:

  gradlew task-name

• ב-Mac, ב-Linux או ב-Windows PowerShell:

  ./gradlew task-name

כדי לראות רשימה של כל משימות ה-build הזמינות בפרויקט, מריצים את הפקודה tasks:

gradlew tasks

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

אם אתם מעדיפים להשתמש בכלים של Android Studio במקום בכלים של שורת הפקודה, תוכלו לעיין במאמר יצירת build והרצה של האפליקציה.

מידע על סוגי build

כברירת מחדל, יש שני סוגים של גרסאות build זמינות לכל אפליקציה ל-Android: אחת לצורך ניפוי באגים באפליקציה – גרסת ה-debug – ואחת לצורך השקת האפליקציה למשתמשים – גרסת ה-release. כדי לפרוס את האפליקציה במכשיר, צריך לחתום על הפלט שנוצר מכל build באמצעות אישור. ה-build לניפוי באגים נחתם באופן אוטומטי באמצעות מפתח ניפוי באגים שסופק על ידי כלי ה-SDK (הוא לא מאובטח ואי אפשר לפרסם איתו ב-Google Play Store), ויש לחתום על ה-build למהדורה באמצעות מפתח פרטי משלכם.

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

אפשר גם להגדיר סוג build מותאם אישית בקובץ build.gradle.kts ולהגדיר אותו כ-build לניפוי באגים על ידי הכללת debuggable true. למידע נוסף, קראו את המאמר הגדרת וריאנטים של גרסאות build.

פיתוח ופריסה של קובץ APK

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

יצירת גרסת build של APK לניפוי באגים

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

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

gradlew assembleDebug

הפעולה הזו יוצרת קובץ APK בשם module_name-debug.apk ב-project_name/module_name/build/outputs/apk/. הקובץ כבר חתום באמצעות מפתח ניפוי הבאגים ותואם ל-zipalign, כך שאפשר להתקין אותו במכשיר באופן מיידי.

לחלופין, כדי ליצור את קובץ ה-APK ולהתקין אותו באופן מיידי במהלך הפעלת אמולטור או במכשיר מחובר, מפעילים את הפקודה installDebug:

gradlew installDebug

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

כדי לראות את כל משימות ה-build וההתקנה שזמינות לכל וריאנט (כולל משימות להסרת התקנות), מריצים את המשימה tasks.

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

פיתוח של App Bundle או APK למהדורה

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

פריסת האפליקציה במהדמ.

כדי להשתמש במהדמנת Android, צריך ליצור מכשיר וירטואלי של Android‏ (AVD) באמצעות Android Studio.

אחרי שיוצרים מכשיר AVD, מפעילים את Android Emulator ומתקינים את האפליקציה באופן הבא:

1. בשורת הפקודה, עוברים אל android_sdk/tools/ ומתחילים את האמולטור על ידי ציון ה-AVD:

   emulator -avd avd_name

   אם אתם לא בטוחים מה השם של ה-AVD, תוכלו להריץ את הפקודה emulator -list-avds.

2. עכשיו אפשר להתקין את האפליקציה באמצעות אחת מהמשימות להתקנה של Gradle שצוינו בקטע בנושא יצירת קובץ APK לניפוי באגים או באמצעות הכלי adb.

   אם קובץ ה-APK נוצר באמצעות SDK של תצוגה מקדימה למפתחים (אם הערך של targetSdkVersion הוא אות במקום מספר), צריך לכלול את האפשרות -t בפקודה install כדי להתקין קובץ APK לבדיקה.

   adb install path/to/your_app.apk
   

   כל קובצי ה-APK שתיצרו יישמרו ב-project_name/module_name/build/outputs/apk/.

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

פריסה של האפליקציה במכשיר פיזי

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

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

אחרי שמגדירים את המכשיר ומחברים אותו באמצעות USB, אפשר להתקין את האפליקציה באמצעות משימות ההתקנה של Gradle שמפורטות בקטע יצירת קובץ APK לניפוי באגים או באמצעות הכלי adb:

adb -d install path/to/your_app.apk

כל קובצי ה-APK שתיצרו יישמרו ב-project_name/module_name/build/outputs/apk/.

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

איך יוצרים חבילה של אפליקציות

קובצי Android App Bundle כוללים את כל המשאבים והקוד המקודד של האפליקציה, אבל העברת היצירה והחתימה של ה-APK ל-Google Play. בניגוד לקובץ APK, אי אפשר לפרוס חבילת אפליקציות ישירות במכשיר. לכן, אם אתם רוצים לבדוק במהירות או לשתף עם מישהו אחר חבילת APK, עדיף ליצור חבילת APK.

הדרך הקלה ביותר ליצור חבילת אפליקציות היא באמצעות Android Studio. עם זאת, אם אתם צריכים ליצור חבילת אפליקציה משורת הפקודה, תוכלו לעשות זאת באמצעות Gradle או bundletool, כפי שמתואר בקטעים הבאים.

איך בונים חבילה של אפליקציה באמצעות Gradle

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

./gradlew :base:bundleDebug

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

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

jarsigner -keystore pathToKeystore app-release.aab keyAlias

הערה: לא ניתן להשתמש ב-apksigner כדי לחתום על חבילת האפליקציות.

איך יוצרים חבילה של אפליקציה באמצעות bundletool

bundletool הוא כלי שורת פקודה שמשמש את Android Studio, את הפלאגין Android Gradle ואת Google Play כדי להמיר את המשאבים והקוד המהדר של האפליקציה לקובצי App Bundle, וליצור מקבצים כאלה חבילות APK שניתן לפרוס.

לכן, למרות שמומלץ לבדוק חבילות אפליקציות באמצעות bundletool ולשחזר באופן מקומי את האופן שבו Google Play יוצרת חבילות APK, בדרך כלל לא תצטרכו להפעיל את bundletool כדי ליצור את חבילת האפליקציות עצמה. במקום זאת, כדאי להשתמש במשימות של Android Studio או Gradle, כפי שמתואר בקטעים הקודמים.

עם זאת, אם אתם לא רוצים להשתמש ב-Android Studio או במשימות Gradle כדי ליצור חבילות – לדוגמה, אם אתם משתמשים בכלי פיתוח מותאם אישית – תוכלו להשתמש בפקודה bundletool בשורת הפקודה כדי ליצור חבילת אפליקציות מקוד וממשאבים שכבר עבר קומפילציה. אם עדיין לא עשיתם זאת, מורידים את bundletool מהמאגר ב-GitHub.

בקטע הזה מוסבר איך לארוז את הקוד והמשאבים של האפליקציה, ואיך להשתמש בפקודה bundletool בשורת הפקודה כדי להמיר אותם לקובץ Android App Bundle.

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

כדי להשתמש ב-bundletool, צריך להעביר מידע מסוים על פרויקט האפליקציה, כמו המניפסט והמשאבים של האפליקציה, בפורמט Protocol Buffer של Google, שנקרא גם protobuf ומשתמש בקובץ עם סיומת *.pb. Protobufs מספקים מנגנון גמיש, שאינו תלוי שפה או פלטפורמה, לסריאליזציה של נתונים מובְנים. הוא דומה ל-XML, אבל קטן יותר, מהיר יותר ופשוט יותר.

הורדת AAPT2

אפשר ליצור את קובץ המניפסט ואת טבלת המשאבים של האפליקציה בפורמט protobuf באמצעות הגרסה האחרונה של AAPT2 ממאגר Maven של Google.

זהירות: אין להשתמש בגרסה של AAPT2 שכלולה בחבילת הכלים ל-build של Android – הגרסה הזו של AAPT2 לא תומכת ב-bundletool.

כדי להוריד את AAPT2 ממאגר Maven של Google:

1. עוברים אל com.android.tools.build > aapt2 באינדקס המאגר.
2. מעתיקים את השם של הגרסה האחרונה של AAPT2.

3. מוסיפים את שם הגרסה שהעתקתם לכתובת ה-URL הבאה ומציינים את מערכת ההפעלה של היעד: https://dl.google.com/dl/android/maven2/com/android/tools/build/aapt2/aapt2-version/aapt2-aapt2-version-[windows | linux | osx].jar

   לדוגמה, כדי להוריד את הגרסה 3.2.0-alpha18-4804415 ל-Windows, צריך להשתמש בכתובת: https://dl.google.com/dl/android/maven2/com/android/tools/build/aapt2/3.2.0-alpha18-4804415/aapt2-3.2.0-alpha18-4804415-windows.jar

4. עוברים לכתובת ה-URL בדפדפן – הורדת AAPT2 אמורה להתחיל תוך זמן קצר.

5. פותחים את קובץ ה-JAR שהורדתם.

איך אוספים את המשאבים של האפליקציה ומקשרים אותם

משתמשים ב-AAPT2 כדי לקמפל את המשאבים של האפליקציה באמצעות הפקודה הבאה:

aapt2 compile \
project_root/module_root/src/main/res/drawable/Image1.png \
project_root/module_root/src/main/res/drawable/Image2.png \
-o compiled_resources/

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

בשלב הקישור, שבו AAPT2 מקשר את המשאבים השונים שעברתם הידור לקובץ APK יחיד, צריך להורות ל-AAPT2 להמיר את המניפסט ואת המשאבים המתורגמים של האפליקציה לפורמט protobuf על ידי הוספת הדגל --proto-format, כפי שמתואר בהמשך:

aapt2 link --proto-format -o output.apk \
-I android_sdk/platforms/android_version/android.jar \
--manifest project_root/module_root/src/main/AndroidManifest.xml \
-R compiled_resources/*.flat \
--auto-add-overlay

הערה: לחלופין, כשמציינים משאבים מועברים באמצעות הדגל -R, אפשר לציין קובץ טקסט שכולל את הנתיב המוחלט של כל אחד מהמשאבים המועברים – כל נתיב מופרד באמצעות רווח אחד. לאחר מכן תוכלו להעביר את קובץ הטקסט הזה אל AAPT2 באופן הבא: aapt2 link ... -R @compiled_resources.txt.

לאחר מכן תוכלו לחלץ תוכן מקובץ ה-APK של הפלט, כמו AndroidManifest.xml,‏ resources.pb וקובצי משאבים אחרים של האפליקציה – עכשיו בפורמט protobuf. צריך את הקבצים האלה כדי להכין את הקלט שנדרש ל-bundletool כדי ליצור את חבילת האפליקציות, כפי שמתואר בקטע הבא.

אריזה של קוד ומשאבים שעבר הידור מראש

לפני שמשתמשים ב-bundletool כדי ליצור חבילת אפליקציה לאפליקציה, צריך קודם לספק קובצי ZIP שמכילים את הקוד המהדר והמשאבים של מודול אפליקציה נתון. התוכן והארגון של קובץ ה-ZIP של כל מודול דומים מאוד לפורמט של Android App Bundle. לדוגמה, צריך ליצור קובץ base.zip למודול הבסיסי של האפליקציה ולארגן את התוכן שלו באופן הבא:

קובץ או ספרייה	תיאור
manifest/AndroidManifest.xml	המניפסט של המודול בפורמט protobuf.
dex/...	ספרייה עם קובץ DEX אחד או יותר של האפליקציה שלכם. יש לתת לשמות הקבצים האלה את השמות הבאים: classes.dex,‏ classes2.dex,‏ classes3.dex וכו'.
res/...	מכיל את המשאבים של המודול בפורמט protobuf לכל תצורות המכשירים. ספריות המשנה והקבצים צריכים להיות מאורגנים באופן דומה לאופן שבו הם מאורגנים ב-APK רגיל.
‫root/..., assets/... וגם lib/...	הספריות האלה זהות לאלה שמתוארות בקטע הפורמט של Android App Bundle.
resources.pb	טבלת המשאבים של האפליקציה בפורמט protobuf.

אחרי שמכינים את קובץ ה-ZIP לכל מודול באפליקציה, אפשר להעביר אותם ל-bundletool כדי ליצור את חבילת האפליקציה, כפי שמתואר בקטע הבא.

איך יוצרים את חבילת האפליקציה באמצעות bundletool

כדי ליצור את חבילת האפליקציה, משתמשים בפקודה bundletool build-bundle, כפי שמתואר בהמשך:

bundletool build-bundle --modules=base.zip --output=mybundle.aab

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

בטבלה הבאה מפורטים דגלים לפקודה build-bundle בפירוט:

סימון	תיאור
--modules=path-to-base.zip, path-to-module2.zip,path-to-module3.zip	מציין את רשימת קובצי ה-ZIP של המודולים שבהם bundletool צריך להשתמש כדי ליצור את חבילת האפליקציות.
--output=path-to-output.aab	מציין את הנתיב ואת שם הקובץ של קובץ הפלט *.aab.
--config=path-to-BundleConfig.json	הנתיב לקובץ תצורה אופציונלי שאפשר להשתמש בו כדי להתאים אישית את תהליך ה-build. מידע נוסף זמין בקטע התאמה אישית של יצירת קובצי APK ב-downstream.
--metadata-file=target-bundle-path:local-file-path	הפקודה מורה ל-bundletool לארוז קובץ מטא-נתונים אופציונלי בתוך חבילת האפליקציה. אפשר להשתמש בקובץ הזה כדי לכלול נתונים, כמו מיפויים של ProGuard או הרשימה המלאה של קובצי ה-DEX של האפליקציה, שעשויים להיות שימושיים בשלבים אחרים בכלי הפיתוח או בחנות האפליקציות. ‫target-bundle-path מציין נתיב יחסי לשורש של חבילת האפליקציות שבו רוצים לארוז את קובץ המטא-נתונים, ו-local-file-path מציין את הנתיב לקובץ המטא-נתונים המקומי עצמו.

התאמה אישית של יצירת חבילות APK ב-downstream

חבילות אפליקציות כוללות קובץ BundleConfig.pb שמספק מטא-נתונים שנדרשים לחנויות אפליקציות, כמו Google Play, כשיוצרים חבילות APK מהחבילה. אמנם הפקודה bundletool יוצרת את הקובץ הזה בשבילכם, אבל אתם יכולים להגדיר היבטים מסוימים של המטא-נתונים בקובץ BundleConfig.json ולהעביר אותו לפקודה bundletool build-bundle. בהמשך, הפקודה bundletool ממירה את הקובץ הזה וממזגת אותו עם גרסת ה-protobuf שכלולה בכל חבילת אפליקציות.

הערה: למידע נוסף על המיפוי של JSON לפורמט protobuf, קראו את המאמר מיפוי JSON. עם זאת, המידע הזה מתקדם יותר מהנדרש בדף הזה.

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

{
  "optimizations": {
    "splitsConfig": {
      "splitDimension": [{
        "value": "LANGUAGE",
        "negate": true
      }]
    }
  }
}

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

{
  "compression": {
    "uncompressedGlob": ["res/raw/**", "assets/**.uncompressed"]
  }
}

חשוב לזכור: כברירת מחדל, bundletool לא דוחס את הספריות הילידיות של האפליקציה (ב-Android 6.0 ואילך) ואת טבלת המשאבים (resources.arsc). לתיאור מלא של מה שאפשר להגדיר ב-BundleConfig.json, כדאי לעיין בקובץ config.proto של bundletool, שנכתב באמצעות תחביר Proto3.

פריסת האפליקציה מקובץ App Bundle

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

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

אתם לא צריכים את Android Studio כדי לחתום על האפליקציה. אתם יכולים לחתום על האפליקציה משורת הפקודה, באמצעות apksigner עבור חבילות APK או jarsigner עבור חבילות אפליקציות, או להגדיר את Gradle כדי שיחתום עליהן בשבילכם במהלך ה-build. בכל מקרה, קודם צריך ליצור מפתח פרטי באמצעות keytool, כפי שמתואר בהמשך:

keytool -genkey -v -keystore my-release-key.jks -keyalg RSA -keysize 2048 -validity 10000 -alias my-alias

בדוגמה שלמעלה, תתבקשו להזין סיסמאות למאגר המפתחות ולמפתח, וגם לשדות 'Distinguished Name' של המפתח. לאחר מכן הוא יוצר את מאגר המפתחות כקובץ בשם my-release-key.jks, ושומר אותו בספרייה הנוכחית (אפשר להעביר אותו לאן שרוצים). מאגר המפתחות מכיל מפתח אחד שתקף למשך 10,000 ימים.

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

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

כדי לחתום על חבילת אפליקציות משורת הפקודה, אפשר להשתמש בפקודה jarsigner. אם במקום זאת רוצים לחתום על קובץ APK, צריך להשתמש ב-zipalign וב-apksigner כפי שמתואר בהמשך.

1. פותחים שורת פקודה – ב-Android Studio, בוחרים באפשרות View > Tool Windows > Terminal – ועוברים לספרייה שבה נמצא קובץ ה-APK ללא החתימה.

2. מיישרים את קובץ ה-APK הלא חתום באמצעות zipalign:

   zipalign -v -p 4 my-app-unsigned.apk my-app-unsigned-aligned.apk
   

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

3. חותמים על חבילת ה-APK באמצעות המפתח הפרטי באמצעות apksigner:

   apksigner sign --ks my-release-key.jks --out my-app-release.apk my-app-unsigned-aligned.apk
   

   בדוגמה הזו, חבילת ה-APK החתומה נוצרת בתיקייה my-app-release.apk אחרי החתימה עליה באמצעות מפתח פרטי ואישור שמאוחסנים בקובץ KeyStore יחיד: my-release-key.jks.

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

   הערה: כדי להשתמש בכלי apksigner, צריך להתקין את הגרסה 24.0.3 ואילך של Android SDK Build Tools. אפשר לעדכן את החבילה הזו באמצעות מנהל ה-SDK.

4. מוודאים שה-APK חתום:

   apksigner verify my-app-release.apk
   

הגדרת Gradle לחתימה על האפליקציה

פותחים את הקובץ build.gradle.kts ברמת המודול ומוסיפים את הבלוק signingConfigs {} עם רשומות ל-storeFile, ל-storePassword, ל-keyAlias ול-keyPassword, ולאחר מכן מעבירים את האובייקט הזה למאפיין signingConfig בסוג ה-build. לדוגמה:

Kotlin

android {
    ...
    defaultConfig { ... }
    signingConfigs {
        create("release") {
            // You need to specify either an absolute path or include the
            // keystore file in the same directory as the build.gradle file.
            storeFile = file("my-release-key.jks")
            storePassword = "password"
            keyAlias = "my-alias"
            keyPassword = "password"
        }
    }
    buildTypes {
        getByName("release") {
            signingConfig = signingConfigs.getByName("release")
            ...
        }
    }
}

Groovy

android {
    ...
    defaultConfig { ... }
    signingConfigs {
        release {
            // You need to specify either an absolute path or include the
            // keystore file in the same directory as the build.gradle file.
            storeFile file("my-release-key.jks")
            storePassword "password"
            keyAlias "my-alias"
            keyPassword "password"
        }
    }
    buildTypes {
        release {
            signingConfig signingConfigs.release
            ...
        }
    }
}

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

עכשיו, כשאתם יוצרים את האפליקציה על ידי הרצת משימה ב-Gradle, Gradle חותם על האפליקציה בשבילכם (ומריץ את zipalign).

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

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