Tag Archives

5 Articles
Android Validator 1.0 Released

Android Validator 1.0 Released

Android-Validator

Form Validator Library for Android

Presentation

Form Validator Library for Android is based on Zend_Validator coded in PHP. This library is intended to simplify and streamline the code to validate a form Android. For the moment, the form can just handle the EditText. Other elements will emerge in future versions.

License

Warning

With Android 4.2, the error display has undergone a display bug. Sometimes, the error fields do not appear in the display. I hope that Google will repair this problem quickly due to Android in itself and not the library.

Use

Form Validator Library is composed of 3 members :

  • Form : Contains all beings validates to treat. This is the Form that manages the display of error messages in the various elements.
  • Validate : Contains all the validators to be treated for a given element.
  • Validator : Can define a validation rule.

Validator

The validator is basic class for this library. It contains specific validation rules. To instanciate validator, you just have to do this (EmailValidator for example):

new EmailValidator(context);

For some validators, functions can change the validation rules. The validator currently contains three basic validation rules:

  • EmailValidator : Ensures that the field does contain a email address. You can also define a regex to check for a particular domain name with the function setDomainName(DomainRegexp). Example for gmail.com domain : setDomainName("gmail\\.com").
  • NotEmptyValidator : Ensures that the field is not empty.
  • UrlValidator : Ensures that the field is a valid url.
  • AlnumValidator : Ensure that the feld has Alnum characters.
  • HexValidator : Ensure that the field has Hex characters.
  • RegExpPattern : Ensure that the field does match setted Pattern.
  • Custom Validator : You can create your own Validator. To do this, you can just create class extends AbstractValidator :

    public class CustomValidator extends AbstractValidator
    {
        // Your custom error message
        private int mErrorMessage = R.string.validator_custom; 
    
        public CustomValidator(Context c) {
            super(c);
        }
    
        @Override
        public boolean isValid(Object value) {
            // Your validation Test is here.
            // Retour true if it's correct, false if it's incorrect
            return true;
        }
    
        @Override
        public String getMessage() {
            return mContext.getString(mErrorMessage);
        }
    }
    

Validate

The pure Validate class is a FIFO validator. It’s test a list of AbstractValidator for specific EditText. For some special cases, Validate is not enough. This is why there are specific validates. This is why there are two individuals with a Validate operation different from that base :

  • ConfirmValidate : Can check whether a value is identical between the two fields. Can be used to confirm the entry of a password.
  • OrTwoRequiredValidate : If one of the two target fields has a value, then it is valid. Can be used if a user must give his phone or fax.
  • Validate : The base Validate. It creates his validators stack.

Basicly, Validate can only handle a single EditText. If you want to manage several at the same time, see if ConfirmValidate or OrTwoRequiredValidate match your problem. If this is not the case, you may need to create your own Validate. To instantiate a Validate, you just have to do this:

Validate emailField = new Validate(email);

And to add Validator stack, for example to add a required Email field, you have to do this:

emailField.addValidator(new NotEmptyValidator(mContext));
emailField.addValidator(new EmailValidator(mContext));

Form

The Form class is the class teacher of the whole Library. It manages the processing of each Validate, Validator and displays the error on the EditText automatically. The Form class stores a Validate stack and then you just have to run the validation with the validate() function. To instanciate Form and add Validates, you have to do this :

Form mForm = new Form();
mForm.addValidates(emailField);
mForm.addValidates(confirmFields);
mForm.addValidates(urlField);

// ...

// Launch Validation
if(mForm.validate()){
    // success statement
}else{
    // error statement like toast, crouton, ...
}

Changelog

  • 0.1 : Create library
  • 0.2 : Add ConfirmValidate and OrTwoRequiredValidate
  • 0.3 : Extends EmailValidator with setDomainName()
  • 0.4 : Replace Validator by AbstractValidator
  • 0.5 : Fix bug in UrlValidator
  • 1.0 : Add AlnumValidator, HexValidator, RegExpValidator, ValidatorException. Fix Validate class.
Toast et Crouton, sortez vos grilles-pains !

Toast et Crouton, sortez vos grilles-pains !

by Fritte7 0 Comments

Bonjour à tous,

Je vais parler prochainement de plusieurs façon d’interagir avec l’utilisateur, pour l’informer, lui demander une confirmation ou autre. Dans un premier temps, je vais parler d’interaction passive, via Toast et Crouton, pour informer l’utilisateur. Plus tard nous parlerons de Dialogue et Notification. Qui sont, eux, des interactions active avec l’utilisateur, pour demander une confirmation, ou une action spécifique.

Pour reprendre les mots de Benjamin, il y a des ‘Best practice’ :

Quand vous êtes dans une activity, seul le toast, crouton ou une dialogue peut-être soulevée. Quand une action extérieure, ou venant d’un service a besoin d’informer l’utilisateur, utilisez la notification.

