CODEWITHSUNDEEP
androidkotlinmenufragmentandroid-inflate
SUR4IDE
SUR4IDE

Reputation: 1223

'setHasOptionsMenu(Boolean): Unit' is deprecated. Deprecated in Java

How do I declare a menu inside of Android fragment? The method that I had used previously is now deprecated.

Originally:

    override fun onCreateView(...): View {
        setHasOptionsMenu(true)
    }

 override fun onCreateOptionsMenu(menu: Menu, inflater: MenuInflater) {
        super.onCreateOptionsMenu(menu, inflater)
        this.menu = menu
        inflater.inflate(R.menu.menu, this.menu)
    }

Upvotes: 102

Views: 48699

Answers (10)

Salam El-Banna
Salam El-Banna

Reputation: 3870

Adding to the above answers, I prefer creating an extension function to reduce boilerplate code:

Extension function implementation:

fun Fragment.setupMenu(@MenuRes menuId: Int, onMenuSelected: (MenuItem) -> Boolean) =
(requireActivity() as MenuHost).addMenuProvider(object : MenuProvider {
    override fun onCreateMenu(menu: Menu, menuInflater: MenuInflater) =
        menuInflater.inflate(menuId, menu)

    override fun onMenuItemSelected(menuItem: MenuItem) = onMenuSelected(menuItem)
}, viewLifecycleOwner, Lifecycle.State.RESUMED)

This way, you will always insure you are adding the lifeCycleOwner and passing the correct lifecycle state which is Lifecycle.State.RESUMED

And you can simply use this inside fragment calling:

setupMenu(R.menu.menu_save) { menuItem ->
    when (menuItem.itemId) {
        R.id.save -> {
            viewModel.onSaveClicked()
            true
        }
        else -> false
    }
}

Upvotes: 0

George Shalvashvili
George Shalvashvili

Reputation: 1569

For people who have flashbacks from Java, here is a bit better way using this extension function:

fun Fragment.addMenuProvider(@MenuRes menuRes: Int, callback: (id: Int) -> Boolean) {
    val menuProvider = object : MenuProvider {
        override fun onCreateMenu(menu: Menu, menuInflater: MenuInflater) {
            menuInflater.inflate(menuRes, menu)
        }

        override fun onMenuItemSelected(menuItem: MenuItem) = callback(menuItem.itemId)

    }
    (requireActivity() as MenuHost).addMenuProvider(
        menuProvider,
        viewLifecycleOwner,
        Lifecycle.State.RESUMED
    )
}

and the usage:

override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
    super.onViewCreated(view, savedInstanceState)

    addMenuProvider(R.menu.feed_fragment) {
        when (it) {
            R.id.menu_write_post -> viewModel.goToPostCreation()
            R.id.menu_filter -> viewModel.goToFilter()
            else -> false
        }
    }
}

In case there is a need for feature flag, then you can repeat addMenuProvider call multiple times

Upvotes: 3

Alma N
Alma N

Reputation: 19

in java for fragment i tried this . it works fine for me

 @Nullable
@Override
public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
    View view = inflater.inflate(R.layout.layout_example, container, false);

    toolbar = (Toolbar)view.findViewById(R.id.toolbar_1);
    ((AppCompatActivity)getActivity()).setSupportActionBar(toolbar);
    MenuHost menuHost = requireActivity();
    menuHost.addMenuProvider(new MenuProvider() {
        @Override
        public void onCreateMenu(@NonNull Menu menu, @NonNull MenuInflater menuInflater) {
            menuInflater.inflate(R.menu.menu_search,menu);
        }

        @Override
        public boolean onMenuItemSelected(@NonNull MenuItem menuItem) {

            if (menuItem.getItemId() == R.id.search_friend){
                Toast.makeText(getActivity(), "friends", Toast.LENGTH_SHORT).show();
                return true;
            }
            else return false;
        }
    },getViewLifecycleOwner(), Lifecycle.State.RESUMED);


    return view;
}

