Am o bara de acțiuni cu o menuitem. Cum pot ascunde/arată că elementul de meniu?
Aceasta este ceea ce am'm încercat să fac:
MenuItem item = (MenuItem) findViewById(R.id.addAction);
item.setVisible(false);
this.invalidateOptionsMenu();
Obține o MenuItem indică spre un astfel de element, sun setVisible pe ea pentru a regla vizibilitatea și apoi apel
invalidateOptionsMenu()` pe activitatea dumneavoastră atât de ActionBar meniu este ajustat în mod corespunzător.
Actualizare: O MenuItem
nu este un obișnuit vedere că's parte din layout. Ceva special, complet diferite. Codul se întoarce null
pentru "item" și că's provocând accidentul. De ce ai nevoie, în schimb, este să faci:
MenuItem item = menu.findItem(R.id.addAction);
Aici este secvența în care ar trebui să sunați la:
primul apel invalidateOptionsMenu()
și apoi în interiorul onCreateOptionsMenu(Meniu)
a obține o referință la MenuItem (prin apelarea meniul.findItem()) și sun
setVisible()` pe ea
A găsit un act adițional la această întrebare:
Dacă doriți să modificați vizibilitatea elementele de meniu de pe drum, trebuie doar să setați o variabilă membru în activitatea dumneavoastră pentru a amintiți-vă că doriți să ascundeți meniul și sun invalidateOptionsMenu()
și ascunde elementele din suprascrisă onCreateOptionsMenu(...)
metoda.
//anywhere in your code
...
mState = HIDE_MENU; // setting state
invalidateOptionsMenu(); // now onCreateOptionsMenu(...) is called again
...
@Override
public boolean onCreateOptionsMenu(Menu menu)
{
// inflate menu from xml
MenuInflater inflater = getSupportMenuInflater();
inflater.inflate(R.menu.settings, menu);
if (mState == HIDE_MENU)
{
for (int i = 0; i < menu.size(); i++)
menu.getItem(i).setVisible(false);
}
}
În exemplul meu am'am ascuns toate elementele.
Da.
invalidateOptionsMenu()
atunci când doriți pentru a ascunde opțiune. Acest lucru va suna onCreateOptionsMenu()`.onCreateOptionsMenu()
, verificați pentru pavilion/starea și show sau
ascunde-l în felul următor:MenuItem element = meniu.findItem(R. id.menu_Done);
dacă (flag/stare)) { element.setVisible(false); } else { }
Puteți apela acest lucru:
MenuItem item = menu.findItem(R.id.my_item);
item.setVisible(false);
Actualizare:
Asigurați-vă că codul nu't se întoarce null
pentru "item" sau se poate bloca aplicația.
Am fost în căutarea pentru un răspuns, cu un pic mai mult context. Acum că mi-am dat seama, voi adăuga că răspunde.
În mod implicit butonul share vor fi ascunse, ca set de android:vizibil="false"`.
main_menu.xml
<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto">
<!-- hide share button by default -->
<item
android:id="@+id/menu_action_share"
android:icon="@drawable/ic_share_white_24dp"
android:visible="false"
android:title="Share"
app:showAsAction="always"/>
<item
android:id="@+id/menu_action_settings"
android:icon="@drawable/ic_settings_white_24dp"
android:title="Setting"
app:showAsAction="ifRoom"/>
</menu>
Dar butonul share opțional pot fi afișate în funcție de anumite condiții.
MainActivity.java
public boolean onCreateOptionsMenu(Menu menu) {
MenuInflater inflater = getMenuInflater();
inflater.inflate(R.menu.main_menu, menu);
MenuItem shareItem = menu.findItem(R.id.menu_action_share);
// show the button when some condition is true
if (someCondition) {
shareItem.setVisible(true);
}
return true;
}
am't de lucru pentru mine. Am avut de a utiliza în mod explicit onPrepareOptionsMenu
pentru a seta un element invizibil.
Deci folosesc onCreateOptionsMenupentru a crea meniul și
onPrepareOptionsMenu` pentru a schimba vizibilitatea etc.
Aceasta a lucrat pentru mine la ambele Activitate și Fragment
@Override
public void onPrepareOptionsMenu(Menu menu) {
super.onPrepareOptionsMenu(menu);
if (menu.findItem(R.id.action_messages) != null)
menu.findItem(R.id.action_messages).setVisible(false);
}
Stabilit inițial elementul de meniu vizibilitate la fals în meniul layout fișier, după cum urmează :
<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto">
<item
android:visible="false"
android:id="@+id/action_do_something"
android:title="@string/txt_do_something"
app:showAsAction="always|withText"
android:icon="@drawable/ic_done"/>
</menu>
Apoi, puteți pur și simplu setați vizibilitatea element de meniu pentru fals în onCreateOptionsMenu() după umflarea meniu.
@Override
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
super.onCreateOptionsMenu(menu, inflater);
inflater.inflate(menu,R.menu.menu);
MenuItem item = menu.findItem(R.id.menuItemId);
if (item != null){
item.setVisible(false);
}
}
P1r4nh4 răspunsul funcționează bine, am simplificat folosind un boolean flag:
public int mState = 0; //at the top of the code
//where you want to trigger the hide action
mState = 1; // to hide or mState = 0; to show
invalidateOptionsMenu(); // now onCreateOptionsMenu(...) is called again
...
@Override
public boolean onCreateOptionsMenu(Menu menu)
{
// inflate menu from xml
MenuInflater inflater = getSupportMenuInflater();
inflater.inflate(R.menu.settings, menu);
if (mState == 1) //1 is true, 0 is false
{
//hide only option 2
menu.getItem(2).setVisible(false);
}
}
setați o valoare pentru o variabilă și de apel invalidateOptionsMenu();
de exemplu
selectedid=arg2;
invalidateOptionsMenu();
public boolean onPrepareOptionsMenu(Menu menu) {
if(selectedid==1){
menu.findItem(R.id.action_setting).setVisible(false);
menu.findItem(R.id.action_s2).setVisible(false);
menu.findItem(R.id.action_s3).setVisible(false);
}
else{
if(selectedid==2){
menu.findItem(R.id.action_search).setVisible(false);
menu.findItem(R.id.action_s4).setVisible(false);
menu.findItem(R.id.action_s5).setVisible(false);
}
}
return super.onPrepareOptionsMenu(menu);
}
Prin setarea de Vizibilitate de toate elementele din Meniu, appbar meniu sau meniu de preaplin va fi Ascuns în mod automat
Exemplu
private Menu menu_change_language;
...
...
@Override
public boolean onCreateOptionsMenu(Menu menu) {
...
...
menu_change_language = menu;
menu_change_language.findItem(R.id.menu_change_language)
.setVisible(true);
return super.onCreateOptionsMenu(menu);
}
Înainte de a merge la alt fragment folosi codul de mai jos:
if(menu_change_language != null){
menu_change_language.findItem(R.id.menu_change_language)
.setVisible(false);
}
În funcție de Dezvoltator Android-ul Oficial,OnCreateOptionMenu(Meniu) nu este recomandat pentru a schimba elementele de meniu sau icoane, vizibilitate, etc..la Execuție.
După apeluri de sistem onCreateOptionsMenu(), se păstrează un exemplu de Meniu popula și nu va suna onCreateOptionsMenu() din nou, cu excepția cazului în care meniul este invalidat pentru un motiv. Cu toate acestea, ar trebui să utilizați onCreateOptionsMenu() numai pentru a crea meniul inițial stat și nu de a face modificări în timpul activității ciclului de viață.
Dacă doriți să modificați opțiunile de meniu bazat pe evenimentele care au loc în timpul activității ciclului de viață, puteți face acest lucru în onPrepareOptionsMenu() metodă. Această metodă vă trece Meniul obiectul așa cum există în prezent astfel încât să puteți modifica, cum ar fi adăuga, elimina sau dezactiva elemente. (Fragmente oferi, de asemenea, un onPrepareOptionsMenu() callback.) --AndroidDeveloper Site-Ul Oficial --
Ca ne-a Recomandat-puteți utiliza acest onOptionsItemSelected(MenuItem element) metoda evidența intrări de utilizator.
@Override
public boolean onOptionsItemSelected(MenuItem item) {
int id = item.getItemId();
if (id == R.id.edit) {
Intent intent = new Intent(this, ExampleActivity.class);
intent.putExtra(BUNDLE_KEY, mConnection);
startActivityForResult(intent, PICK_CHANGE_REQUEST);
return true;
} else if (id == R.id.delete) {
showDialog(this);
return true;
}
return super.onOptionsItemSelected(item);
}
Dacă aveți nevoie pentru a schimba Elementele de Meniu în timp a Alerga, puteți utiliza onPrepareOptionsMenu(Meniu) pentru a le schimba
@Override
public boolean onPrepareOptionsMenu(Menu menu){
if (Utils.checkNetworkStatus(ExampleActivity.this)) {
menu.findItem(R.id.edit).setVisible(true);
menu.findItem(R.id.delete).setVisible(true);
}else {
menu.findItem(R.id.edit).setVisible(false);
menu.findItem(R.id.delete).setVisible(false);
}
return true;
}
https://stackoverflow.com/a/21215280/466363 - răspuns cu Privire Alterno și Sufian
.
private Menu mMenu;
@Override
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
inflater.inflate(R.menu.track_fragment, menu);
mMenu = menu;
}
...
private void someMethod() {
...
if (mMenu != null) {
MenuItem item = mMenu.findItem(R.id.new_track);
if (item != null) {
item.setVisible(false);
ActivityCompat.invalidateOptionsMenu(this.getActivity());
}
}
...
}
ActivityCompat.invalidateOptionsMenu() nu't de apel invers onPrepareOptionsMenu(); doar actualiza meniul direct.
Mi someMethod() ia a sunat de mai multe locuri, chiar înainte de onCreateOptionsMenu(), așa că trebuie să verificați mMenu != null.
ar trebui să lucreze folosind API 8
Dacă ați făcut totul ca în răspunsurile de mai sus, dar un element de meniu este încă vizibil, verificați dacă ați referință la unic resursă. De exemplu, în onCreateOptionsMenu sau onPrepareOptionsMenu
@Override
public void onPrepareOptionsMenu(Menu menu) {
super.onPrepareOptionsMenu(menu);
MenuItem menuOpen = menu.findItem(R.id.menu_open);
menuOpen.setVisible(false);
}
Ctrl+Click R. id.menu_open și verificați că nu există numai în meniul fișier. În cazul în care această resursă este deja folosit oriunde și încărcate într-o activitate, se va încerca să se ascundă acolo.
Pentru cei care folosesc Appcompat bibliotecă: Dacă Activitatea subclase ActionBarActivity, puteți apela supportInvalidateOptionsMenu()
Văzut aici: https://stackoverflow.com/a/19649877/1562524
Cel mai bun mod de a ascunde toate articolele dintr-un meniu cu doar o singură comandă este de a folosi "grup" în meniul tău xml. Doar adaugă toate elementele de meniu, care va fi în meniul de preaplin în interiorul aceluiași grup.
În acest exemplu avem două elemente de meniu care vă va arăta întotdeauna (element obișnuit și de căutare) și trei preaplin elemente:
<menu xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto">
<item
android:id="@+id/someItemNotToHide1"
android:title="ITEM"
app:showAsAction="always" />
<item
android:id="@+id/someItemNotToHide2"
android:icon="@android:drawable/ic_menu_search"
app:showAsAction="collapseActionView|ifRoom"
app:actionViewClass="android.support.v7.widget.SearchView"
android:title="Search"/>
<group android:id="@+id/overFlowItemsToHide">
<item android:id="@+id/someID"
android:orderInCategory="1" app:showAsAction="never" />
<item android:id="@+id/someID2"
android:orderInCategory="1" app:showAsAction="never" />
<item android:id="@+id/someID3"
android:orderInCategory="1" app:showAsAction="never" />
</group>
</menu>
Apoi, pe de activitate (de preferat la onCreateOptionsMenu), utilizați comanda setGroupVisible pentru a stabili toate elementele de meniu vizibilitate fals sau adevărat.
public boolean onCreateOptionsMenu(Menu menu) {
menu.setGroupVisible(R.id.overFlowItems, false); // Or true to be visible
}
Dacă doriți să utilizați această comandă oriunde în altă parte pe activitatea dumneavoastră, asigurați-vă că pentru a salva meniul de clasă la nivel local, și verificați întotdeauna dacă meniul este nul, pentru că puteți executa înainte de createOptionsMenu:
Menu menu;
public boolean onCreateOptionsMenu(Menu menu) {
this.menu = menu;
}
public void hideMenus() {
if (menu != null) menu.setGroupVisible(R.id.overFlowItems, false); // Or true to be visible
}
acest cod a lucrat pentru mine
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.main_menu,menu);
if (Application.sharedPreferences.getInt("type",1) == 2)
{
menuItem = menu.findItem(R.id.menu_travel_orders);
menuItem.setVisible(false);
}
return super.onCreateOptionsMenu(menu);
}