Comment forcer l'utilisation du menu de débordement sur les appareils avec le bouton de menu

Je voudrais avoir tous les éléments de menu qui ne rentrent pas dans le go ActionBar dans le menu de trop - plein (celui qui est atteint de la barre d' action non sur le bouton de menu) , même sur des appareils qui faire un bouton Menu . Cela semble beaucoup plus intuitif pour les utilisateurs que de les jeter dans une liste de menus séparée qui oblige l'utilisateur à passer d'une interaction tactile (écran) à une interaction basée sur un bouton simplement parce que la disposition de l'ActionBar ne peut pas les adapter à la barre.

Sur l'émulateur, je peux définir la valeur "Hardware Back / Home Keys" sur "no" et obtenir cet effet. J'ai cherché un moyen de le faire dans le code pour un appareil réel qui a un bouton de menu mais ne peut pas en régler un. Quelqu'un peut-il m'aider?

EDIT: Modifié pour répondre à la situation du bouton de menu physique.

Ceci est en fait empêché par la conception. Selon la section de compatibilité du guide de conception Android ,

"... le débordement d'action est disponible à partir de la touche matérielle du menu. La fenêtre contextuelle des actions qui en résulte ... s'affiche en bas de l'écran."

Vous remarquerez dans les captures d'écran que les téléphones dotés d'un bouton de menu physique n'ont pas de menu de débordement dans l'ActionBar. Cela évite toute ambiguïté pour l'utilisateur, ayant essentiellement deux boutons disponibles pour ouvrir exactement le même menu.

Pour résoudre le problème de la cohérence entre les appareils: en fin de compte, il est plus important pour l'expérience utilisateur que votre application se comporte de manière cohérente avec toutes les autres applications sur le même appareil, que de se comporter de manière cohérente avec elle-même sur tous les appareils.

Vous pouvez également utiliser ce petit hack ici:

try {
    ViewConfiguration config = ViewConfiguration.get(this);
    Field menuKeyField = ViewConfiguration.class.getDeclaredField("sHasPermanentMenuKey");
    if (menuKeyField != null) {
        menuKeyField.setAccessible(true);
        menuKeyField.setBoolean(config, false);
    }
} catch (Exception ignored) {
}

Le bon endroit pour le mettre serait la onCreate-Méthode de votre classe Application.

Cela forcera l'application à afficher le menu de débordement. Le bouton de menu fonctionnera toujours, mais il ouvrira le menu dans le coin supérieur droit.

[Modifier] Depuis qu'il est venu plusieurs fois maintenant: Ce hack ne fonctionne que pour l'ActionBar native introduite dans Android 3.0, pas ActionBarSherlock. Ce dernier utilise sa propre logique interne pour décider d'afficher ou non le menu de débordement. Si vous utilisez l'ABS, toutes les plateformes <4.0 sont gérées par l'ABS et sont donc soumises à sa logique. Le hack fonctionnera toujours pour tous les appareils équipés d'Android 4.0 ou supérieur (vous pouvez ignorer en toute sécurité Android 3.x, car il n'y a pas vraiment de tablettes avec un bouton de menu).

Il existe un thème spécial ForceOverflow qui forcera le menu en ABS, mais apparemment, il sera supprimé dans les versions futures en raison de complications .

J'utilise pour contourner le problème en définissant mon menu comme celui-ci (également avec l'icône ActionBarSherlock utilisée dans mon exemple):

<menu xmlns:android="http://schemas.android.com/apk/res/android" >

    <item
        android:id="@+id/menu_overflow"
        android:icon="@drawable/abs__ic_menu_moreoverflow_normal_holo_light"
        android:orderInCategory="11111"
        android:showAsAction="always">
        <menu>
            <item
                android:id="@+id/menu_overflow_item1"
                android:showAsAction="never"
                android:title="@string/overflow_item1_title"/>
            <item
                android:id="@+id/menu_overflow_item2"
                android:showAsAction="never"
                android:title="@string/overflow_item2_title"/>
        </menu>
    </item>

</menu>

J'admets que cela peut nécessiter une "gestion de débordement" manuelle dans votre xml, mais j'ai trouvé cette solution utile.

Vous pouvez également forcer l'appareil à utiliser le bouton HW pour ouvrir le menu de débordement, dans votre activité:

private Menu mainMenu;

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    // TODO: init menu here...
    // then:
    mainMenu=menu;
    return true;
}

@Override
public boolean onKeyUp(int keycode, KeyEvent e) {
    switch(keycode) {
        case KeyEvent.KEYCODE_MENU:
            if (mainMenu !=null) {
                mainMenu.performIdentifierAction(R.id.menu_overflow, 0);
            }
    }

    return super.onKeyUp(keycode, e);
}

:-)

Si vous utilisez la barre d'action de la bibliothèque de support ( android.support.v7.app.ActionBar), utilisez ce qui suit:

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:yorapp="http://schemas.android.com/apk/res-auto" >

    <item
        android:id="@+id/menu_overflow"
        android:icon="@drawable/icon"
        yourapp:showAsAction="always"
        android:title="">
        <menu>
            <item
                android:id="@+id/item1"
                android:title="item1"/>
            <item
                android:id="@+id/item2"
                android:title="item2"/>
        </menu>
    </item>

</menu>