Upvotes: 2

Eran Boudjnah
Eran Boudjnah

Reputation: 1278

I'm not sure why all answers recommend passing in Lifecycle.State.RESUME as the lifecycle state to the addMenuProvider call. This will make the menu disappear when the fragment is paused, which doesn't look great when the fragment is paused and still visible.

For example, showing a dialog as a result of tapping a menu item will make the menu disappear. It will re-appear when the dialog is dismissed.

For most cases, a better lifecycle state to pass in would be Lifecycle.State.CREATE, which will only remove the menu when the view is destroyed. This is also the default behaviour, so you can simply omit the lifecycle state.

Upvotes: 3

Codelaby
Codelaby

Reputation: 2883

In Kotlin, declaration for Activity, Fragment and PreferenceFragmentCompat

Activity

class MainActivity : AppCompatActivity() {

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

   addMenuProvider(object : MenuProvider {
      override fun onCreateMenu(menu: Menu, menuInflater: MenuInflater) {
        menuInflater.inflate(R.menu.main_menu, menu)
      }

      override fun onMenuItemSelected(menuItem: MenuItem): Boolean {
        // Handle the menu selection
        return true
      }
    })
  }
}

Fragment

  override fun onViewCreated(view: View, savedInstanceState: Bundle?) {

    // The usage of an interface lets you inject your own implementation
    val menuHost: MenuHost = requireActivity()

    menuHost.addMenuProvider(object : MenuProvider {
      override fun onCreateMenu(menu: Menu, menuInflater: MenuInflater) {
        // Add menu items here
        menuInflater.inflate(R.menu.main_menu, menu)
      }

      override fun onMenuItemSelected(menuItem: MenuItem): Boolean {
        // Handle the menu selection
            return when (menuItem.itemId) {
                R.id.action_menu1 -> {
                    // todo menu1
                    true
                }
                R.id.action_menu2 -> {
                    // todo menu2
                    true
                }
                else -> false
            }
      }
    }, viewLifecycleOwner, Lifecycle.State.RESUMED)
 }

PreferenceFragmentCompat

val menuHost: MenuHost = requireHost() as MenuHost
//Same declaration with Fragment

Use MenuProvider interface

class FirstFragment : Fragment(), MenuProvider {
 
      override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
              val menuHost: MenuHost = requireActivity()
              menuHost.addMenuProvider(this, viewLifecycleOwner, Lifecycle.State.RESUMED)
      }
 
      override fun onCreateMenu(menu: Menu, menuInflater: MenuInflater) {
        // Add menu items here
        menuInflater.inflate(R.menu.second_menu, menu)
      }
 
      override fun onMenuItemSelected(menuItem: MenuItem): Boolean {
        // Handle the menu selection
            return when (menuItem.itemId) {
                R.id.menu_clear -> {
                    // Do stuff...
                    true
                }
                R.id.menu_refresh -> {
                    // Do stuff...
                    true
                }
                else -> false
            }
      }, viewLifecycleOwner, Lifecycle.State.RESUMED)
}

Upvotes: 32

Ali Ahmed
Ali Ahmed

Reputation: 83

this helps me on onCreateView Method:

requireActivity().addMenuProvider(new MenuProvider() {
        @Override
        public void onCreateMenu(@NonNull Menu menu, @NonNull MenuInflater menuInflater) {
            menuInflater.inflate(R.menu.bottom_nav_menu, menu);
            
            // Add option Menu Here
            
        }

        @Override
        public boolean onMenuItemSelected(@NonNull MenuItem menuItem) {
                           
            // Handle option Menu Here
             return false;
        }
    }, getViewLifecycleOwner, Lifecycle.State.RESUMED);

Upvotes: 6

Eric B.
Eric B.

Reputation: 703