Aujourd’hui je vais vous parler cuisine, avec Toast et Crouton… Ha … On me dit dans l’oreillette que je ne suis pas sur le bon blog… Ce n’est pas grave, je vais parler de Toast et Crouton sur Android !

(Il ma fallut 2 mois et l’utilisation de crouton pour comprendre le jeux de mot personnellement…)

Le toast est une des façons d’informer l’utilisateur des actions qu’il a réalisé, où qui se serait produite en tâche de fond, qui n’a pas besoin d’interaction avec l’utilisateur. Je m’explique, quand je demande l’utilisation du GPS, mais que ce dernier est éteint, je demande l’activation via une dialogue. Comme mon précédent post (voir ici)

A la différence, un toast ne propose pas d’interaction, quand vous activez votre code pin (pour débloquer la carte sim) il vous annonce « code accepté » ou « carte sim débloqué ». Ou quand vous envoyez un tweet, il peut vous dire « Tweet bien envoyé », ça reste une information.

]1 Voici ce que donne un Toast beurré.

Cela à des avantages, mais quelques inconvénients. Si vous devez informer le client d’une exception soulevée, le toast est relativement discret et ne reste pas très longtemps affiché. Mais vous ne pouvez pas bloquer l’utilisateur avec une dialogue, car la dialogue demande une interactivité (un « ok » ou « annuler » pour la terminer).

Crouton, une librairie open-source, est une solution très facile à mettre en place, pour remédier à ce petit problème. Sans compter qu’il est beaucoup plus visible que son prédécesseur. Ce dernier s’utilise exactement de la même façon qu’un toast. Je lui ai trouvé deux défaut majeur.

]2 Allo Huston? On a un problème.

Le premier est qu’il est affiché sur la vue d’où il est appelé, en résumé, quand vous réalisez un crouton sur une dialogue, il est affiché sur le header de cette dernière. Cela peut-être plus visible mais si vous fermez directement la dialogue en lançant le message crouton avant, vous ne verrez pas le message car la dialogue sera fermée. A l’instar du Toast qui sera visible même si vous fermez l’application.

Le deuxième est qu’il demande une activity, dont je préfère largement l’utilisation du context, plutôt que l’activity elle-même. Mais c’est une question d’habitude. (Pour marquer l’utilisation de context, le lancement du Toast, la création d’une activity, une dialogue et même une notification, un context suffit amplement. Mais je pense que cela peut-être modifiable.) Voyons le code pour générer un Toast.

Toast.makeText(getApplicationContext(), "Toast de base", Toast.LENGTH_LONG).show();

Le premier paramètre est le context, le second un text qui peut-être enregistré dans le fichier strings, dans le dossier value (récupérable via getString(R.strings.votretext)).

Le dernier paramètre est le temps d’affichage (LONG ou SHORT).

Voyons Crouton maintenant.

Crouton.makeText(this, "Crouton INFO !", Style.INFO).show();

Les paramètres sont, l’activity, le texte, et un style. Le style est défini dans le projet de Crouton, qui pour rappel sont quatre simple fichiers.

Il y a 3 styles défini de base; Info, Alert, Confirm. Info et Confirm seront affichés durant 3 secondes, Alert sera affiché 5 secondes. Chacun a sa propre couleur, info est bleu, confirm vert et alert en rouge.

J’ai réalisé un projet, récupérable à cette adresse. Merci pour la lecture, et bonne journée !

Tout pour bien commencer un projet

Tout pour bien commencer un projet

by Throrïn 11 Comments

Bonjour à tous. Aujourd’hui, nous allons voir quelles sont les ressources indispensables pour bien commencer un nouveau projet Android que ce soit niveau graphique que fonctionnel ainsi que les ressources disponibles pour la publication (création de visuels simples, …).

TheUltimateAndroidLibrary.com

Parfois, il est difficile de trouver si une fonctionnalité a bien été développée pour la plateforme et surtout si on peut la réutiliser pour notre projet. C’est pour ça que le site « The Ultimate Android Library » a été créé. Ce site est un vrai répertoire de libraries pour Android. Vous trouverez une bonne partie des différents projets disponibles pour rajouter des fonctionnalités (gestion des rapports d’erreur, implémentation des différents patterns java/Android, …). Ce site est encore jeune et ne référence peut-être pas toutes les libraries existantes. Si vous en trouvez d’autres, n’hésitez pas à les leur donner afin que le site soit plus complet.

Site : http://www.theultimateandroidlibrary.com/
 

FluidUi.com

