Menü ekleme

Oluşturma yöntemini deneyin
Jetpack Compose, Android için önerilen kullanıcı arayüzü araç setidir. Compose'da bileşenleri nasıl ekleyeceğinizi öğrenin.

Menüler, birçok uygulama türünde yaygın olarak kullanılan bir kullanıcı arayüzü bileşenidir. Tanıdık ve tutarlı bir kullanıcı deneyimi sağlamak için etkinliklerinizde kullanıcı işlemlerini ve diğer seçenekleri sunmak üzere Menu API'lerini kullanın.

Taşma menüsü örneğini gösteren resim
Şekil 1. Taşma menüsü simgesinin altında görünen ve simgeye dokunulduğunda tetiklenen bir menü.

Bu dokümanda, Android'in tüm sürümlerinde üç temel menü türü veya işlem sunusunun nasıl oluşturulacağı gösterilmektedir:

Seçenekler menüsü ve uygulama çubuğu
Seçenekler menüsü, bir etkinlik için menü öğelerinin birincil koleksiyonudur. "Ara", "E-posta oluştur" ve "Ayarlar" gibi, uygulama üzerinde küresel etkisi olan işlemleri burada ekleyebilirsiniz.

Seçenekler menüsü oluşturma bölümüne bakın.

İçerik menüsü ve bağlamsal işlem modu
İçerik menüsü, kullanıcı bir öğeye dokunup basılı tuttuğunda görünen bir kayan menüdür. Seçili içeriği veya bağlam çerçevesini etkileyen işlemler sağlar.

Bağlamsal işlem modu, seçilen içeriği etkileyen işlem öğelerini ekranın üst kısmındaki bir çubukta görüntüler ve kullanıcının birden fazla öğe seçmesine olanak tanır.

İçerik menüsü oluşturma bölümüne bakın.

Pop-up menü
Pop-up menüde, menüyü çağıran görünüme sabitlenmiş öğelerin dikey bir listesi gösterilir. Belirli içerikle ilgili çok sayıda işlem sağlamak veya bir komutun ikinci bölümü için seçenekler sunmak açısından idealdir. Bir pop-up menüdeki işlemler, karşılık gelen içeriği doğrudan etkilemez. İçeriğe dayalı işlemler, bunun içindir. Pop-up menü daha ziyade, etkinliğinizdeki içeriklerin bölgeleriyle ilgili genişletilmiş işlemler içindir.

Pop-up menü oluşturma bölümüne bakın.

XML'de bir menü tanımlayın

Android, tüm menü türlerinde menü öğelerini tanımlamak için standart bir XML biçimi sağlar. Etkinliğinizin kodunda bir menü oluşturmak yerine bir menü ve bu menünün tüm öğelerini bir XML menü kaynağında tanımlayın. Daha sonra, etkinliğinizde veya parçanızda menü kaynağını Menu nesnesi olarak yükleyerek şişirebilirsiniz.

Aşağıdaki nedenlerle bir menü kaynağı kullanmak iyi bir uygulamadır:

  • Menü yapısını XML olarak görselleştirmek daha kolaydır.
  • Menü içeriğini uygulamanızın davranış kodundan ayırır.
  • Uygulama kaynakları çerçevesinden yararlanarak farklı platform sürümleri, ekran boyutları ve diğer yapılandırmalar için alternatif menü yapılandırmaları oluşturmanıza imkan tanır.

Menü tanımlamak için projenizin res/menu/ dizininde bir XML dosyası oluşturun ve aşağıdaki öğelerle menüyü derleyin:

<menu>
Menü öğeleri için kapsayıcı olan bir Menu tanımlar. <menu> öğesi, dosyanın kök düğümü olmalıdır ve bir veya daha fazla <item> ve <group> öğesini barındırabilir.
<item>
Menüdeki tek bir öğeyi temsil eden bir MenuItem oluşturur. Bu öğe, alt menü oluşturmak için iç içe yerleştirilmiş bir <menu> öğesi içerebilir.
<group>
<item> öğeleri için isteğe bağlı, görünmez bir kapsayıcı. Menü öğelerini, etkin durum ve görünürlük gibi özellikleri paylaşacak şekilde kategorilere ayırmanızı sağlar. Daha fazla bilgi için Menü grubu oluşturma bölümüne bakın.