If you're using Jetpack NavigationUI then you need to setSupportActionBar(toolbar), otherwise the menu will not be present.

Upvotes: 9

Hammad Zafar Bawara
Hammad Zafar Bawara

Reputation: 513

JAVA CODE

Option menu in Activity

addMenuProvider(new MenuProvider() {
            @Override
            public void onCreateMenu(@NonNull Menu menu, @NonNull MenuInflater menuInflater) {
                menuInflater.inflate(R.menu.bottom_nav_menu, menu);

                // Add menu options here

            }

            @Override
            public boolean onMenuItemSelected(@NonNull MenuItem menuItem) {

                // Handle Menu Options Selection Here

                return false;
            }
        });

Option menu in Fragment

requireActivity().addMenuProvider(new MenuProvider() {
            @Override
            public void onCreateMenu(@NonNull Menu menu, @NonNull MenuInflater menuInflater) {
                menuInflater.inflate(R.menu.bottom_nav_menu, menu);
                
                // Add option Menu Here
                
            }

            @Override
            public boolean onMenuItemSelected(@NonNull MenuItem menuItem) {
                return false;
                
                // Handle option Menu Here
                
            }
        }, viewLifecycleOwner, Lifecycle.State.RESUMED);

Upvotes: 19

rogue
rogue

Reputation: 421

Expanding on what @joseph-wambura and @hammad-zafar-bawara said, you can also implement the interface in the fragment...

class MyFragment : Fragment(), MenuProvider {

    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
        // Do stuff...
        val menuHost: MenuHost = requireActivity()
        menuHost.addMenuProvider(this, viewLifecycleOwner, Lifecycle.State.RESUMED)
    }

    override fun onCreateMenu(menu: Menu, menuInflater: MenuInflater) {
        menuInflater.inflate(R.menu.options, menu)
        // Do stuff...
    }

    override fun onMenuItemSelected(menuItem: MenuItem): Boolean {
        // Do stuff...
        return false
    }
}

Upvotes: 40

Joseph Wambura
Joseph Wambura

Reputation: 3396

From the Developer documentation, this can be achieved by the following:

/**
  * Using the addMenuProvider() API directly in your Activity
  **/
class ExampleActivity : ComponentActivity(R.layout.activity_example) {

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    // Add menu items without overriding methods in the Activity
   addMenuProvider(object : MenuProvider {
      override fun onCreateMenu(menu: Menu, menuInflater: MenuInflater) {
        // Add menu items here
        menuInflater.inflate(R.menu.example_menu, menu)
      }

      override fun onMenuItemSelected(menuItem: MenuItem): Boolean {
        // Handle the menu selection
        return true
      }
    })
  }
}

/**
  * Using the addMenuProvider() API in a Fragment
  **/
class ExampleFragment : Fragment(R.layout.fragment_example) {

  override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
    // The usage of an interface lets you inject your own implementation
    val menuHost: MenuHost = requireActivity()
  
    // Add menu items without using the Fragment Menu APIs
    // Note how we can tie the MenuProvider to the viewLifecycleOwner
    // and an optional Lifecycle.State (here, RESUMED) to indicate when
    // the menu should be visible
    menuHost.addMenuProvider(object : MenuProvider {
      override fun onCreateMenu(menu: Menu, menuInflater: MenuInflater) {
        // Add menu items here
        menuInflater.inflate(R.menu.example_menu, menu)
      }

      override fun onMenuItemSelected(menuItem: MenuItem): Boolean {
        // Handle the menu selection
            return when (menuItem.itemId) {
                R.id.menu_clear -> {
                    // clearCompletedTasks()
                    true
                }
                R.id.menu_refresh -> {
                    // loadTasks(true)
                    true
                }
                else -> false
            }
      }
    }, viewLifecycleOwner, Lifecycle.State.RESUMED)
  }

Fragments setHasOptionsMenu deprecated, use setHasOptionsMenu

Upvotes: 145

Related Questions