J2ME souple Wrapper clé

Question

La lecture des articles, m'a dit que des touches programmables varie entre les appareils. Certains disent -6 ou -21 pour touche gauche et -7 ou -22 pour la touche programmable de droite. Compte tenu de cette situation, est-il un bon emballage ou la fonction ou les meilleures pratiques pour gérer correctement?

Si pas possible pour tous les appareils, quelle est la meilleure façon de soutenir la plupart des appareils? avec entaille peu ou pas du tout?

Answer 1

Pour vous donner une idée de l'ampleur du problème un coup d'oeil à ce de keycodes.

L'approche de Omermuhammed est bonne si vous êtes en mesure de modifier le contenu JAD en fonction du combiné cible, par exemple en regardant le champ d'en-tête de l'agent utilisateur dans une demande de téléchargement à partir d'un sur-combiné navigateur Web.

Si vous ne pouvez pas identifier le combiné jusqu'à ce que l'application a été livré, vous pouvez regarder quelque chose comme ce qui détermine essentiellement le combiné hôte lors de l'exécution et définit les correspondances keycode de façon appropriée. On dirait lourd à moi si.

Enfin, si votre application utilise un sous-ensemble de codes que vous peut être en mesure de sortir des listes codées en dur - pour certains codes, il n'y a pas ou peu de collisions (à gauche est généralement soit -3 ou -61, et les codes habituellement ne signifient pas autre chose). Encore une fois, pas une approche idéale.

Ressources suggérées final pour vous: WURFL ou des chaînes de l'agent utilisateur, et base de données des dispositifs de J2MEPolish pour keycodes de l'appareil

Answer 2

La façon la plus simple que j'ai trouvé pour le mettre en place dans le code avec les valeurs recommandées en fonction de la norme UIT-T et la remplacer par un paramètre JAD. Donc, pour une application donnée, il cherchera existance du paramètre jad au démarrage de l'application et le mettre, sinon il utilisera les valeurs par défaut.

Je l'ai utilisé ces et des techniques similaires pour écrire des applications qui peuvent être rapidement portés, et ce processus est généralement bien connu.

Answer 3

Je dois complètement en désaccord avec Martin Clayton ci-dessus, quelque chose de similaire à cette méthode d'identification hôte combinés à l'exécution est absolument la bonne façon de traiter ce problème. Et y compris une classe standard pour le faire pour vous est beaucoup moins encombrant que faffing autour de plusieurs Jads / jars OMI.

Answer 4

Ceci est la méthode que je l'ai créé, qui utilise des codes clés et les noms clés. J'ai écrit ce code sur il y a 10 ans et à l'époque il soutenais la plupart des appareils. (Une exception que je trouve, cependant, était certains modèles Sagem qui ont le -6 et -7 codes clés l'inverse Mais vous pourriez probablement travailler autour de ce nouveau en utilisant les noms de clé -. Mais vous devrez peut-être obtenir l'agent utilisateur aussi)

    private static final int SOFT_BUTTON_KEY_CODE_UNDEFINED = -999;
    private static int LEFT_SOFT_BUTTON_KEY_CODE = SOFT_BUTTON_KEY_CODE_UNDEFINED;
    private static int RIGHT_SOFT_BUTTON_KEY_CODE = SOFT_BUTTON_KEY_CODE_UNDEFINED;

    private boolean isLeftSoftButton(int keyCode) {

        // Try the standard code
        if (keyCode == -6) {
            return true;
        }
        // Try the code we have already detected
        else if (keyCode == LEFT_SOFT_BUTTON_KEY_CODE && LEFT_SOFT_BUTTON_KEY_CODE != SOFT_BUTTON_KEY_CODE_UNDEFINED) {
            return true;
        }
        // If we haven't yet detected the code...
        else if (LEFT_SOFT_BUTTON_KEY_CODE == SOFT_BUTTON_KEY_CODE_UNDEFINED) {
            // try to detect it
            String keyName = getKeyName(keyCode).toUpperCase();
            if (keyName.equals("SOFT1") || keyName.equals("LEFT SELECTION KEY") || keyName.equals("LEFT SOFTKEY") || keyName.equals("LEFT SOFT KEY") || keyName.equals("SOFTKEY 1") || keyName.equals("-6")) {
                // It's the left soft button! So remember the code for next time...
                LEFT_SOFT_BUTTON_KEY_CODE = keyCode;
                // Return true
                return true;
            }
            else {
                // keyName didn't match, so return false
                return false;
            }
        }
        else {
            // keyCode didn't match
            return false;
        }

    }

    private boolean isRightSoftButton(int keyCode) {

        // Try the standard code
        if (keyCode == -7) {
            return true;
        }
        // Try the code we have already detected
        else if (keyCode == RIGHT_SOFT_BUTTON_KEY_CODE && RIGHT_SOFT_BUTTON_KEY_CODE != SOFT_BUTTON_KEY_CODE_UNDEFINED) {
            return true;
        }
        // If we haven't yet detected the code...
        else if (RIGHT_SOFT_BUTTON_KEY_CODE == SOFT_BUTTON_KEY_CODE_UNDEFINED) {
            // try to detect it
            String keyName = getKeyName(keyCode).toUpperCase();
            if (keyName.equals("SOFT2") || keyName.equals("RIGHT SELECTION KEY") || keyName.equals("RIGHT SOFTKEY") || keyName.equals("RIGHT SOFT KEY") || keyName.equals("SOFTKEY 4") || keyName.equals("SOFTKEY 2") || keyName.equals("-7")) {
                // It's the right soft button! So remember the code for next time...
                RIGHT_SOFT_BUTTON_KEY_CODE = keyCode;
                // Return true
                return true;
            }
            else {
                // keyName didn't match, so return false
                return false;
            }
        }
        else {
            // keyCode didn't match
            return false;
        }

    }