game_menu.xml adlı örnek bir menü aşağıdaki gibidir:

<?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> öğesi, bir öğenin görünümünü ve davranışını tanımlamak için kullanabileceğiniz birkaç özelliği destekler. Önceki menüde yer alan öğeler aşağıdaki özellikleri içerir:

android:id
Öğeye özgü olan ve kullanıcı seçtiğinde uygulamanın öğeyi tanımasını sağlayan kaynak kimliği.
android:icon
Öğenin simgesi olarak kullanılacak bir çizime referans.
android:title
Öğenin başlığı olarak kullanılacak bir dizeye referans.
android:showAsAction
Bu öğenin uygulama çubuğunda işlem öğesi olarak ne zaman ve nasıl görüneceğine dair spesifikasyon.

Bunlar kullandığınız en önemli özellikler olsa da kullanabileceğiniz daha birçok özellik vardır. Desteklenen tüm özellikler hakkında bilgi edinmek için Menü kaynağı belgelerine bakın.

<item> öğesinin alt öğesi olarak <menu> öğesi ekleyerek herhangi bir menüdeki öğeye alt menü ekleyebilirsiniz. Alt menüler, PC uygulamasının menü çubuğundaki öğeler (ör. Dosya, Düzenle ve Görünüm gibi) konulara göre düzenlenebilen birçok işleve sahip olduğunda kullanışlıdır. Aşağıdaki örneğe bakın:

<?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>

Etkinliğinizdeki menüyü kullanmak için menü kaynağını _inflate_ yaparak XML kaynağını MenuInflater.inflate() ile programlanabilir bir nesneye dönüştürün. Aşağıdaki bölümlerde, her bir menü türü için bir menüyü nasıl genişleteceğiniz gösterilmektedir.

Seçenekler menüsü oluşturma

Şekil 1'de gösterilen gibi, seçenekler menüsünde mevcut etkinlik bağlamıyla alakalı işlemleri ve "Arama", "E-posta oluştur" ve "Ayarlar" gibi diğer seçenekleri eklersiniz.

Google E-Tablolar uygulamasının uygulama çubuğunu gösteren resim
Şekil 2. Taşma işlemi düğmesi de dahil olmak üzere çeşitli düğmeleri gösteren Google E-Tablolar uygulaması.

Seçenekler menüsüne ait öğeleri Activity alt sınıfınızdan veya bir Fragment alt sınıfından bildirebilirsiniz. Hem etkinliğiniz hem de parçalarınız seçenekler menüsü için öğeler belirtiyorsa öğeler kullanıcı arayüzünde birleştirilir. Önce etkinliğin öğeleri, ardından parçaların etkinliğe eklendiği sırayla her bir parçanın öğeleri görünür. Gerekirse, taşımanız gereken her bir <item> için menü öğelerini android:orderInCategory özelliğiyle yeniden sıralayabilirsiniz.

Bir etkinliğin seçenekler menüsünü belirtmek için onCreateOptionsMenu() değerini geçersiz kılın. Parçalar kendi onCreateOptionsMenu() geri çağırmalarını sağlar. Bu yöntemde, XML olarak tanımlanan menü kaynağınızı, geri çağırmada sağlanan Menu değerine genişletebilirsiniz. Bu, aşağıdaki örnekte gösterilmiştir:

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;
}

Ayrıca add() kullanarak menü öğeleri ekleyebilir ve MenuItem API'leriyle özelliklerini düzeltmek için öğeleri findItem() ile alabilirsiniz.

Tıklama etkinliklerini işleme

