'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:**
```kotlin
override fun onCreateView(...): View {
setHasOptionsMenu(true)
}
```

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

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][1]


[1]:

[To see links please register here]

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

**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);
```

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

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

In Kotlin, declaration for `Activity`, `Fragment` and `PreferenceFragmentCompat`

### Activity
```kotlin
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
```kotlin
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

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

### Use MenuProvider interface

```kotlin
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)
}
```

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.

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

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

```kotlin
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:

```kotlin
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