code mis à jour, basé sur http://www.iteye.com/topic/179073 ...

private static final int SOFT_BUTTON_KEY_CODE_UNDEFINED = -999;
private static int LEFT_SOFT_BUTTON_KEY_CODE = SOFT_BUTTON_KEY_CODE_UNDEFINED;
private static int RIGHT_SOFT_BUTTON_KEY_CODE = SOFT_BUTTON_KEY_CODE_UNDEFINED;

private boolean isLeftSoftButton(int keyCode) {

    // Try the standard codes
    //     standard   ||    Motorola    ||    Siemens    ||   Motorola 2   ||   Motorola 1
    if (keyCode == -6 || keyCode == -21 || keyCode == -1 || keyCode == -20 || keyCode == 21) {
        return true;
    }
    // Try the code we have already detected
    else if (keyCode == LEFT_SOFT_BUTTON_KEY_CODE && LEFT_SOFT_BUTTON_KEY_CODE != SOFT_BUTTON_KEY_CODE_UNDEFINED) {
        return true;
    }
    // If we haven't yet detected the code...
    else if (LEFT_SOFT_BUTTON_KEY_CODE == SOFT_BUTTON_KEY_CODE_UNDEFINED) {
        // try to detect it
        String keyName = getKeyName(keyCode).toUpperCase();
        if (keyName.equals("SOFT1") || keyName.equals("LEFT SELECTION KEY") || keyName.equals("LEFT SOFTKEY") || keyName.equals("LEFT SOFT KEY") || keyName.equals("SOFTKEY 1") || keyName.equals("-6")) {
            // It's the left soft button! So remember the code for next time...
            LEFT_SOFT_BUTTON_KEY_CODE = keyCode;
            // Return true
            return true;
        }
        else {
            // keyName didn't match, so return false
            return false;
        }
    }
    else {
        // keyCode didn't match
        return false;
    }

}

private boolean isRightSoftButton(int keyCode) {

    // Try the standard codes
    //     standard   ||    Motorola    ||    Siemens    ||   Motorola 1
    if (keyCode == -7 || keyCode == -22 || keyCode == -4 || keyCode == 22) {
        return true;
    }
    // Try the code we have already detected
    else if (keyCode == RIGHT_SOFT_BUTTON_KEY_CODE && RIGHT_SOFT_BUTTON_KEY_CODE != SOFT_BUTTON_KEY_CODE_UNDEFINED) {
        return true;
    }
    // If we haven't yet detected the code...
    else if (RIGHT_SOFT_BUTTON_KEY_CODE == SOFT_BUTTON_KEY_CODE_UNDEFINED) {
        // try to detect it
        String keyName = getKeyName(keyCode).toUpperCase();
        if (keyName.equals("SOFT2") || keyName.equals("RIGHT SELECTION KEY") || keyName.equals("RIGHT SOFTKEY") || keyName.equals("RIGHT SOFT KEY") || keyName.equals("SOFTKEY 4") || keyName.equals("SOFTKEY 2") || keyName.equals("-7")) {
            // It's the right soft button! So remember the code for next time...
            RIGHT_SOFT_BUTTON_KEY_CODE = keyCode;
            // Return true
            return true;
        }
        else {
            // keyName didn't match, so return false
            return false;
        }
    }
    else {
        // keyCode didn't match
        return false;
    }

}`

Answer 5

  

MIDP définit comme suit constante pour les touches d'un clavier standard ITU-T: KEY_NUM0, KEY_NUM1, KEY_NUM2, KEY_NUM3, KEY_NUM4, KEY_NUM5, KEY_NUM6, KEY_NUM7, KEY_NUM8, KEY_NUM9, KEY_POUND et KEY_STAR. Les applications ne doivent pas compter sur la présence de codes clés supplémentaires. En particulier, majuscules et minuscules ou caractères générés en appuyant sur une fois sur la touche multiples ne sont pas pris en charge par les événements clés de bas niveau. Un « nom » attribué à la touche peut être interrogé par la méthode getkeyname ().

AFAIR la méthode GetKeyName revient tout à fait la même chose sur la plupart des téléphones il était donc tout à fait fiable, mais je n'ai pas écrit quoi que ce soit dans J2ME depuis il y a environ 2 ans, si ma mémoire peut jouer des tours. (Vous avez été prévenu)