Kullanıcı, uygulama çubuğundaki işlem öğeleri de dahil olmak üzere seçenekler menüsünden bir öğe seçtiğinde sistem, etkinliğinizin onOptionsItemSelected() yöntemini çağırır. Bu yöntem, seçilen MenuItem için geçerlidir. Öğeyi tanımlamak için getItemId() yöntemini çağırın. Bu çağrı, menü kaynağındaki android:id özelliği tarafından veya add() yöntemine verilen bir tam sayıyla menü öğesi için benzersiz kimliği döndürür. Uygun işlemi gerçekleştirmek için bu kimliği bilinen menü öğeleriyle eşleştirebilirsiniz.

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);
    }
}

Bir menü öğesini başarıyla tamamladıktan sonra true tuşuna basın. Menü öğesiyle siz ilgilenmiyorsanız üst sınıf onOptionsItemSelected() uygulamasını çağırın. Varsayılan uygulama "false" değerini döndürür.

Etkinliğiniz parçalar içeriyorsa sistem, ilk olarak etkinlik için onOptionsItemSelected() çağrısı yapar. Ardından, her parça true değerini döndürene veya tüm parçalar çağrılana kadar, parçaların eklendiği sırayla her bir parça için çağrıda bulunur.

Çalışma zamanında menü öğelerini değiştirin

Sistem onCreateOptionsMenu() işlevini çağırdıktan sonra, doldurduğunuz Menu öğesinin bir örneğini saklar ve menü geçersiz kılınmadığı sürece onCreateOptionsMenu() işlevini tekrar çağırmaz. Ancak onCreateOptionsMenu() öğesini yalnızca ilk menü durumunu oluşturmak için kullanın ve etkinlik yaşam döngüsü boyunca değişiklik yapmak için kullanmayın.

Etkinlik yaşam döngüsü sırasında gerçekleşen etkinliklere dayalı olarak seçenekler menüsünü onPrepareOptionsMenu() yönteminde değiştirebilirsiniz. Bu yöntem, Menu nesnesini size mevcut olduğu şekliyle iletir. Böylece bu nesneyi öğe ekleyerek, kaldırarak veya devre dışı bırakarak değiştirebilirsiniz. Parçalar bir onPrepareOptionsMenu() geri çağırma da sağlar.

Uygulama çubuğunda menü öğeleri sunulduğunda seçenekler menüsünün her zaman açık olduğu kabul edilir. Bir etkinlik meydana geldiğinde ve menü güncellemesi gerçekleştirmek istediğinizde, invalidateOptionsMenu() çözümünü kullanarak sistemin onPrepareOptionsMenu() yöntemini çağırmasını isteyin.

İçerik menüsü oluşturma

Kayan içerik menüsünü gösteren resim
Şekil 3. Kayan içerik menüsü.

İçerik menüsü, kullanıcı arayüzündeki belirli bir öğeyi veya bağlam çerçevesini etkileyen işlemler sunar. Herhangi bir görünüm için içerik menüsü sağlayabilirsiniz ancak bu menüler çoğunlukla kullanıcının her öğe üzerinde doğrudan işlem yapabileceği RecylerView veya diğer görünüm koleksiyonlarındaki öğeler için kullanılır.

Bağlama dayalı işlemler sağlamanın iki yolu vardır:

  • Kayan içerik menüsünde. Kullanıcı, içerik menüsünü desteklediğini beyan eden bir görünüme dokunup basılı tuttuğunda menü, iletişim kutusuna benzer şekilde menü öğelerinden oluşan kayan bir liste olarak görüntülenir. Kullanıcılar tek seferde bir öğe üzerinde içeriğe dayalı bir işlem gerçekleştirebilir.
  • Bağlamsal işlem modunda. Bu mod, seçili öğeleri etkileyen işlem öğeleriyle birlikte ekranın üst kısmında bir bağlamsal işlem çubuğu veya CAB görüntüleyen ActionMode sistem uygulamasıdır. Uygulamanız destekliyorsa kullanıcılar bu mod etkin durumdayken birden fazla öğe üzerinde aynı anda işlem gerçekleştirebilir.

Kayan içerik menüsü oluşturma

