Menü ekleme

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

Menüler, birçok uygulama türünde yaygın bir kullanıcı arayüzü bileşenidir. Tanıdık ve tutarlı bir kullanıcı deneyimi sunmak 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, simgeye dokunulmasıyla tetiklenen bir menü.

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

Seçenekler menüsü ve uygulama çubuğu
Seçenekler menüsü, bir etkinlik için menü öğelerinden oluşan birincil koleksiyondur. "Arama", "E-posta oluştur" ve "Ayarlar" gibi uygulama üzerinde küresel etkisi olan işlemleri buraya yerleştirirsiniz.

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 kayan bir menüdür. Seçilen içeriği veya bağlam çerçevesini etkileyen işlemler sunar.

Bağlamsal işlem modu, seçilen içeriği etkileyen işlem öğelerini ekranın üst kısmındaki bir çubukta gösterir 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 bağlı öğelerin dikey bir listesi gösterilir. Belirli içerikle ilgili işlemler taşması veya bir komutun ikinci bölümü için seçenekler sağlamak açısından kullanışlıdır. Pop-up menüsündeki işlemler, ilgili içeriği doğrudan etkilemez. Bağlamsal işlemler bu bağlamda gerçekleştirilir. Pop-up menü, daha ziyade etkinliğinizdeki içeriğin bölgeleriyle ilgili olan genişletilmiş işlemler içindir.

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

XML'de menü tanımla

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üyü ve tüm öğelerini bir XML menü kaynağında tanımlayın. Daha sonra etkinliğinizde veya parçanızda menü kaynağını artırıp bir Menu nesnesi olarak yükleyebilirsiniz.

Bir menü kaynağının kullanılması aşağıdaki nedenlerden dolayı iyi bir uygulamadır:

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

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

<menu>
Menü öğeleri için kapsayıcı olan bir Menu tanımlar. <menu> öğesi, dosyanın kök düğümü olmalıdır ve en az bir <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.

Aşağıda game_menu.xml adlı örnek bir menü verilmiştir:

<?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 çeşitli özellikleri 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 bir kaynak kimliği.
android:icon
Öğenin simgesi olarak kullanılacak bir çekilebilirliğe yapılan referans.
android:title
Öğenin başlığı olarak kullanılacak bir dizeye referanstır.
android:showAsAction
Bu öğenin uygulama çubuğunda işlem öğesi olarak ne zaman ve nasıl görüneceğiyle ilgili spesifikasyon.

Bunlar kullandığınız en önemli özellikler olsa da daha pek çok özellik mevcuttur. Desteklenen tüm özellikler hakkında bilgi için Menü kaynağı belgelerine bakın.

<item> alt öğesi olarak bir <menu> öğesi ekleyerek herhangi bir menüdeki bir öğeye alt menü ekleyebilirsiniz. Uygulamanızda konulara göre düzenlenebilecek birçok işlev (ör. Dosya, Düzenle ve Görünüm) olduğunda alt menüler 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_ kullanarak XML kaynağını MenuInflater.inflate() ile programlanabilir bir nesneye dönüştürün. Aşağıdaki bölümlerde, her menü türü için bir menünün nasıl şişirileceği gösterilmektedir.

Seçenekler menüsü oluştur

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

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

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

Bir etkinlikle ilgili 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'de tanımlanan menü kaynağınızı, geri çağırmada sağlanan Menu öğesine şişirebilirsiniz. Bu, aşağıdaki örnekte gösterilmektedir:

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 findItem() ile öğeleri alarak özelliklerini MenuItem API'leriyle düzeltebilirsiniz.

Tıklama etkinliklerini yönetme

Kullanıcı, uygulama çubuğundaki işlem öğelerini de içeren 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 yönteminden geçer. getItemId() öğesini çağırarak öğeyi tanımlayabilirsiniz. getItemId(). Bu çağrı, menü kaynağındaki android:id özelliğiyle veya add() yöntemine verilen bir tam sayıyla menü öğesinin benzersiz kimliğini 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ılı bir şekilde işlediğinizde true öğesine dönün. Menü öğesiyle siz ilgilenmiyorsanız onOptionsItemSelected() üst sınıf uygulamasını çağırın. Varsayılan uygulama, false (yanlış) değerini döndürür.

