मेन्यू, कई तरह के ऐप्लिकेशन में यूज़र इंटरफ़ेस का एक सामान्य कॉम्पोनेंट होता है. उपयोगकर्ताओं को बेहतर अनुभव देने के लिए, Menu एपीआई का इस्तेमाल करें. इससे, अपनी गतिविधियों में उपयोगकर्ता की कार्रवाइयों और अन्य विकल्पों को दिखाया जा सकता है.
इस दस्तावेज़ में, Android के सभी वर्शन पर तीन तरह के मेन्यू या ऐक्शन प्रज़ेंटेशन बनाने का तरीका बताया गया है:
- विकल्प मेन्यू और ऐप्लिकेशन बार
- विकल्प मेन्यू, किसी ऐक्टिविटी के लिए मेन्यू आइटम का मुख्य कलेक्शन होता है. यहां ऐसी कार्रवाइयां की जाती हैं जिनका ऐप्लिकेशन पर ग्लोबल असर पड़ता है. जैसे, "खोजें," "ईमेल लिखें," और "सेटिंग."
विकल्प मेन्यू बनाएं सेक्शन देखें.
- कॉन्टेक्स्ट मेन्यू और काम की कार्रवाई वाला मोड
- कॉन्टेक्स्ट मेन्यू एक फ़्लोटिंग मेन्यू होता है, जो किसी एलिमेंट को दबाकर रखने पर दिखता है. यह
चुने गए कॉन्टेंट या कॉन्टेक्स्ट फ़्रेम पर असर डालने वाली कार्रवाइयां उपलब्ध कराता है.
कॉन्टेक्स्ट के हिसाब से ऐक्शन मोड, स्क्रीन के सबसे ऊपर एक बार में ऐसे ऐक्शन आइटम दिखाता है जिनका असर चुने गए कॉन्टेंट पर पड़ता है. साथ ही, यह उपयोगकर्ता को एक से ज़्यादा आइटम चुनने की सुविधा देता है.
कॉन्टेक्स्ट मेन्यू बनाना सेक्शन देखें.
- पॉप-अप मेन्यू
- पॉप-अप मेन्यू, आइटम की वर्टिकल सूची दिखाता है. यह सूची, उस व्यू से जुड़ी होती है जिससे मेन्यू को चालू किया जाता है. यह किसी खास कॉन्टेंट से जुड़ी कार्रवाइयों के लिए, ऑवरफ़्लो की सुविधा देता है. इसके अलावा, यह किसी निर्देश के दूसरे हिस्से के लिए विकल्प भी उपलब्ध कराता है. पॉप-अप मेन्यू में मौजूद कार्रवाइयों का सीधा असर, उस कॉन्टेंट पर नहीं पड़ता है जिस पर वे की जाती हैं. इसके लिए, कॉन्टेक्स्ट के हिसाब से कार्रवाइयां की जाती हैं. इसके बजाय,
पॉप-अप मेन्यू उन एक्सटेंडेड ऐक्शन के लिए है जो आपकी गतिविधि में कॉन्टेंट के क्षेत्रों से जुड़े हैं.
पॉप-अप मेन्यू बनाना सेक्शन देखें.
एक्सएमएल में मेन्यू तय करना
Android, मेन्यू आइटम तय करने के लिए, सभी तरह के मेन्यू के लिए स्टैंडर्ड एक्सएमएल फ़ॉर्मैट उपलब्ध कराता है. अपनी गतिविधि के कोड में मेन्यू बनाने के बजाय, एक्सएमएल मेन्यू रिसॉर्स में मेन्यू और उसके सभी आइटम तय करें. इसके बाद, अपनी ऐक्टिविटी या फ़्रैगमेंट में मेन्यू संसाधन को Menu ऑब्जेक्ट के तौर पर लोड करके, उसे फ़ुल फ़ॉर्मैट में दिखाया जा सकता है.
मेन्यू संसाधन का इस्तेमाल करने का यह तरीका अपनाना अच्छा है, क्योंकि:
- एक्सएमएल में मेन्यू के स्ट्रक्चर को विज़ुअलाइज़ करना आसान होता है.
- यह मेन्यू के कॉन्टेंट को आपके ऐप्लिकेशन के व्यवहार से जुड़े कोड से अलग करता है.
- इसकी मदद से, ऐप्लिकेशन के संसाधनों के फ़्रेमवर्क का इस्तेमाल करके, अलग-अलग प्लैटफ़ॉर्म के वर्शन, स्क्रीन साइज़, और अन्य कॉन्फ़िगरेशन के लिए, मेन्यू के वैकल्पिक कॉन्फ़िगरेशन बनाए जा सकते हैं.
मेन्यू तय करने के लिए, अपने प्रोजेक्ट की res/menu/ डायरेक्ट्री में एक एक्सएमएल फ़ाइल बनाएं. इसके बाद, इन एलिमेंट की मदद से मेन्यू बनाएं:
<menu>Menuतय करता है, जो मेन्यू आइटम के लिए कंटेनर होता है.<menu>एलिमेंट, फ़ाइल का रूट नोड होना चाहिए. साथ ही, इसमें एक या उससे ज़्यादा<item>और<group>एलिमेंट हो सकते हैं.<item>- एक ऐसा
MenuItemबनाता है जो किसी मेन्यू में एक आइटम को दिखाता है. इस एलिमेंट में नेस्ट किया गया<menu>एलिमेंट हो सकता है, ताकि सबमेन्यू बनाया जा सके. <group><item>एलिमेंट के लिए, एक वैकल्पिक और न दिखने वाला कंटेनर. इसकी मदद से, मेन्यू आइटम को कैटगरी में बांटा जा सकता है, ताकि वे प्रॉपर्टी शेयर कर सकें. जैसे, चालू होने की स्थिति और दिखने की सेटिंग. ज़्यादा जानकारी के लिए, मेन्यू ग्रुप बनाना सेक्शन देखें.
यहां game_menu.xml नाम के मेन्यू का उदाहरण दिया गया है:
<?xml version="1.0" encoding="utf-8"?> <menu xmlns:android="http://schemas.android.com/apk/res/android"> <item android:id="@+id/new_game" android:icon="@drawable/ic_new_game" android:title="@string/new_game" app:showAsAction="ifRoom"/> <item android:id="@+id/help" android:icon="@drawable/ic_help" android:title="@string/help" /> </menu>
<item> एलिमेंट में कई एट्रिब्यूट इस्तेमाल किए जा सकते हैं. इनका इस्तेमाल, आइटम के दिखने के तरीके और उसके व्यवहार को तय करने के लिए किया जा सकता है. ऊपर दिए गए मेन्यू में मौजूद आइटम में ये एट्रिब्यूट शामिल हैं:
android:id- आइटम के लिए यूनीक रिसॉर्स आईडी, जिसकी मदद से ऐप्लिकेशन, उपयोगकर्ता के आइटम चुनने पर उसकी पहचान कर पाता है.
android:icon- आइटम के आइकॉन के तौर पर इस्तेमाल करने के लिए, ड्रॉबल का रेफ़रंस.
android:title- आइटम के टाइटल के तौर पर इस्तेमाल करने के लिए, स्ट्रिंग का रेफ़रंस.
android:showAsAction- इस आइटम के ऐप्लिकेशन बार में ऐक्शन आइटम के तौर पर दिखने के समय और तरीके के बारे में जानकारी.
ये सबसे ज़रूरी एट्रिब्यूट हैं, लेकिन इसके अलावा और भी कई एट्रिब्यूट उपलब्ध हैं. इस्तेमाल किए जा सकने वाले सभी एट्रिब्यूट के बारे में जानकारी पाने के लिए, मेन्यू संसाधन दस्तावेज़ देखें.
किसी भी मेन्यू में मौजूद आइटम में सबमेन्यू जोड़ा जा सकता है. इसके लिए, <item> के चाइल्ड के तौर पर <menu> एलिमेंट जोड़ें.
सबमेन्यू तब काम के होते हैं, जब आपके ऐप्लिकेशन में कई फ़ंक्शन होते हैं और उन्हें विषयों के हिसाब से व्यवस्थित किया जा सकता है. जैसे, पीसी ऐप्लिकेशन के मेन्यू बार में मौजूद आइटम, जैसे कि फ़ाइल,
बदलाव करें, और देखें. यह उदाहरण देखें:
<?xml version="1.0" encoding="utf-8"?> <menu xmlns:android="http://schemas.android.com/apk/res/android"> <item android:id="@+id/file" android:title="@string/file" > <!-- "file" submenu --> <menu> <item android:id="@+id/create_new" android:title="@string/create_new" /> <item android:id="@+id/open" android:title="@string/open" /> </menu> </item> </menu>
अपनी गतिविधि में मेन्यू का इस्तेमाल करने के लिए, मेन्यू रिसॉर्स को _इंफ़्लेट_ करें. इसके लिए, MenuInflater.inflate() का इस्तेमाल करके, एक्सएमएल रिसॉर्स को प्रोग्राम किए जा सकने वाले ऑब्जेक्ट में बदलें.
नीचे दिए गए सेक्शन में, हर तरह के मेन्यू को फ़ुल करने का तरीका बताया गया है.
विकल्प मेन्यू बनाना
विकल्प मेन्यू में, मौजूदा गतिविधि के कॉन्टेक्स्ट से जुड़ी कार्रवाइयां और अन्य विकल्प शामिल किए जाते हैं. जैसे, "खोजें", "ईमेल लिखें", और "सेटिंग". यह मेन्यू, पहले चित्र में दिखाया गया है.
विकल्प मेन्यू के लिए आइटम, अपनी Activityसबक्लास या किसी Fragmentसबक्लास से घोषित किए जा सकते हैं. अगर आपकी गतिविधि और फ़्रैगमेंट, दोनों में विकल्प मेन्यू के लिए आइटम दिखाए जाते हैं, तो यूज़र इंटरफ़ेस (यूआई) में आइटम को आपस में जोड़ दिया जाता है. गतिविधि के आइटम सबसे पहले दिखते हैं. इसके बाद, हर फ़्रैगमेंट के आइटम उसी क्रम में दिखते हैं जिस क्रम में फ़्रैगमेंट को गतिविधि में जोड़ा गया है. ज़रूरत पड़ने पर, android:orderInCategory एट्रिब्यूट की मदद से मेन्यू आइटम का क्रम बदला जा सकता है. इसके लिए, आपको हर उस <item> के लिए android:orderInCategory एट्रिब्यूट की वैल्यू डालनी होगी जिसे आपको एक से दूसरी जगह ले जाना है.
किसी गतिविधि के लिए विकल्प मेन्यू तय करने के लिए, onCreateOptionsMenu() को बदलें.
फ़्रैगमेंट अपने onCreateOptionsMenu() कॉलबैक की जानकारी देते हैं. इस तरीके से, एक्सएमएल में तय किए गए अपने मेन्यू रिसॉर्स को, कॉलबैक में दिए गए Menu में फ़ुलफ़िल किया जा सकता है. यह नीचे दिए गए उदाहरण में दिखाया गया है:
Kotlin
override fun onCreateOptionsMenu(menu: Menu): Boolean { val inflater: MenuInflater = menuInflater inflater.inflate(R.menu.game_menu, menu) return true }
Java
@Override public boolean onCreateOptionsMenu(Menu menu) { MenuInflater inflater = getMenuInflater(); inflater.inflate(R.menu.game_menu, menu); return true; }
add() का इस्तेमाल करके भी मेन्यू आइटम जोड़े जा सकते हैं. साथ ही, MenuItem एपीआई की मदद से उनकी प्रॉपर्टी में बदलाव करने के लिए, findItem() का इस्तेमाल करके आइटम वापस पाए जा सकते हैं.
क्लिक इवेंट मैनेज करना
जब उपयोगकर्ता ऐप्लिकेशन बार में मौजूद ऐक्शन आइटम के साथ-साथ, विकल्प मेन्यू से कोई आइटम चुनता है, तो सिस्टम आपकी गतिविधि के onOptionsItemSelected()
तरीके को कॉल करता है. यह तरीका, चुने गए MenuItem को पास करता है. getItemId() को कॉल करके, आइटम की पहचान की जा सकती है. यह मेन्यू आइटम का यूनीक आईडी दिखाता है. यह आईडी, मेन्यू रिसॉर्स में android:id एट्रिब्यूट से तय होता है या add() तरीके में दिए गए पूर्णांक से तय होता है. सही कार्रवाई करने के लिए, इस आईडी को मेन्यू के जाने-पहचाने आइटम से मैच किया जा सकता है.
Kotlin
override fun onOptionsItemSelected(item: MenuItem): Boolean { // Handle item selection. return when (item.itemId) { R.id.new_game -> { newGame() true } R.id.help -> { showHelp() true } else -> super.onOptionsItemSelected(item) } }
Java
@Override public boolean onOptionsItemSelected(MenuItem item) { // Handle item selection. switch (item.getItemId()) { case R.id.new_game: newGame(); return true; case R.id.help: showHelp(); return true; default: return super.onOptionsItemSelected(item); } }
मेन्यू आइटम को मैनेज करने के बाद, true दिखाएं. अगर आपने मेन्यू आइटम को मैनेज नहीं किया है, तो onOptionsItemSelected() के सुपरक्लास को लागू करें. डिफ़ॉल्ट तौर पर लागू करने पर, यह फ़ंक्शन
गलत वैल्यू दिखाता है.
अगर आपकी गतिविधि में फ़्रैगमेंट शामिल हैं, तो सिस्टम सबसे पहले गतिविधि के लिए onOptionsItemSelected() को कॉल करता है. इसके बाद, फ़्रैगमेंट को जोड़े जाने के क्रम में हर फ़्रैगमेंट के लिए कॉल करता है. ऐसा तब तक होता है, जब तक कोई फ़्रैगमेंट true नहीं दिखाता या सभी फ़्रैगमेंट को कॉल नहीं किया जाता.
रनटाइम के दौरान मेन्यू आइटम बदलना
सिस्टम onCreateOptionsMenu() को कॉल करने के बाद, आपके भरी हुई Menu का एक इंस्टेंस बनाए रखता है. साथ ही, मेन्यू अमान्य होने तक onCreateOptionsMenu() को फिर से कॉल नहीं करता.
हालांकि, onCreateOptionsMenu() का इस्तेमाल सिर्फ़ मेन्यू की शुरुआती स्थिति बनाने के लिए करें, न कि गतिविधि के लाइफ़साइकल के दौरान बदलाव करने के लिए.
अगर आपको गतिविधि के लाइफ़साइकल के दौरान होने वाले इवेंट के आधार पर, विकल्पों के मेन्यू में बदलाव करना है, तो ऐसा onPrepareOptionsMenu()
तरीके से किया जा सकता है. इस तरीके से, आपको Menu ऑब्जेक्ट वैसा ही मिलता है जैसा वह फ़िलहाल मौजूद है, ताकि आप उसमें बदलाव कर सकें. जैसे, आइटम जोड़ना, हटाना या बंद करना.
फ़्रैगमेंट में एक onPrepareOptionsMenu() callback भी होता है.
जब मेन्यू आइटम, ऐप्लिकेशन बार में दिखाए जाते हैं, तो विकल्प मेन्यू को हमेशा खुला माना जाता है. जब कोई इवेंट होता है और आपको मेन्यू अपडेट करना होता है, तो सिस्टम को onPrepareOptionsMenu() कॉल करने का अनुरोध करने के लिए, invalidateOptionsMenu() को कॉल करें.
काम के हिसाब से मेन्यू बनाना
कॉन्टेक्स्ट मेन्यू में ऐसी कार्रवाइयां होती हैं जिनका असर यूज़र इंटरफ़ेस (यूआई) में किसी आइटम या कॉन्टेक्स्ट फ़्रेम पर पड़ता है. किसी भी व्यू के लिए संदर्भ मेन्यू दिया जा सकता है. हालांकि, इनका इस्तेमाल अक्सर RecylerView या अन्य व्यू कलेक्शन में मौजूद आइटम के लिए किया जाता है. इनमें उपयोगकर्ता, हर आइटम पर सीधे कार्रवाई कर सकता है.
काम की कार्रवाइयां देने के दो तरीके हैं:
- फ़्लोटिंग कॉन्टेक्स्ट मेन्यू में. जब कोई उपयोगकर्ता किसी ऐसे व्यू को दबाकर रखता है जिसमें कॉन्टेक्स्ट मेन्यू की सुविधा काम करती है, तो मेन्यू, डायलॉग की तरह ही मेन्यू आइटम की फ़्लोटिंग सूची के तौर पर दिखता है. उपयोगकर्ता एक बार में एक आइटम पर, संदर्भ के हिसाब से कार्रवाई कर सकते हैं.
- काम की कार्रवाई वाले मोड में. यह मोड,
ActionModeको सिस्टम में लागू करने का तरीका है. इसमें स्क्रीन पर सबसे ऊपर, स्थिति के हिसाब से ऐक्शन बार या CAB दिखता है. इसमें, चुने गए आइटम पर असर डालने वाले ऐक्शन आइटम होते हैं. अगर आपका ऐप्लिकेशन इस मोड के साथ काम करता है, तो यह चालू होने पर उपयोगकर्ता एक साथ कई आइटम पर कार्रवाई कर सकते हैं.
ध्यान दें: संदर्भ मेन्यू में आइटम के शॉर्टकट और आइकॉन काम नहीं करते.
फ़्लोटिंग कॉन्टेक्स्ट मेन्यू बनाना
फ़्लोटिंग संदर्भ मेन्यू उपलब्ध कराने के लिए, यह तरीका अपनाएं:
registerForContextMenu()को कॉल करके और उसेViewपास करके, उसViewको रजिस्टर करें जिससे संदर्भ मेन्यू जुड़ा है.अगर आपकी गतिविधि में
RecyclerViewका इस्तेमाल किया जाता है और आपको हर आइटम के लिए एक ही संदर्भ मेन्यू चाहिए, तोRecyclerViewकोregisterForContextMenu()में पास करके, सभी आइटम को संदर्भ मेन्यू के लिए रजिस्टर करें.- अपने
ActivityयाFragmentमें,onCreateContextMenu()का तरीका लागू करें.जब रजिस्टर किए गए व्यू को टच करके दबाने का इवेंट मिलता है, तो सिस्टम आपके
onCreateContextMenu()तरीके को कॉल करता है. यहां मेन्यू आइटम तय किए जाते हैं. आम तौर पर, मेन्यू रिसॉर्स को इन्फ़्लेट करके ऐसा किया जाता है. उदाहरण के लिए:Kotlin
override fun onCreateContextMenu(menu: ContextMenu, v: View, menuInfo: ContextMenu.ContextMenuInfo) { super.onCreateContextMenu(menu, v, menuInfo) val inflater: MenuInflater = menuInflater inflater.inflate(R.menu.context_menu, menu) }
Java
@Override public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) { super.onCreateContextMenu(menu, v, menuInfo); MenuInflater inflater = getMenuInflater(); inflater.inflate(R.menu.context_menu, menu); }
MenuInflaterइससे, मेन्यू संसाधन से कॉन्टेक्स्ट मेन्यू को फ़ुल स्क्रीन पर दिखाया जा सकता है. कॉलबैक के तरीके के पैरामीटर में, उपयोगकर्ता का चुना गयाViewऔर चुने गए आइटम के बारे में ज़्यादा जानकारी देने वालाContextMenu.ContextMenuInfoऑब्जेक्ट शामिल होता है. अगर आपकी गतिविधि के कई व्यू हैं और हर व्यू में अलग-अलग संदर्भ मेन्यू दिखते हैं, तो इन पैरामीटर का इस्तेमाल करके यह तय किया जा सकता है कि कौनसा संदर्भ मेन्यू दिखाना है. यहां दिए गए उदाहरण में दिखाए गए तरीके से,
onContextItemSelected()को लागू करें. जब उपयोगकर्ता कोई मेन्यू आइटम चुनता है, तो सिस्टम इस तरीके को कॉल करता है, ताकि आप सही कार्रवाई कर सकें.Kotlin
override fun onContextItemSelected(item: MenuItem): Boolean { val info = item.menuInfo as AdapterView.AdapterContextMenuInfo return when (item.itemId) { R.id.edit -> { editNote(info.id) true } R.id.delete -> { deleteNote(info.id) true } else -> super.onContextItemSelected(item) } }
Java
@Override public boolean onContextItemSelected(MenuItem item) { AdapterContextMenuInfo info = (AdapterContextMenuInfo) item.getMenuInfo(); switch (item.getItemId()) { case R.id.edit: editNote(info.id); return true; case R.id.delete: deleteNote(info.id); return true; default: return super.onContextItemSelected(item); } }
getItemId()तरीका, चुने गए मेन्यू आइटम के आईडी के बारे में क्वेरी करता है. इस आईडी कोandroid:idएट्रिब्यूट का इस्तेमाल करके, एक्सएमएल में हर मेन्यू आइटम को असाइन किया जाता है. इस बारे में ज़्यादा जानने के लिए, एक्सएमएल में मेन्यू तय करना लेख पढ़ें.मेन्यू आइटम को मैनेज करने के बाद,
trueदिखाएं. अगर आपने मेन्यू आइटम को मैनेज नहीं किया है, तो मेन्यू आइटम को सुपरक्लास के लागू होने पर पास करें. अगर आपकी गतिविधि में फ़्रैगमेंट शामिल हैं, तो गतिविधि को सबसे पहले यह कॉलबैक मिलता है. जब इवेंट को मैनेज नहीं किया जाता है, तो सिस्टम सुपरक्लास को कॉल करके, इवेंट को हर फ़्रैगमेंट में मौजूद संबंधित कॉलबैक मैथड में एक-एक करके पास करता है. ऐसा, हर फ़्रैगमेंट को जोड़े जाने के क्रम में किया जाता है. ऐसा तब तक किया जाता है, जब तकtrueयाfalseनहीं मिल जाता.Activityऔरandroid.app.Fragmentके लिए डिफ़ॉल्ट तौर पर लागू होने वाले फ़ंक्शन,falseदिखाते हैं. इसलिए, जब कोई गड़बड़ी मैनेज न की जा सके, तो हमेशा सुपरक्लास को कॉल करें.
काम की कार्रवाई वाले मोड का इस्तेमाल करना
कॉन्टेक्स्ट ऐक्शन मोड, ActionMode के सिस्टम को लागू करने का एक तरीका है. यह उपयोगकर्ता के इंटरैक्शन को कॉन्टेक्स्ट ऐक्शन करने पर फ़ोकस करता है. जब कोई उपयोगकर्ता किसी आइटम को चुनकर इस मोड को चालू करता है, तो स्क्रीन पर सबसे ऊपर एक संदर्भ के हिसाब से कार्रवाई करने वाला बार दिखता है. इसमें, उपयोगकर्ता को उन कार्रवाइयों के बारे में जानकारी मिलती है जिन्हें चुने गए आइटम पर किया जा सकता है. यह मोड चालू होने पर, उपयोगकर्ता एक से ज़्यादा आइटम चुन सकता है. हालांकि, ऐसा तब ही किया जा सकता है, जब आपका ऐप्लिकेशन इस सुविधा के साथ काम करता हो. साथ ही, उपयोगकर्ता आइटम से चुने हुए का निशान हटा सकता है और गतिविधि में नेविगेट करना जारी रख सकता है. जब उपयोगकर्ता सभी आइटम से चुने हुए का निशान हटाता है, 'वापस जाएं' बटन पर टैप करता है या बार की बाईं ओर मौजूद हो गया कार्रवाई पर टैप करता है, तो ऐक्शन मोड बंद हो जाता है और संदर्भ के हिसाब से ऐक्शन बार गायब हो जाता है.
काम की कार्रवाइयां दिखाने वाले व्यू के लिए, आम तौर पर काम की कार्रवाई वाले मोड को तब चालू किया जाता है, जब इनमें से कोई एक या दोनों इवेंट होते हैं:
- उपयोगकर्ता, व्यू को दबाकर रखता है.
- उपयोगकर्ता, व्यू में चेकबॉक्स या मिलता-जुलता यूज़र इंटरफ़ेस (यूआई) कंपोनेंट चुनता है.
आपका ऐप्लिकेशन, कॉन्टेक्स्ट के हिसाब से ऐक्शन मोड को कैसे चालू करता है और हर ऐक्शन के लिए व्यवहार कैसे तय करता है, यह आपके डिज़ाइन पर निर्भर करता है. इसके दो डिज़ाइन हैं:
- अलग-अलग और मनमुताबिक व्यू पर काम की कार्रवाइयां करने के लिए.
RecyclerViewमें मौजूद आइटम के ग्रुप पर, कॉन्टेक्स्ट के हिसाब से एक साथ कई कार्रवाइयां करने के लिए. इससे उपयोगकर्ता को एक से ज़्यादा आइटम चुनने और उन सभी पर एक साथ कार्रवाई करने की सुविधा मिलती है.
नीचे दिए गए सेक्शन में, पहले मामले के लिए ज़रूरी सेटअप के बारे में बताया गया है.
अलग-अलग व्यू के लिए, काम की कार्रवाई वाला मोड चालू करना
अगर आपको काम की कार्रवाई वाले मोड को सिर्फ़ तब चालू करना है, जब उपयोगकर्ता कोई खास व्यू चुनता है, तो यह तरीका अपनाएं:
ActionMode.Callbackइंटरफ़ेस को इस उदाहरण में दिखाए गए तरीके से लागू करें. इसके कॉलबैक तरीकों में, कॉन्टेक्स्ट के हिसाब से ऐक्शन बार के लिए कार्रवाइयां तय की जा सकती हैं. साथ ही, ऐक्शन आइटम पर क्लिक इवेंट का जवाब दिया जा सकता है और ऐक्शन मोड के लिए लाइफ़साइकल के अन्य इवेंट मैनेज किए जा सकते हैं.Kotlin
private val actionModeCallback = object : ActionMode.Callback { // Called when the action mode is created. startActionMode() is called. override fun onCreateActionMode(mode: ActionMode, menu: Menu): Boolean { // Inflate a menu resource providing context menu items. val inflater: MenuInflater = mode.menuInflater inflater.inflate(R.menu.context_menu, menu) return true } // Called each time the action mode is shown. Always called after // onCreateActionMode, and might be called multiple times if the mode // is invalidated. override fun onPrepareActionMode(mode: ActionMode, menu: Menu): Boolean { return false // Return false if nothing is done } // Called when the user selects a contextual menu item. override fun onActionItemClicked(mode: ActionMode, item: MenuItem): Boolean { return when (item.itemId) { R.id.menu_share -> { shareCurrentItem() mode.finish() // Action picked, so close the CAB. true } else -> false } } // Called when the user exits the action mode. override fun onDestroyActionMode(mode: ActionMode) { actionMode = null } }
Java
private ActionMode.Callback actionModeCallback = new ActionMode.Callback() { // Called when the action mode is created. startActionMode() is called. @Override public boolean onCreateActionMode(ActionMode mode, Menu menu) { // Inflate a menu resource providing context menu items. MenuInflater inflater = mode.getMenuInflater(); inflater.inflate(R.menu.context_menu, menu); return true; } // Called each time the action mode is shown. Always called after // onCreateActionMode, and might be called multiple times if the mode // is invalidated. @Override public boolean onPrepareActionMode(ActionMode mode, Menu menu) { return false; // Return false if nothing is done. } // Called when the user selects a contextual menu item. @Override public boolean onActionItemClicked(ActionMode mode, MenuItem item) { switch (item.getItemId()) { case R.id.menu_share: shareCurrentItem(); mode.finish(); // Action picked, so close the CAB. return true; default: return false; } } // Called when the user exits the action mode. @Override public void onDestroyActionMode(ActionMode mode) { actionMode = null; } };
ये इवेंट कॉलबैक, विकल्प मेन्यू के कॉलबैक से काफ़ी हद तक मिलते-जुलते हैं. हालांकि, इनमें से हर कॉलबैक, इवेंट से जुड़ा
ActionModeऑब्जेक्ट भी पास करता है.ActionModeएपीआई का इस्तेमाल करके, CAB में कई तरह के बदलाव किए जा सकते हैं. जैसे,setTitle()औरsetSubtitle()का इस्तेमाल करके टाइटल और सबटाइटल में बदलाव करना. इससे यह पता चलता है कि कितने आइटम चुने गए हैं.पिछले सैंपल में, ऐक्शन मोड के खत्म होने पर
actionModeवैरिएबल कोnullपर सेट किया गया है. अगले चरण में, देखें कि इसे कैसे शुरू किया जाता है और आपकी ऐक्टिविटी या फ़्रैगमेंट में सदस्य वैरिएबल को सेव करने से कैसे फ़ायदा हो सकता है.- जब आपको बार दिखाना हो, तब
startActionMode()को कॉल करें. जैसे, जब उपयोगकर्ता व्यू को दबाकर रखे.Kotlin
someView.setOnLongClickListener { view -> // Called when the user performs a touch & hold on someView. when (actionMode) { null -> { // Start the CAB using the ActionMode.Callback defined earlier. actionMode = activity?.startActionMode(actionModeCallback) view.isSelected = true true } else -> false } }
Java
someView.setOnLongClickListener(new View.OnLongClickListener() { // Called when the user performs a touch & hold on someView. public boolean onLongClick(View view) { if (actionMode != null) { return false; } // Start the CAB using the ActionMode.Callback defined earlier. actionMode = getActivity().startActionMode(actionModeCallback); view.setSelected(true); return true; } });
startActionMode()को कॉल करने पर, सिस्टम से वहActionModeदिखता है जिसे आपने बनाया है. इसे किसी सदस्य वैरिएबल में सेव करके, दूसरे इवेंट के जवाब में, कॉन्टेक्स्ट के हिसाब से बनने वाले ऐक्शन बार में बदलाव किए जा सकते हैं. पिछले सैंपल में,ActionModeका इस्तेमाल यह पक्का करने के लिए किया गया है कि अगरActionModeइंस्टेंस पहले से चालू है, तो उसे फिर से न बनाया जाए. इसके लिए, ऐक्शन मोड शुरू करने से पहले यह जांच की जाती है कि सदस्य null है या नहीं.
पॉप-अप मेन्यू बनाना
PopupMenu
एक मोडल मेन्यू होता है, जो View पर ऐंकर होता है. अगर स्क्रीन पर जगह है, तो यह ऐंकर व्यू के नीचे दिखता है. अगर जगह नहीं है, तो यह व्यू के ऊपर दिखता है. यह इन कामों के लिए मददगार है:
- किसी खास कॉन्टेंट से जुड़ी कार्रवाइयों के लिए, ओवरफ़्लो स्टाइल वाला मेन्यू उपलब्ध कराना. जैसे, Gmail के ईमेल हेडर, जैसा कि चौथे चित्र में दिखाया गया है.
- निर्देश वाले वाक्य का दूसरा हिस्सा देना. जैसे, जोड़ें के तौर पर मार्क किया गया बटन, जो अलग-अलग जोड़ें विकल्पों वाला पॉप-अप मेन्यू दिखाता है.
- ऐसा मेन्यू उपलब्ध कराना जो
Spinnerजैसा हो, लेकिन चुने गए विकल्प को सेव न करता हो.
अगर आपने मेन्यू को एक्सएमएल में तय किया है, तो पॉप-अप मेन्यू दिखाने का तरीका यहां बताया गया है:
PopupMenuको उसके कन्स्ट्रक्टर की मदद से इंस्टैंशिएट करें. यह कन्स्ट्रक्टर, मौजूदा ऐप्लिकेशनContextऔर उसViewको लेता है जिस पर मेन्यू को ऐंकर किया गया है.MenuInflaterका इस्तेमाल करके, अपने मेन्यू संसाधन कोPopupMenu.getMenu()से दिखाए गएMenuऑब्जेक्ट में फ़्लोर करें.PopupMenu.show()पर कॉल करें.
उदाहरण के लिए, यहां एक ऐसा बटन दिया गया है जो पॉप-अप मेन्यू दिखाता है:
<ImageButton android:id="@+id/dropdown_menu" android:layout_width="wrap_content" android:layout_height="wrap_content" android:contentDescription="@string/descr_overflow_button" android:src="@drawable/arrow_drop_down" />
इसके बाद, गतिविधि इस तरह का पॉप-अप मेन्यू दिखा सकती है:
Kotlin
findViewById<ImageButton>(R.id.dropdown_menu).setOnClickListener { val popup = PopupMenu(this, it) val inflater: MenuInflater = popup.menuInflater inflater.inflate(R.menu.actions, popup.menu) popup.show() }
Java
findViewById(R.id.dropdown_menu).setOnClickListener(v -> { PopupMenu popup = new PopupMenu(this, v); popup.getMenuInflater().inflate(R.menu.actions, popup.getMenu()); popup.show(); });
जब कोई उपयोगकर्ता कोई आइटम चुनता है या मेन्यू के बाहर टैप करता है, तो मेन्यू बंद हो जाता है. PopupMenu.OnDismissListener का इस्तेमाल करके, खारिज करने के इवेंट को सुना जा सकता है.
क्लिक इवेंट मैनेज करना
जब कोई उपयोगकर्ता मेन्यू आइटम चुनता है, तो कोई कार्रवाई करने के लिए, PopupMenu.OnMenuItemClickListener इंटरफ़ेस लागू करें और setOnMenuItemclickListener() को कॉल करके, इसे अपने PopupMenu के साथ रजिस्टर करें.
जब उपयोगकर्ता कोई आइटम चुनता है, तो सिस्टम आपके इंटरफ़ेस में onMenuItemClick() callback को कॉल करता है.
यह नीचे दिए गए उदाहरण में दिखाया गया है:
Kotlin
fun showMenu(v: View) { PopupMenu(this, v).apply { // MainActivity implements OnMenuItemClickListener. setOnMenuItemClickListener(this@MainActivity) inflate(R.menu.actions) show() } } override fun onMenuItemClick(item: MenuItem): Boolean { return when (item.itemId) { R.id.archive -> { archive(item) true } R.id.delete -> { delete(item) true } else -> false } }
Java
public void showMenu(View v) { PopupMenu popup = new PopupMenu(this, v); // This activity implements OnMenuItemClickListener. popup.setOnMenuItemClickListener(this); popup.inflate(R.menu.actions); popup.show(); } @Override public boolean onMenuItemClick(MenuItem item) { switch (item.getItemId()) { case R.id.archive: archive(item); return true; case R.id.delete: delete(item); return true; default: return false; } }
मेन्यू ग्रुप बनाना
मेन्यू ग्रुप, मेन्यू आइटम का एक कलेक्शन होता है. इसमें कुछ खास विशेषताएं होती हैं. ग्रुप की मदद से, ये काम किए जा सकते हैं:
setGroupVisible()का इस्तेमाल करके, सभी आइटम दिखाएं या छिपाएं.setGroupEnabled()का इस्तेमाल करके, सभी आइटम चालू या बंद करें.setGroupCheckable()का इस्तेमाल करके बताएं कि सभी आइटम पर सही का निशान लगाया जा सकता है या नहीं.
मेन्यू संसाधन में <group> एलिमेंट के अंदर <item> एलिमेंट को नेस्ट करके या add() तरीके से ग्रुप आईडी तय करके, ग्रुप बनाया जा सकता है.
यहां मेन्यू रिसॉर्स का एक उदाहरण दिया गया है, जिसमें एक ग्रुप शामिल है:
<?xml version="1.0" encoding="utf-8"?> <menu xmlns:android="http://schemas.android.com/apk/res/android"> <item android:id="@+id/menu_save" android:icon="@drawable/menu_save" android:title="@string/menu_save" /> <!-- menu group --> <group android:id="@+id/group_delete"> <item android:id="@+id/menu_archive" android:title="@string/menu_archive" /> <item android:id="@+id/menu_delete" android:title="@string/menu_delete" /> </group> </menu>
ग्रुप में मौजूद आइटम, पहले आइटम के उसी लेवल पर दिखते हैं—मेन्यू में मौजूद तीनों आइटम एक-दूसरे से जुड़े होते हैं. हालांकि, ग्रुप आईडी का रेफ़रंस देकर और ऊपर बताए गए तरीकों का इस्तेमाल करके, ग्रुप में मौजूद दो आइटम की विशेषताओं में बदलाव किया जा सकता है. सिस्टम, ग्रुप किए गए आइटम को कभी अलग नहीं करता. उदाहरण के लिए, अगर आपने हर आइटम के लिए android:showAsAction="ifRoom" एट्रिब्यूट का इस्तेमाल किया है, तो दोनों आइटम ऐक्शन बार में दिखेंगे या दोनों आइटम ऐक्शन ओवरफ़्लो में दिखेंगे.
ऐसे मेन्यू आइटम इस्तेमाल करना जिन पर सही का निशान लगाया जा सकता है
मेन्यू, विकल्पों को चालू और बंद करने के लिए इंटरफ़ेस के तौर पर काम का हो सकता है. इसके लिए, स्टैंडअलोन विकल्पों के लिए चेकबॉक्स या एक-दूसरे से अलग विकल्पों के ग्रुप के लिए रेडियो बटन का इस्तेमाल किया जा सकता है. पांचवें चित्र में एक सबमेन्यू दिखाया गया है. इसमें ऐसे आइटम हैं जिन्हें रेडियो बटन की मदद से चुना जा सकता है.
<item> एलिमेंट में android:checkable एट्रिब्यूट का इस्तेमाल करके, अलग-अलग मेन्यू आइटम के लिए, चुने जा सकने की सुविधा तय की जा सकती है. इसके अलावा, <group> एलिमेंट में android:checkableBehavior एट्रिब्यूट का इस्तेमाल करके, पूरे ग्रुप के लिए यह सुविधा तय की जा सकती है. उदाहरण के लिए, इस मेन्यू ग्रुप के सभी आइटम को रेडियो बटन की मदद से चुना जा सकता है:
<?xml version="1.0" encoding="utf-8"?> <menu xmlns:android="http://schemas.android.com/apk/res/android"> <group android:checkableBehavior="single"> <item android:id="@+id/red" android:title="@string/red" /> <item android:id="@+id/blue" android:title="@string/blue" /> </group> </menu>
android:checkableBehavior एट्रिब्यूट में इनमें से कोई एक वैल्यू सबमिट की जा सकती है:
single- ग्रुप में से सिर्फ़ एक आइटम को चुना जा सकता है. इससे रेडियो बटन बन जाते हैं.
all- सभी आइटम पर सही का निशान लगाया जा सकता है. ऐसा करने पर, उन आइटम के बगल में चेकबॉक्स दिखते हैं.
none- कोई भी आइटम चुना नहीं जा सकता.
<item> एलिमेंट में android:checked एट्रिब्यूट का इस्तेमाल करके, किसी आइटम पर डिफ़ॉल्ट रूप से सही का निशान लगाया जा सकता है. साथ ही, setChecked() तरीके का इस्तेमाल करके, कोड में बदलाव किया जा सकता है.
जब कोई ऐसा आइटम चुना जाता है जिसे चुना जा सकता है, तो सिस्टम आपके आइटम के चुने गए कॉलबैक तरीके को कॉल करता है, जैसे कि onOptionsItemSelected().
यहां चेकबॉक्स की स्थिति सेट की जाती है, क्योंकि चेकबॉक्स या रेडियो बटन की स्थिति अपने-आप नहीं बदलती. isChecked() का इस्तेमाल करके, आइटम की मौजूदा स्थिति के बारे में क्वेरी की जा सकती है. यह स्थिति, उपयोगकर्ता के आइटम को चुनने से पहले की होती है. इसके बाद, setChecked() का इस्तेमाल करके, आइटम की चुनी गई स्थिति सेट की जा सकती है. इसका उदाहरण यहां दिया गया है:
Kotlin
override fun onOptionsItemSelected(item: MenuItem): Boolean { return when (item.itemId) { R.id.vibrate, R.id.dont_vibrate -> { item.isChecked = !item.isChecked true } else -> super.onOptionsItemSelected(item) } }
Java
@Override public boolean onOptionsItemSelected(MenuItem item) { switch (item.getItemId()) { case R.id.vibrate: case R.id.dont_vibrate: if (item.isChecked()) item.setChecked(false); else item.setChecked(true); return true; default: return super.onOptionsItemSelected(item); } }
अगर चेक किए जाने की स्थिति को इस तरह सेट नहीं किया जाता है, तो उपयोगकर्ता के चुनने पर, चेकबॉक्स या रेडियो बटन की दिखने वाली स्थिति में कोई बदलाव नहीं होता. स्थिति सेट करने पर, गतिविधि में आइटम की चुने गए स्टेटस को सेव किया जाता है, ताकि जब उपयोगकर्ता बाद में मेन्यू खोले, तो आपने जो चुना हुआ स्टेटस सेट किया है वह दिखे.
किसी इंटेंट के आधार पर मेन्यू आइटम जोड़ना
कभी-कभी, आपको किसी मेन्यू आइटम से Intent का इस्तेमाल करके कोई गतिविधि शुरू करनी होती है. भले ही, वह गतिविधि आपके ऐप्लिकेशन में हो या किसी दूसरे ऐप्लिकेशन में. जब आपको उस इंटेंट का पता हो जिसका इस्तेमाल करना है और आपके पास कोई ऐसा मेन्यू आइटम हो जो इंटेंट को शुरू करता हो, तो startActivity() के साथ इंटेंट को तब चलाया जा सकता है, जब आइटम चुने जाने पर कॉलबैक का सही तरीका इस्तेमाल किया जा रहा हो. जैसे, onOptionsItemSelected() कॉलबैक.
हालांकि, अगर आपको यह पक्का नहीं है कि उपयोगकर्ता के डिवाइस में कोई ऐसा ऐप्लिकेशन है जो इंटेंट को मैनेज करता है, तो उसे ट्रिगर करने वाला मेन्यू आइटम जोड़ने पर, हो सकता है कि वह काम न करे. ऐसा इसलिए, क्योंकि हो सकता है कि इंटेंट किसी गतिविधि को पूरा न करे. इस समस्या को हल करने के लिए, Android आपको अपने मेन्यू में डाइनैमिक तौर पर मेन्यू आइटम जोड़ने की सुविधा देता है. ऐसा तब होता है, जब Android को डिवाइस पर ऐसी गतिविधियां मिलती हैं जो आपके इंटेंट को मैनेज करती हैं.
इंटेंट स्वीकार करने वाली उपलब्ध गतिविधियों के आधार पर मेन्यू आइटम जोड़ने के लिए, यह तरीका अपनाएं:
- कैटगरी के साथ किसी इंटेंट की जानकारी दें. इसके लिए,
CATEGORY_ALTERNATIVEयाCATEGORY_SELECTED_ALTERNATIVEया दोनों में से किसी एक कैटगरी का इस्तेमाल करें. साथ ही, अन्य ज़रूरी शर्तों को भी पूरा करें. Menu.addIntentOptions()पर कॉल करें. इसके बाद, Android उन सभी ऐप्लिकेशन को खोजता है जो इंटेंट को पूरा कर सकते हैं और उन्हें आपके मेन्यू में जोड़ता है.
अगर कोई ऐसा ऐप्लिकेशन इंस्टॉल नहीं है जो इंटेंट के मुताबिक हो, तो कोई मेन्यू आइटम नहीं जोड़ा जाता.
यह नीचे दिए गए उदाहरण में दिखाया गया है:
Kotlin
override fun onCreateOptionsMenu(menu: Menu): Boolean { super.onCreateOptionsMenu(menu) // Create an Intent that describes the requirements to fulfill, to be // included in the menu. The offering app must include a category value // of Intent.CATEGORY_ALTERNATIVE. val intent = Intent(null, dataUri).apply { addCategory(Intent.CATEGORY_ALTERNATIVE) } // Search and populate the menu with acceptable offering apps. menu.addIntentOptions( R.id.intent_group, // Menu group to which new items are added. 0, // Unique item ID (none). 0, // Order for the items (none). this.componentName, // The current activity name. null, // Specific items to place first (none). intent, // Intent created above that describes the requirements. 0, // Additional flags to control items (none). null) // Array of MenuItems that correlate to specific items (none). return true }
Java
@Override public boolean onCreateOptionsMenu(Menu menu){ super.onCreateOptionsMenu(menu); // Create an Intent that describes the requirements to fulfill, to be // included in the menu. The offering app must include a category value // of Intent.CATEGORY_ALTERNATIVE. Intent intent = new Intent(null, dataUri); intent.addCategory(Intent.CATEGORY_ALTERNATIVE); // Search and populate the menu with acceptable offering apps. menu.addIntentOptions( R.id.intent_group, // Menu group to which new items are added. 0, // Unique item ID (none). 0, // Order for the items (none). this.getComponentName(), // The current activity name. null, // Specific items to place first (none). intent, // Intent created above that describes the requirements. 0, // Additional flags to control items (none). null); // Array of MenuItems that correlate to specific items (none). return true; }
जो गतिविधि, तय किए गए इंटेंट से मैच करने वाला इंटेंट फ़िल्टर उपलब्ध कराती है उसके लिए एक मेन्यू आइटम जोड़ा जाता है. इसमें, इंटेंट फ़िल्टर के android:label में मौजूद वैल्यू को मेन्यू आइटम के टाइटल के तौर पर और ऐप्लिकेशन आइकॉन को मेन्यू आइटम के आइकॉन के तौर पर इस्तेमाल किया जाता है. addIntentOptions() तरीका, मेन्यू में जोड़े गए आइटम की संख्या दिखाता है.
अपनी गतिविधि को दूसरे मेन्यू में जोड़ने की अनुमति देना
अपनी गतिविधि की सेवाएं दूसरे ऐप्लिकेशन को ऑफ़र की जा सकती हैं, ताकि आपके ऐप्लिकेशन को दूसरे ऐप्लिकेशन के मेन्यू में शामिल किया जा सके. इसके लिए, आपको ऊपर बताई गई भूमिकाओं को बदलना होगा.
अन्य ऐप्लिकेशन मेन्यू में शामिल करने के लिए, इंटेंट फ़िल्टर को हमेशा की तरह तय करें. हालांकि, इंटेंट फ़िल्टर कैटगरी के लिए, CATEGORY_ALTERNATIVE या CATEGORY_SELECTED_ALTERNATIVE वैल्यू या दोनों शामिल करें. यह नीचे दिए गए उदाहरण में दिखाया गया है:
<intent-filter label="@string/resize_image"> ... <category android:name="android.intent.category.ALTERNATIVE" /> <category android:name="android.intent.category.SELECTED_ALTERNATIVE" /> ... </intent-filter>
इंटेंट और इंटेंट फ़िल्टर में, इंटेंट फ़िल्टर लिखने के बारे में ज़्यादा पढ़ें.