Kayan içerik menüsü sağlamak için aşağıdakileri yapın:

  1. registerForContextMenu() yöntemini çağırıp View ileterek içerik menüsünün ilişkilendirildiği View bilgisini kaydedin.

    Etkinliğiniz bir RecyclerView kullanıyorsa ve her öğenin aynı içerik menüsünü sunmasını istiyorsanız RecyclerView öğesini registerForContextMenu() öğesine ileterek içerik menüsü için tüm öğeleri kaydedin.

  2. Activity veya Fragment üzerinde onCreateContextMenu() yöntemini uygulayın.

    Kayıtlı görünüm bir "dokunup basılı tutma" etkinliği aldığında, sistem onCreateContextMenu() yönteminizi çağırır. Burası, aşağıdaki örnekte olduğu gibi, genellikle bir menü kaynağını şişirerek menü öğelerini tanımladığınız yerdir:

    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, bir menü kaynağından içerik menüsünü genişletmenizi sağlar. Geri çağırma yöntemi parametreleri, kullanıcının seçtiği View ve seçilen öğe hakkında ek bilgi sağlayan ContextMenu.ContextMenuInfo nesnesini içerir. Etkinliğinizde, her biri farklı içerik menüsü sunan birkaç görünüm varsa hangi içerik menüsünü genişleteceğinizi belirlemek için bu parametreleri kullanabilirsiniz.

  3. Aşağıdaki örnekte gösterildiği gibi onContextItemSelected() uygulayın. Kullanıcı bir menü seçeneği seçtiğinde, uygun işlemi gerçekleştirebilmeniz için sistem bu yöntemi çağırır.

    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() yöntemi, seçilen menü öğesinin kimliğini sorgular. Bu kimliği, XML olarak menü tanımlama bölümünde gösterildiği gibi XML'de her menü öğesine android:id özelliğini kullanarak atarsınız.

    Bir menü öğesini başarıyla tamamladıktan sonra true tuşuna basın. Menü öğesiyle siz ilgilenmiyorsanız menü öğesini üst sınıf uygulamasına geçirin. Etkinliğiniz parçalar içeriyorsa etkinlik önce bu geri çağırmayı alır. İşlenmediğinde üst sınıfı çağırarak sistem, etkinliği true veya false döndürülene kadar her parçanın eklendiği sırayla her parçanın ilgili geri çağırma yöntemine iletir. Activity ve android.app.Fragment için varsayılan uygulamalar false değerini döndürür. Bu nedenle, işlenmediğinde her zaman üst sınıfı çağırın.

Bağlamsal işlem modunu kullanın

Bağlamsal işlem modu, kullanıcı etkileşimini içeriğe dayalı işlemler gerçekleştirmeye odaklayan bir ActionMode sistem uygulamasıdır. Kullanıcı bir öğe seçerek bu modu etkinleştirdiğinde, kullanıcının seçili öğelerde gerçekleştirebileceği işlemleri göstermek için ekranın üst kısmında bir bağlamsal işlem çubuğu görünür. Uygulamanız destekliyorsa kullanıcı, bu mod etkinleştirildiğinde birden fazla öğe seçebilir ve öğelerin seçimini kaldırıp etkinlik içinde gezinmeye devam edebilir. İşlem modu devre dışı bırakılır ve kullanıcı tüm öğelerin seçimini kaldırdığında, Geri düğmesine veya çubuğun sol tarafındaki Bitti işlemine dokunduğunda içeriğe dayalı işlem çubuğu kaybolur.

Bağlamsal işlemler sağlayan görünümlerde, genellikle şu iki etkinlikten biri veya her ikisi de gerçekleştiğinde içeriğe dayalı işlem modunu çağırırsınız:

  • Kullanıcı görünüme dokunup basılı tutar.
  • Kullanıcı, görünüm içinde bir onay kutusu veya benzer bir kullanıcı arayüzü bileşeni seçer.