Etkinliğiniz parçalar içeriyorsa sistem önce etkinlik için onOptionsItemSelected() yöntemini, daha sonra parçaların eklendiği sırayla her bir parça için bir true veya tüm parçalar çağrılana kadar bir çağrıyı yapar.

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

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

Seçenekler menüsünü etkinlik yaşam döngüsü sırasında gerçekleşen etkinliklere göre değiştirmek isterseniz bunu onPrepareOptionsMenu() yönteminden yapabilirsiniz. Bu yöntem, mevcut olan Menu nesnesini size iletir. Böylece öğe ekleyerek, kaldırarak veya devre dışı bırakarak üzerinde değişiklik yapabilirsiniz. Parçalar ayrıca onPrepareOptionsMenu() geri çağırma olanağı da sağlar.

Uygulama çubuğunda menü öğeleri sunulduğunda seçenekler menüsü her zaman açık kabul edilir. Bir etkinlik oluştuğunda ve menü güncellemesi yapmak istediğinizde sistemin onPrepareOptionsMenu() işlevini çağırmasını istemek için invalidateOptionsMenu() çağrısı yapın.

İç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 içerik çerçevesini etkileyen işlemler sunar. Herhangi bir görünüm için içerik menüsü sağlayabilirsiniz, ancak bunlar en çok RecylerView veya kullanıcının her öğe üzerinde doğrudan işlem yapabileceği diğer görünüm koleksiyonlarındaki öğeler için kullanılır.

Bağlamsal işlemler iki şekilde sunulur:

  • Kayan içerik menüsünde. Kullanıcı, içerik menüsünün desteklendiğini beyan eden bir görünümde dokunup basılı tuttuktan sonra, iletişim kutusuna benzer şekilde menü öğelerinin kayan bir listesi olarak görüntülenir. Kullanıcılar tek seferde bir öğe üzerinde bağlamsal 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(CAB) görüntüleyen ActionMode sistem uygulamasıdır. Uygulamanız bu modu destekliyorsa kullanıcılar aynı anda birden çok öğe üzerinde işlem gerçekleştirebilir.

Not: İçerik menüsü, öğe kısayollarını ve öğe simgelerini desteklemez.

Kayan içerik menüsü oluşturma

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

  1. Bağlam menüsünün ilişkili olduğu View öğesini registerForContextMenu() çağırıp View ileterek kaydedin.

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

  2. Activity veya Fragment öğenizde 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. Aşağıdaki örnekte olduğu gibi, genellikle bir menü kaynağını şişirerek menü öğelerini burada tanımlarsınız:

    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 bilgiler sağlayan ContextMenu.ContextMenuInfo nesnesini içerir. Etkinliğinizde, her biri farklı bir içerik menüsü sunan çeşitli görünümler varsa hangi içerik menüsünü şişireceğinizi belirlemek için bu parametreleri kullanabilirsiniz.

  3. Aşağıdaki örnekte gösterildiği gibi onContextItemSelected() uygulayın. Kullanıcı bir menü öğesi 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, XML'de menü tanımlama bölümünde gösterildiği gibi android:id özelliğini kullanarak XML'deki her menü öğesine atadığınız kimliği seçili menü öğesinin kimliğini sorgular.

    Bir menü öğesini başarılı bir şekilde işlediğinizde true öğesine dönün. Menü öğesini siz işlemiyorsanız menü öğesini üst sınıf uygulamaya geçirin. Etkinliğiniz parçalar içeriyorsa etkinlik önce bu geri çağırmayı alır. İşlenmeden üst sınıfı çağırarak sistem, true veya false döndürülene kadar etkinliği, her parçanın eklendiği sırayla bir parça olmak üzere her parçadaki ilgili geri çağırma yöntemine iletir. Activity ve android.app.Fragment için varsayılan uygulamalar false döndürür. Bu nedenle, işlenmediğinde her zaman üst sınıfı çağırın.

Bağlamsal işlem modunu kullanma