Vous souhaitez créer des mockups facilement pour telle ou telle plateforme ? Pour Smartphone mais aussi pour tablette ? Alors FluidUi est fait pour vous. Parmi tous les sites de mockup en ligne que j’ai pu tester, FluidUi est sans doute le plus simple d’utilisation mais aussi le plus complet. En plus, vous pouvez même créer des vidéos fonctionnelles pour montrer comment va fonctionner votre application. Bref, un site à garder dans vos favoris si vous voulez poser sur papier une idée et aller plus loin.

Site : https://www.fluidui.com/
 

Android App Patterns

Vous ne savez pas comment mettre en forme les empty views de vos différentes listes ou encore comment faire un visuel du pattern Dashboard assez sympa ? Alors le site Android App Patterns est fait pour vous. Dessus vous trouverez des idées pour mettre en forme les différents patterns, que ce soit pour smartphone ou pour tablette, grâce au visuel de plusieurs applications.

Site : http://www.android-app-patterns.com
 

Testeur GCM

Vous voulez tester le service GCM pour effectuer un push sur vos applications mais vous n’avez aucun serveur pour effectuer le dit test ? Alors je vous conseille de faire un tour sur ce site. Ce site va vous permettre d’effectuer des alertes GCM pour vos applications. Pour que cela fonctionne, n’oubliez pas de suivre l’introduction sir le site d’Android afin d’obtenir votre apiKey. Bien entendu, je conseille cette solution que pour vos tests de développement.

Site : http://gcm-alert.appspot.com/
 

Android UI Patterns

Cette fois ci, il ne s’agit pas d’un site de ressources mais d’une application. Dans le même genre que TheUltimateAndroidLibrary, Android UI Patterns va recenser la plupart des libaries existantes vous permettant d’utiliser les différents Patterns UI disponibles (même certains portages iphones). Vous verrez le rendu final de la library via une démo de celle-ci ainsi qu’un lien vers les sources du projet pour que vous puissiez l’utiliser.

Site : https://play.google.com/store/apps/details?id=com.groidify.uipatterns
 

Android Asset Studio

Android Asset Studio est une suite de ressources pour vos projets Android. Vous pouvez générer les icônes de vos applications, faire facilement des 9patch, générer des styles pour les actionBar ou encore générer des visuels de téléphones avec les screens de vos applications. Bref cette petite boîte à outil est celle qu’il vous faut impérativement. En plus, certains ce ces outils sont intégrés au fur et à mesure au sein du site Android Developer (pour le moment il y a juste le Device Frame generator).

Site : http://android-ui-utils.googlecode.com/hg/asset-studio/dist/index.html

 

Voilà, normalement avec tout ceci vous êtes parés pour commencer un bon projet. Si vous trouvez d’autres sites ou que vous en avez un intégrant un grand nombre de ressource utiles dans le style de ceux-ci, n’hésitez surtout pas à poster un commentaire pour en parler. Je l’ajouterai certainement à la liste des existants.

Android Form Validator Preview
Les bulles sont disponibles en natif sur Android

Android Form Validator Preview

Voici une Library de ma composition servant à gérer, comme sous le Framework Zend PHP, la validation des formulaires. Les classes ont été calquées pour s’utiliser comme sous Zend et, de plus, elle permet facilement de créer de nouveaux validateurs.

La library est encore en phase de développement. Pour les impatients, vous la trouverez ici. Aucun JAR n’est disponible pour l’instant car j’utilise les fichiers ressource Android.

Utilisez donc mon projet comme un « Library Project » ou importez directement les sources dedans tant que vous indiquez la provenance. Dans les sources, vous trouverez une Activity d’exemple vous montrant comment vous servir des différents validateurs disponibles pour l’instant à savoir :

  • ConfirmValidator : Permet de vérifier si le champ de confirmation est valide (ex : confirmation mot de passe)
  • EmailValidator : Permet de vérifier si l’email saisit est valide.
  • NotEmptyValidator : Permet de savoir si un champ a bien été saisit
  • OrTwoFieldsEmptyValidator : Permet de vérifier si, entre deux champs, au moins l’un des deux a été saisit.
  • UrlValidator : Permet de savoir si un champ URL a été correctement saisit.

Chaque Validator est rattaché à un objet Validate propre. Ce champ validate permet de créer des chaines de validation en sachant que le premier Validator entré sera le premier testé.

EditText field1;

// Création du Validate pour notre champ1 :
Validate valField1 = new Validate(field1);

// Ajout de nos différents validateurs du premier à tester au dernier
valField1.addValidator(new EmailValidator(mContext));
valField1.addValidator(new NotEmptyValidator(mContext));

Certains Validators sont particuliers et s’utilisent sur deux champs en même temps (pour le ConfirmValidator et le OrTwoFieldsEmptyValidator).

EditText password;
EditText confirmPassword;

ConfirmValidator confirmFields = new ConfirmValidator(password, confirmPassword);

Tous les Objets Validates créés sont rajoutés à un Form. Et c’est ce Form qui permettra de vérifier si votre formulaire est valide.