Uygulamanızın bağlamsal işlem modunu nasıl çağırdığı ve her işlemin davranışını nasıl tanımladığı, tasarımınıza bağlıdır. İki tasarım vardır:

  • Bağımsız, rastgele görüntülemelerle ilgili bağlama dayalı işlemler için.
  • RecyclerView içindeki öğe gruplarıyla ilgili toplu bağlamsal işlemler için kullanıcının birden fazla öğe seçip hepsinde işlem gerçekleştirmesini sağlar.

Aşağıdaki bölümlerde her bir senaryo için gereken kurulum açıklanmaktadır.

Bağımsız görünümler için bağlamsal işlem modunu etkinleştir

Bağlamsal işlem modunu yalnızca kullanıcı belirli görünümleri seçtiğinde çağırmak istiyorsanız aşağıdakileri yapın:

  1. ActionMode.Callback arayüzünü aşağıdaki örnekte gösterildiği gibi uygulayın. Geri çağırma yöntemlerinde, bağlamsal işlem çubuğu için işlemler belirtebilir, işlem öğelerindeki tıklama etkinliklerine yanıt verebilir ve işlem modu için diğer yaşam döngüsü olaylarını işleyebilirsiniz.

    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;
            }
        };
        

    Bu etkinlik geri çağırma işlevleri, seçenekler menüsünün geri çağırmalarıyla neredeyse bire bir aynıdır. Tek fark, bunların her birinin etkinlikle ilişkili ActionMode nesnesini de iletmesidir. ActionMode API'lerini CAB'de çeşitli değişiklikler yapmak için kullanabilirsiniz. Örneğin setTitle() ve setSubtitle() ile başlık ve alt başlığı revize edebilirsiniz. Bu, kaç tane öğenin seçildiğini gösterir.

    Yukarıdaki örnek, işlem modu kaldırıldığında actionMode değişkenini null olarak ayarlar. Sonraki adımda, özelliğin nasıl başlatıldığını ve üye değişkenini etkinliğinize veya parçanıza kaydetmenin nasıl yararlı olabileceğini görün.

  2. Çubuğun gösterilmesini istediğinizde (ör. kullanıcı ekrana dokunup basılı tuttuğunuzda) startActionMode() numaralı telefonu arayın.

    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() çağrısı yaptığınızda sistem, oluşturulan ActionMode değerini döndürür. Bunu bir üye değişkenine kaydederek bağlamsal işlem çubuğunda diğer etkinliklere göre değişiklik yapabilirsiniz. Yukarıdaki örnekte ActionMode, eylem moduna başlamadan önce üyenin boş olup olmadığını kontrol ederek ActionMode örneğinin zaten etkin olması durumunda yeniden oluşturulmamasını sağlamak için kullanılır.

Pop-up menü oluştur

Gmail uygulamasında, sağ üstteki taşma düğmesine sabitlenmiş bir pop-up menüyü gösteren resim.
Şekil 4. Gmail uygulamasında, sağ üst köşedeki taşma düğmesine sabitlenmiş bir pop-up menü.

PopupMenu, View öğesine sabitlenmiş kalıcı bir menüdür. Yer varsa sabit görünümünün altında, varsa görünümün üzerinde görünür. Aşağıdakiler açısından yararlıdır:

  • Şekil 4'te gösterilen, Gmail'in e-posta üstbilgileri gibi belirli bir içerikle ilgili işlemler için taşma stili bir menü sunma.
  • Farklı Ekle seçeneklerine sahip bir pop-up menü açan, Ekle işaretli bir düğme gibi bir komut cümlesinin ikinci bir bölümünü sağlama.
  • Kalıcı seçimi korumayan Spinner benzeri bir menü sunma.

Menünüzü XML olarak tanımlarsanız pop-up menüyü şu şekilde gösterebilirsiniz:

  1. Menünün bağlı olduğu mevcut Context uygulamasını ve View öğesini alan kurucusuyla bir PopupMenu örneği oluşturun.
  2. Menü kaynağınızı PopupMenu.getMenu() tarafından döndürülen Menu nesnesine genişletmek için MenuInflater kullanın.
  3. Şu numaraya telefon et: PopupMenu.show().