Bağlamsal işlem modu, kullanıcı etkileşimini bağlamsal işlemler gerçekleştirmeye odaklanan bir ActionMode sistem uygulamasıdır. Kullanıcılar bir öğe seçerek bu modu etkinleştirdiğinde, kullanıcının seçilen öğeler üzerinde gerçekleştirebileceği işlemleri sunmak için ekranın üst kısmında bağlamsal bir işlem çubuğu görüntülenir. Bu mod etkin durumdayken kullanıcı, uygulamanız destekliyorsa birden fazla öğe seçebilir, öğelerin seçimini kaldırıp etkinlik içinde gezinmeye devam edebilir. Kullanıcı tüm öğelerin seçimini kaldırdığında, Geri düğmesine dokunduğunda veya çubuğun sol tarafındaki Bitti işlemine dokunduğunda, işlem modu devre dışı bırakılır ve bağlamsal işlem çubuğu kaybolur.

Bağlamsal işlemler sunan görünümlerde, genellikle aşağıdaki iki etkinlikten biri veya her ikisi de gerçekleştiğinde bağlamsal işlem modunu çağırırsınız:

  • Kullanıcı görünüme dokunup basılı tutar.
  • Kullanıcı, görünümdeki bir onay kutusunu veya benzer bir kullanıcı arayüzü bileşenini seçer.

Uygulamanızın bağlama dayalı işlem modunu çağırma ve her işlemin davranışını tanımlama şekli, tasarımınıza bağlıdır. İki tasarım vardır:

  • Bağımsız, rastgele görünümlerdeki bağlamsal işlemler için.
  • Kullanıcının birden fazla öğe seçmesine ve hepsinde işlem yapmasına olanak tanıyan RecyclerView içindeki öğe gruplarında toplu bağlamsal işlemler için.

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

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

İçeriğe dayalı 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şlemleri belirtebilir, işlem öğelerindeki tıklama etkinliklerine yanıt verebilir ve işlem modu için diğer yaşam döngüsü etkinliklerini yönetebilirsiniz.

    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ğırmaları, seçenekler menüsü için yapılan geri çağırmalarla hemen hemen aynıdır. Tek fark, bunların her birinin etkinlikle ilişkili ActionMode nesnesini de iletmesidir. ActionMode API'lerini kullanarak CAB'de başlık ve alt başlığı düzeltme gibi çeşitli değişiklikler yapabilirsiniz. Örneğin, setTitle() ve setSubtitle() kullanarak başlık ve alt başlığı düzeltebilirsiniz. Bu, kaç öğe seçildiğinin belirtilmesinde yararlıdır.

    Önceki örnek, işlem modu kaldırıldığında actionMode değişkenini null olarak ayarlar. Sonraki adımda değişkenin nasıl başlatıldığını ve üye değişkenini etkinliğinizde veya parçanızda kaydetmenin nasıl faydalı olabileceğini öğrenin.

  2. Çubuğun gösterilmesini istediğinizde (örneğin, kullanıcı görünüme dokunup basılı tutduğunda) startActionMode() çağırı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() işlevini çağırdığınızda, sistem oluşturulan ActionMode öğesini döndürür. Bunu bir üye değişkenine kaydederek bağlamsal işlem çubuğunda diğer etkinliklere yanıt olarak değişiklik yapabilirsiniz. Önceki örnekte ActionMode, işlem modu başlatılmadan önce üyenin null olup olmadığını kontrol ederek halihazırda etkinse ActionMode örneğinin yeniden oluşturulmamasını sağlamak için kullanılır.

Pop-up menü oluştur

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

PopupMenu, View öğesine bağlı kalıcı bir menüdür. Yer varsa sabit görünümün altında, aksi takdirde görünümün üstünde görünür. Aşağıdakiler için yararlıdır:

  • Şekil 4'te gösterilen Gmail'in e-posta üstbilgileri gibi belirli içerikle ilgili işlemler için taşma tarzı bir menü sağlama.
  • Bir komut cümlesinin ikinci bir bölümünü sağlar. Örneğin, farklı Ekle seçeneklerine sahip bir pop-up menü oluşturan, Ekle işaretli bir düğme sağlanır.
  • Kalıcı bir seçim tutmayan Spinner benzeri bir menü sağlıyor.

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

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

Örneğin, aşağıda bir pop-up menü gösteren düğme verilmiştir:

