Meilleures Pratiques: Entrée De Validation (Android)

Je suis nouveau sur android, le développement mobile (Android Studio native développement de nouvelles connaissances). Et ici, je veux poser une question concernant les meilleures pratiques pour la validation d'entrée.
Aussi loin que nous le savons, quand un développeur de développer formulaire de saisie. Nous devons empêcher un utilisateur de la clé dans une mauvaise entrée dans le champ de texte. Voici donc ma question,

  1. Peut-on créer un fichier java pour vocation de validation? Toutes les entrées de formulaire ,il faut passer à une validation de fichier (Dans le cas de beaucoup de pages d'entrée de l'écran dans l'une des applications). Si OUI, comment puis-je obtenir un exemple de/lien/tutoriel de cette technique pour mon apprentissage. Si PAS, pourquoi?

De mon point de vue personnel, il doit avoir un moyen de mettre en œuvre la technique. De sorte que nous n'avons pas besoin de réutiliser le même code pour chaque fichier java (en terme de code propre). Malheureusement, je n'ai trouvé aucun exemple ou un tutoriel pour que. Peut-être que je recherche un mauvais mot-clé ou mal lu. Et si il n'y a pas une telle technique existent, quelles sont les meilleures pratiques pour la validation d'entrée?

Merci.

p/s: Ce fil de discussion pour trouver une meilleure façon de meilleures pratiques. Merci.

En fait il y a quelques libs déjà github.com/vekexasia/android-edittext-validator et github.com/thyrlian/AwesomeValidation

OriginalL'auteur Salehin Rafi | 2015-10-12

  1. 12

    Cette classe java implémente un TextWatcher de "voir" votre texte à modifier, en regardant tout changement apporté au texte: 

    public abstract class TextValidator implements TextWatcher {
    private final TextView textView;

    public TextValidator(TextView textView) {
        this.textView = textView;
    }

    public abstract void validate(TextView textView, String text);

    @Override
    final public void afterTextChanged(Editable s) {
        String text = textView.getText().toString();
        validate(textView, text);
    }

    @Override
    final public void 
    beforeTextChanged(CharSequence s, int start, int count, int after) {
         /* Needs to be implemented, but we are not using it. */ 
    }

    @Override
    final public void 
    onTextChanged(CharSequence s, int start, int before, int count) { 
         /* Needs to be implemented, but we are not using it. */    
    }
}

    Et dans votre EditText, vous pouvez définir que le texte de l'observateur à son port d'écoute

    editText.addTextChangedListener(new TextValidator(editText) {
    @Override public void validate(TextView textView, String text) {
       /* Insert your validation rules here */
    }
});
    Merci, très bonne solution.
    Copié à partir de: stackoverflow.com/a/11838715/1112963
    Est-il un bon modèle pour passer instance de composants d'INTERFACE utilisateur pour les classes qui ne devrait porter que sur la logique? Je pense que la meilleure façon serait de faire valider la réponse de la classe de validation et dans la mise en œuvre de la classe de l'utilisation de la valeur de manipuler l'INTERFACE utilisateur.

    OriginalL'auteur Randyka Yudhistira

  2. 6

    Une approche (dont je suis l'aide de), vous devez avoir une aide pour la validation des entrées telles que:

    1. Nullité (ou le vide)
    2. Dates
    3. Mots de passe
    4. E-mails
    5. Valeurs numériques
    6. et d'autres

    voici un extrait de mon ValidationHelper classe:

    public class InputValidatorHelper {
    public boolean isValidEmail(String string){
        final String EMAIL_PATTERN = "^[_A-Za-z0-9-\\+]+(\\.[_A-Za-z0-9-]+)*@[A-Za-z0-9-]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$";
        Pattern pattern = Pattern.compile(EMAIL_PATTERN);
        Matcher matcher = pattern.matcher(string);
        return matcher.matches();
    }

    public boolean isValidPassword(String string, boolean allowSpecialChars){
        String PATTERN;
        if(allowSpecialChars){
            //PATTERN = "((?=.*\\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%]).{6,20})";
            PATTERN = "^[a-zA-Z@#$%]\\w{5,19}$";
        }else{
            //PATTERN = "((?=.*\\d)(?=.*[a-z])(?=.*[A-Z]).{6,20})";
            PATTERN = "^[a-zA-Z]\\w{5,19}$";
        }



        Pattern pattern = Pattern.compile(PATTERN);
        Matcher matcher = pattern.matcher(string);
        return matcher.matches();
    }

    public boolean isNullOrEmpty(String string){
        return TextUtils.isEmpty(string);
    }

    public boolean isNumeric(String string){
        return TextUtils.isDigitsOnly(string);
    }

    //Add more validators here if necessary
}

    Maintenant la façon dont j'utilise cette classe est: est-ce

    InputValidatorHelper inputValidatorHelper = new InputValidatorHelper();
StringBuilder errMsg = new StringBuilder("Unable to save. Please fix the following errors and try again.\n");
//Validate and Save
boolean allowSave = true;
if (user.getEmail() == null && !inputValidatorHelper.isValidEmail(user_email)) {
    errMsg.append("- Invalid email address.\n");
    allowSave = false;
}

if (inputValidatorHelper.isNullOrEmpty(user_first_name)) {
    errMsg.append("- First name should not be empty.\n");
    allowSave = false;
}

if(allowSave){
    //Proceed with your save logic here
}

    Vous pouvez appeler votre validation à l'aide de TextWatcher qui est fixé par EditText#addTextChangedListener

    exemple:

    txtName.addTextChangedListener(new TextWatcher() {
    @Override
    public void beforeTextChanged(CharSequence s, int start, int count, int after) {
        //Do nothing
    }

    @Override
    public void onTextChanged(CharSequence s, int start, int before, int count) {

    }

    @Override
    public void afterTextChanged(Editable s) {
        validate();
    }
});
    Il y a Android spécial InputTypes pour tous les TextView types que vous avez énumérées. Pourquoi avez-vous besoin de validation?

    OriginalL'auteur PinoyCoder