Örneğin, burada bir pop-up menü gösteren düğmeyi görebilirsiniz:

<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" />

Ardından etkinlik, aşağıdaki gibi bir pop-up menü gösterebilir:

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();
});

Kullanıcı bir öğe seçtiğinde veya menü alanının dışına dokunduğunda menü kapatılır. PopupMenu.OnDismissListener kullanarak kapatma etkinliğini dinleyebilirsiniz.

Tıklama etkinliklerini işleme

Kullanıcı menü öğesi seçtiğinde bir işlem gerçekleştirmek için PopupMenu.OnMenuItemClickListener arayüzünü uygulayın ve setOnMenuItemclickListener() yöntemini çağırarak PopupMenu cihazınıza kaydedin. Kullanıcı bir öğe seçtiğinde sistem, arayüzünüzde onMenuItemClick() geri çağırma işlevini çağırır.

Bu, aşağıdaki örnekte gösterilmiştir:

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;
    }
}

Menü grubu oluşturun

Menü grubu, belirli ortak özellikleri olan menü öğelerinden oluşan bir koleksiyondur. Bir grupla şunları yapabilirsiniz:

  • setGroupVisible() kullanarak tüm öğeleri gösterin veya gizleyin.
  • setGroupEnabled() özelliğini kullanarak tüm öğeleri etkinleştirin veya devre dışı bırakın.
  • setGroupCheckable() kullanarak tüm öğelerin kontrol edilebilir olup olmadığını belirtin.

<item> öğelerini menü kaynağınızdaki bir <group> öğesinin içine yerleştirerek veya add() yöntemiyle bir grup kimliği belirterek grup oluşturabilirsiniz.

Aşağıda, grup içeren bir menü kaynağı örneği verilmiştir:

<?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>

Gruptaki öğeler ilk öğeyle aynı düzeyde görünür. Menüdeki üç öğenin hepsi kardeş öğedir. Bununla birlikte, grup kimliğine ve önceki yöntemleri kullanarak gruptaki iki öğenin özelliklerini değiştirebilirsiniz. Ayrıca sistem, gruplandırılmış öğeleri hiçbir zaman ayırmaz. Örneğin, her öğe için android:showAsAction="ifRoom" belirtirseniz her ikisi de işlem çubuğunda veya her ikisi de işlem taşmasında görünür.

İşaretlenebilir menü öğeleri kullanın

Şekil 5. İşaretlenebilir öğelerin yer aldığı bir alt menü.

Menü; seçenekleri açmak ve kapatmak, bağımsız seçenekler için bir onay kutusu kullanmak veya karşılıklı olarak birbirini dışlayan seçenek grupları için radyo düğmeleri kullanmak için bir arayüz olarak yararlı olabilir. Şekil 5'te radyo düğmeleriyle işaretlenebilen öğeler içeren bir alt menü gösterilmiştir.

İşaretlenebilir davranışı, <item> öğesinde android:checkable özelliğini kullanarak tek tek menü öğeleri veya <group> öğesinde android:checkableBehavior özelliğiyle bir grubun tamamı için tanımlayabilirsiniz. Örneğin, bu menü grubundaki tüm öğeler bir radyo düğmesiyle işaretlenebilir:

<?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 özelliği aşağıdakilerden birini kabul eder:

single
Gruptan yalnızca bir öğe işaretlenebilir ve bu da radyo düğmelerine neden olur.
all
Tüm öğeler işaretlenebilir. Bunun sonucunda onay kutuları gösterilir.
none
İşaretlenebilir öğe yok.

<item> öğesindeki android:checked özelliğini kullanarak bir öğeye varsayılan işaretli durum uygulayabilir ve setChecked() yöntemini kullanarak bunu kodda değiştirebilirsiniz.