Form form = new Form();
form.addValidates(valField1);
form.addValidates(confirmFields);

Pour vérifier si votre formulaire est valide. Il suffit juste de faire un if tout simple :

if(form.validate())
{
    // Traitement de votre formulaire
}

Et, en cas d’erreur, des bulles apparaissent sur les champs invalides comme ceci :

]1 Les bulles sont disponibles en natif sur Android

Comme vous le voyez, son utilisation reste très simple. Ensuite, sachez que vous pouvez créer facilement de nouveaux Validators pour vos formulaires. Pour ce faire, vous avez juste à créer une classe d’héritant de Validator :

/**
 * Classe servant à créer de nouveaux Validators
 * @author throrin19
 *
 */
public abstract class Validator {

    protected Context mContext;

    public Validator(Context c){
        mContext = c;
    }

    /**
     * Permet de vérifier si la valeur passée en paramètre est valide ou non.
     * @param value
     *         {@link Object} : la valeur à valider
     * @return
     *         boolean : true si valide, false sinon.
     */
    public abstract boolean isValid(Object value);

    /**
     * Permet de récupérer le message d'erreur correspondant au validateur.
     * @return
     *         String : le message d'erreur
     */
    public abstract String getMessage();
} 

Pour les intéressés par cette library, elle est déjà disponible sur mon Github en suivant ce lien.

Utiliser une Library Externe : Html2Pdf

Aujourd’hui nous allons voir comment implanter HTML2PDF à Zend. Cet article m’a été demandé par quelques personnes ces derniers jours et justement, je pensais en parler.

HTML2PDF ainsi que d’autres libraries PHP disponibles sur internet comme PHPThumb n’utilisent pas la convention PEAR. Leur inclusion ainsi que leur utilisation ne s’effectuera pas comme les libraries utilisant la convention PEAR.

Afin d’utiliser facilement la library html2pdf, nous allons passer par une aide d’action Zend, permettant de faire la transition (Vous pouvez faire une aide de vue ou autre chose utilisant la même logique).

Pour ce faire, nous allons créer une nouvelle classe PHP dans notre library perso App. Elle s’appellera App_Helper_Html2Pdf.

/**
 * Ligne nous permettant d'utiliser la classe HTML2PDF dans souci avec Zend
 */
require_once LIBRARY_PATH.'/html2pdf/html2pdf.class.php';

class App_Helper_Html2Pdf extends Zend_Controller_Action_Helper_Abstract{

    /**
     * @var Zend_Loader_PluginLoader
     */
    public $pluginLoader;

    /**
     * Constructeur: initialisee le chargeur de classes d'aides ou plugins
     *
     * @return void
     */
    public function __construct()
    {
        $this->pluginLoader = new Zend_Loader_PluginLoader();
    }

    /**
     * Constructeur
     *
     * @param string sens portrait ou landscape
     * @param string format A4, A5, ...
     * @param string langue : fr, en, it...
     * @param boolean $unicode TRUE means that the input text is unicode (default = true)
     * @param  String $encoding charset encoding; default is UTF-8
     * @param array marges par defaut, dans l'ordre (left, top, right, bottom)
     * @return null
     */
    public function instanceClass($sens = 'P', $format = 'A4', $langue='fr', $unicode=true, $encoding='UTF-8', $marges = array(5, 5, 5, 8)){
        $html2pdf = new HTML2PDF($sens, $format, $langue, $unicode, $encoding, $marges);

        return $html2pdf;
    }

    /**
     * Fonction permettant d'appeler directement instanceClass
     */
    public function direct($sens = 'P', $format = 'A4', $langue='fr', $unicode=true, $encoding='UTF-8', $marges = array(5, 5, 5, 8)){
        return $this->instanceClass($sens, $format, $langue, $unicode, $encoding, $marges);
    }
}

Pour que Html2Pdf marche ici, nous utilisons, à la première ligne de notre fichier, un require_once pointant sur la classe principale. De là, nous sommes tranquille pour la suite, PHP va se débrouiller. Pour utiliser votre aide d’action, n’oubliez pas de rajouter la partie suivante dans votre Bootstrap.

protected function _initHelpers(){
    Zend_Controller_Action_HelperBroker::addPrefix('App_Helper');
}

Pour finir, pour récupérer votre objet PDF, vous n’aurez plus qu’à faire ceci dans un controller et vous pourrez manipuler votre objet Html2Pdf :

$html2pdf = $this->_helper->Html2Pdf('P','A4','fr', false, 'ISO-8859-15');

Maintenant vous savez comment rajouter une library externe n’utilisant pas la convention PEAR au sein d’un projet Zend. Malheureusement, avec l’arrivée de ZF2 et de PHP5.3 avec les namespaces, cela risque encore de changer.