Ce type de méthode est empêché par le système de conception Android Developers, mais j'ai trouvé un moyen de le faire passer:

Ajoutez ceci à votre fichier de menu XML:

<item android:id="@+id/pick_action_provider"
    android:showAsAction="always"
    android:title="More"
    android:icon="@drawable/ic_action_overflow"
    android:actionProviderClass="com.example.AppPickActionProvider" />

Ensuite, créez une classe nommée 'AppPickActionProvider' et copiez-y le code suivant:

    package com.example;

import android.content.Context;
import android.util.Log;
import android.view.ActionProvider;
import android.view.MenuItem;
import android.view.MenuItem.OnMenuItemClickListener;
import android.view.SubMenu;
import android.view.View;

public class AppPickActionProvider extends ActionProvider implements
        OnMenuItemClickListener {

    static final int LIST_LENGTH = 3;

    Context mContext;

    public AppPickActionProvider(Context context) {
        super(context);
        mContext = context;
    }

    @Override
    public View onCreateActionView() {
        Log.d(this.getClass().getSimpleName(), "onCreateActionView");

        return null;
    }

    @Override
    public boolean onPerformDefaultAction() {
        Log.d(this.getClass().getSimpleName(), "onPerformDefaultAction");

        return super.onPerformDefaultAction();
    }

    @Override
    public boolean hasSubMenu() {
        Log.d(this.getClass().getSimpleName(), "hasSubMenu");

        return true;
    }

    @Override
    public void onPrepareSubMenu(SubMenu subMenu) {
        Log.d(this.getClass().getSimpleName(), "onPrepareSubMenu");

        subMenu.clear();

        subMenu.add(0, 1, 1, "Item1")
        .setIcon(R.drawable.ic_action_home).setOnMenuItemClickListener(this);

        subMenu.add(0, 2, 1, "Item2")
            .setIcon(R.drawable.ic_action_downloads).setOnMenuItemClickListener(this);
    }

    @Override
    public boolean onMenuItemClick(MenuItem item) {
        switch(item.getItemId())
        {
            case 1:

                // What will happen when the user presses the first menu item ( 'Item1' )

                break;
            case 2:

                // What will happen when the user presses the second menu item ( 'Item2' )

                break;

        }

        return true;
    }
}

Eh bien, je pense qu'Alexander Lucas a fourni la réponse (malheureusement) correcte, donc je la marque comme "correcte". La réponse alternative que j'ajoute ici est simplement de diriger tous les nouveaux lecteurs vers cet article du blog Android Developers en tant que discussion plutôt complète du sujet avec quelques suggestions spécifiques sur la façon de gérer votre code lors de la transition du pré-niveau 11 à la nouvelle barre d'action.

Je crois toujours que c'était une erreur de conception que le bouton de menu ne se comporte pas comme un bouton "Action Overflow" redondant dans les appareils activés par le bouton de menu comme un meilleur moyen de faire la transition de l'expérience utilisateur, mais son eau sous le pont à ce stade.

Je ne sais pas si c'est ce que vous recherchez, mais j'ai créé un sous-menu dans le menu de la barre d'action et défini son icône pour correspondre à l'icône du menu de débordement. Bien que les éléments ne lui soient pas automatiquement envoyés (c'est-à-dire que vous devez choisir ce qui est toujours visible et ce qui déborde toujours), il me semble que cette approche peut vous aider.

Dans l'application Gmail fournie avec ICS préinstallé, le bouton de menu est désactivé lorsque plusieurs éléments sont sélectionnés. Le menu de débordement est ici "forcé" d'être déclenché par l'utilisation du bouton de débordement au lieu du bouton de menu physique. Theres une bibliothèque tierce appelée ActionBarSherlock qui vous permet de "forcer" le menu de débordement. Mais cela ne fonctionnera qu'au niveau d'API 14 ou inférieur (pré-ICS)

Si vous utilisez la barre d'outils , vous pouvez afficher le débordement sur toutes les versions et tous les appareils, j'ai essayé sur certains appareils 2.x, cela fonctionne.

Désolé si ce problème est mort.

Voici ce que j'ai fait pour résoudre l'erreur. Je suis allé aux mises en page et en ai créé deux contenant des barres d'outils. L'un était une mise en page pour la version 8 de sdk et l'autre pour la version 21 de sdk. Sur la version 8, j'ai utilisé la barre d'outils android.support.v7.widget.Toolbar tandis que j'ai utilisé android.widget.Toolbar sur la mise en page sdk 21.

Ensuite, je gonfle la barre d'outils dans mon activité. Je vérifie le sdk pour voir s'il était de 21 ou plus. Je gonfle ensuite la mise en page correspondante. Cela force le bouton matériel à mapper sur la barre d'outils que vous avez réellement conçue.

Pour tous ceux qui utilisent le nouveau Toolbar:

private Toolbar mToolbar;

@Override
protected void onCreate(Bundle bundle) {
    super.onCreate(bundle);

    mToolbar = (Toolbar) findViewById(R.id.toolbar);
    setSupportActionBar(mToolbar);

    ...
}


@Override
public boolean onKeyUp(int keycode, KeyEvent e) {
    switch(keycode) {
        case KeyEvent.KEYCODE_MENU:
            mToolbar.showOverflowMenu();
            return true;
        }

    return super.onKeyUp(keycode, e);
}