<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 pop-up menüsünü aşağıdaki şekilde 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. Kapatma etkinliğini PopupMenu.OnDismissListener kullanarak dinleyebilirsiniz.

Tıklama etkinliklerini yönetme

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

Bu, aşağıdaki örnekte gösterilmektedir:

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şturma

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

<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, bir grubu içeren 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>

Grupta bulunan öğeler, ilk öğeyle aynı düzeyde görünür. Menüdeki üç öğe de kardeştir. Bununla birlikte, grup kimliğini referans alarak 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" değerini bildirirseniz işlem çubuğunda her ikisi de veya işlem taşmasında her ikisi de görünür.

Kontrol edilebilir menü öğeleri kullan

Şekil 5. Kontrol edilebilir öğelerin bulunduğu bir alt menü.

Bir menü, seçenekleri açıp kapatmak için bir arayüz olarak, bağımsız seçenekler için bir onay kutusu veya karşılıklı olarak dışlanan seçenek grupları için radyo düğmeleri kullanarak yararlı olabilir. Şekil 5'te, radyo düğmeleriyle işaretlenebilen öğelerin bulunduğu bir alt menü gösterilmektedir.

<item> öğesindeki android:checkable özelliğini kullanarak menü öğeleri için tek tek veya <group> öğesinde android:checkableBehavior özelliğine sahip bir grubun tamamı için kontrol edilebilir davranışı 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. Bunun sonucunda radyo düğmeleri görüntülenir.
all
Tüm öğeler işaretlenebilir. Bunun sonucunda onay kutuları ortaya çıkar.
none
Kontrol edilebilir öğe yok.

<item> öğesindeki android:checked özelliğini kullanarak bir öğeye varsayılan olarak kontrol edilmiş durumu uygulayabilir ve setChecked() yöntemi ile bu durumu kodda değiştirebilirsiniz.

Kontrol edilebilir bir öğe seçildiğinde sistem, öğe için seçilen ilgili geri çağırma yönteminizi (ör. onOptionsItemSelected()) çağırır. Onay kutusu veya radyo düğmesi, durumunu otomatik olarak değiştirmediğinden onay kutusunun durumunu burada ayarlarsınız. isChecked() ile öğenin mevcut durumunu (kullanıcının seçmeden önceki durumunu) sorgulayabilir ve "işaretli" durumunu setChecked() ile 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 kutusu veya radyo düğmesinin görünen durumu kullanıcı tarafından seçildiğinde değişmez. Durumu ayarladığınızda etkinlik, öğenin kontrol edilen 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 ekleme

Bazen bir menü öğesinin, uygulamanızdaki veya başka bir uygulamadaki bir etkinlik Intent kullanarak bir etkinlik başlatmasını istersiniz. Kullanmak istediğiniz amacı bildiğinizde ve amacı başlatan belirli bir menü öğesi olduğunda, onOptionsItemSelected() geri çağırması gibi öğe üzerinde seçilen uygun geri çağırma yöntemi sırasında amacı startActivity() ile yürütebilirsiniz.

Bununla birlikte, kullanıcının cihazının amacı işleyen bir uygulama içerdiğinden emin değilseniz amaç bir etkinliği işlemeyip Android, cihazda amacınıza uygun etkinlikler bulduğunda, bu sorunu çözmek için menünüze dinamik olarak menü öğeleri eklemenize olanak tanır.

Bir amacı kabul eden mevcut etkinliklere dayalı menü öğeleri eklemek için aşağıdakileri yapın:

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

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

Bu, aşağıdaki örnekte gösterilmektedir:

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

Tanımlanan amaçla eşleşen intent filtresi sağlayan her etkinlik için bir menü öğesi eklenir. Bunun için, intent filtresinin android:label öğesindeki değer menü öğesi başlığı ve uygulama simgesi olarak menü öğesi 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 verme

Etkinliğinize ait hizmetleri diğer uygulamalara sunabilirsiniz. Böylece uygulamanız, diğer uygulamaların menüsüne dahil edilebilir. Daha önce açıklanan rolleri tersine çevirebilirsiniz.

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

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

Amaçlar ve amaç filtreleri bölümünden intent filtreleri yazma hakkında daha fazla bilgi edinebilirsiniz.