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

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

כדי להריץ משימה עם ה-wrapper, צריך להשתמש באחת מהפקודות הבאות חלון טרמינל (ב-Android Studio, בוחרים באפשרות תצוגה > Windows בכלי > טרמינל):

• ב-Windows Command Shell:

  gradlew task-name

• ב-Mac , Linux או Windows PowerShell:

  ./gradlew task-name

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

gradlew tasks

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

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

מידע על סוגי build

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

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

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

יצירה ופריסה של APK

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

בניית APK לניפוי באגים

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

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

gradlew assembleDebug

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

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

gradlew installDebug

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

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

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

פיתוח חבילת הפצה או APK

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

פריסת האפליקציה לאמולטור

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

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

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 number שבע פעמים. חזרה למסך הקודם כדי למצוא את אפשרויות למפתחים.

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

adb -d install path/to/your_app.apk

כל חבילות ה-APK שיוצרים נשמרות בהן project_name/module_name/build/outputs/apk/

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

בניית App Bundle

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

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

פיתוח App Bundle באמצעות Gradle

אם ברצונך ליצור App Bundle משורת הפקודה, צריך להריץ את bundleVariant משימת Gradle במודול הבסיסי של האפליקציה. לדוגמה, הפקודה הבאה יוצרת App Bundle לגרסת ניפוי הבאגים של המודול הבסיסי:

./gradlew :base:bundleDebug

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

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

jarsigner -keystore pathToKeystore app-release.aab keyAlias

הערה: אי אפשר להשתמש ב-apksigner כדי לחתום על ה-App Bundle.

בניית App Bundle באמצעות Bundletool

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

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

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

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

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

האפליקציה bundletool דורשת מידע מסוים על הפרויקט באפליקציה, כמו את המניפסט של האפליקציה ואת המשאבים שלה, להיות הפורמט של מאגר האחסון לפרוטוקולים של Google – נקרא גם "פרוטובוף" והוא משתמש בסיומת הקובץ *.pb. אבות טיפוס לספק מנגנון ניתן להרחבה ולשפה ניטרלית, לפלטפורמה ניטרלית לשינוי סריאלי של נתונים מובְנים - הם דומים ל-XML אבל הם קטנים יותר, מהירים יותר לפשוט יותר.

הורדה של AAPT2

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

זהירות: אין להשתמש בגרסת AAPT2 שכלולה ב-build של Android חבילת הכלים של Google – הגרסה הזו של 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 להמיר את המניפסט של האפליקציה ומשאבים שהורכבו לפורמט של אב-טיפוס על ידי הוספת הדגל --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 וקובצי משאבים אחרים – עכשיו בפורמט אב-טיפוס. הקבצים האלה נדרשים לך כשמכינים את הקלט על bundletool ליצור את ה-App Bundle, כפי שמתואר בסעיפים הבאים .

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

לפני שמשתמשים ב-bundletool כדי ליצור App Bundle לאפליקציה, צריך קודם לספק קובצי מיקוד שבכל אחד מהם יש קוד שעבר הידור ומשאבים, של מודול האפליקציה הנתון. התוכן והארגון של קובץ ה-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 כדי ליצור את ה-App Bundle, כמו שמתואר בקטע הבא.

יצירת App Bundle באמצעות Bundletool

כדי ליצור את ה-App Bundle, צריך להשתמש בפקודה bundletool build-bundle, למשל מוצגת למטה:

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

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

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

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

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

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

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

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

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

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

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

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

פורסים את האפליקציה מ-App Bundle

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

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

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

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

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

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

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

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

1. פותחים שורת פקודה – ב-Android Studio, בוחרים תצוגה > חלונות לכלים > טרמינל – ועוברים לספרייה שבה ה-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. אפשר לעדכן את החבילה הזו באמצעות מנהל ה-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")
            ...
        }
    }
}

מגניב

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 (ומפעילה את ziplay) במקומכם.

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

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