İşaretlenebilir bir öğe seçildiğinde, sistem öğe için seçtiğiniz ilgili geri çağırma yöntemini (ör. onOptionsItemSelected()) çağırır. Bir onay kutusu veya radyo düğmesi, durumunu otomatik olarak değiştirmez. Bu nedenle, onay kutusunun durumunu burada ayarlarsınız. isChecked() ile öğenin mevcut durumunu (kullanıcının seçmeden önceki durumunu) sorgulayabilir ve ardından setChecked() ile işaretli durumu ayarlayabilirsiniz. Bu, aşağıdaki örnekte gösterilmektedir:

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);
    }
}

İşaretli durumu bu şekilde ayarlamazsanız onay kutusunun veya radyo düğmesinin görünür durumu kullanıcı tarafından seçildiğinde değişmez. Durumu ayarladığınızda etkinlik, öğenin işaretli durumunu korur. Böylece kullanıcı menüyü daha sonra açtığında, ayarladığınız işaretli durum görünür olur.

Niyete göre menü öğeleri ekleyin

Bazen bir menü öğesinin Intent kullanarak bir etkinlik başlatmasını istersiniz. Bu, uygulamanızdaki bir etkinlik veya başka bir uygulamadaki bir etkinlik olabilir. Kullanmak istediğiniz amacı bildiğinizde ve amacı başlatan belirli bir menü öğeniz olduğunda, niyeti startActivity() ile yürütebilirsiniz. Bunun için, öğe için seçilen uygun geri çağırma yöntemini (ör. onOptionsItemSelected() geri çağırma) kullanabilirsiniz.

Ancak, kullanıcının cihazının, amacı işleyen bir uygulama içerdiğinden emin değilseniz söz konusu işlevi çağıran bir menü öğesinin eklenmesi, menü öğesinin çalışmamasına yol açabilir (çünkü amaç bir etkinliğe çözümlenemeyebilir). Android, bu sorunu çözmek için cihazda amacınıza uygun etkinlikler bulduğunda menünüze dinamik olarak menü öğeleri eklemenize olanak tanır.

Belirli bir amacı kabul eden mevcut etkinliklere göre menü öğeleri eklemek için aşağıdakileri yapın:

  1. CATEGORY_ALTERNATIVE veya CATEGORY_SELECTED_ALTERNATIVE ya da her ikisi kategorisiyle ve diğer gereksinimlerle bir amaç tanımlayın.
  2. Menu.addIntentOptions() numaralı telefonu arayın. Android, daha sonra bu amacı gerçekleştirebilecek uygulamaları arar ve menünüze ekler.

Amacı karşılayan yüklü uygulama yoksa herhangi bir menü öğesi eklenmez.

Bu, aşağıdaki örnekte gösterilmiştir:

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;
}

Amaç tanımıyla eşleşen bir amaç filtresi sağlayan bulunan her etkinlik için bir menü öğesi eklenir. Bu öğede, menü öğesi başlığı olarak amaç filtresinin android:label değeri ve menü öğesi simgesi uygulama simgesi kullanılır. addIntentOptions() yöntemi, eklenen menü öğelerinin sayısını döndürür.

Etkinliğinizin diğer menülere eklenmesine izin verin

Daha önce açıklanan rolleri tersine çevirerek uygulamanızın diğer uygulamaların menüsüne eklenmesi için etkinliğinize ilişkin hizmetleri diğer uygulamalara sunabilirsiniz.

Diğer uygulama menülerine dahil etmek için her zamanki gibi bir amaç filtresi tanımlayın, ancak amaç filtresi kategorisi için CATEGORY_ALTERNATIVE veya CATEGORY_SELECTED_ALTERNATIVE değerlerini ya da her ikisini birden ekleyin. Bu, aşağıdaki örnekte gösterilmiştir:

<intent-filter label="@string/resize_image">
    ...
    <category android:name="android.intent.category.ALTERNATIVE" />
    <category android:name="android.intent.category.SELECTED_ALTERNATIVE" />
    ...
</intent-filter>

Amaç filtreleri yazma hakkında daha fazla bilgiyi Amaçlar ve amaç filtreleri bölümünde bulabilirsiniz.