Android Password Strength checker with seekbar

Question

How to Create Password Strength checker with seekbar in android ?

Answer 1

You can use https://github.com/VenomVendor/Password-Strength-Checker for your requirement

or use TextWatcher for checking EditText length .Like this way

 public void afterTextChanged(Editable s)
                    {
                                 if(s.length()==0)
                                        textViewPasswordStrengthIndiactor.setText("Not Entered");
                                 else if(s.length()<6)
                                        textViewPasswordStrengthIndiactor.setText("EASY");
                                 else if(s.length()<10) 
                                        textViewPasswordStrengthIndiactor.setText("MEDIUM"); 
                                 else if(s.length()<15) 
                                        textViewPasswordStrengthIndiactor.setText("STRONG");
                                   else 
                                        textViewPasswordStrengthIndiactor.setText("STRONGEST");

                               if(s.length()==20)
                                   textViewPasswordStrengthIndiactor.setText("Password Max Length Reached");
                    }
            };

Demo Help .

afterTextChanged (Editable s) - This method is called when the text has been changed. Because any changes you make will cause this method to be called again recursively, you have to be watchful about performing operations here, otherwise it might lead to infinite loop.

Answer 2

1. create a rule engine for password strength, may be a simple function which returns strength when you pass a string to it.
2. use a TextWatcher on your password edit text and pass any string entered through your rules.
3. Use returned strength value from your rule engine to set progress value and progress color of your progress bar.

Answer 3

https://github.com/yesterselga/password-strength-checker-android

is a really good example. I changed the code not to use string values. Instead of it I am using values from 0-4. here is the code

public enum PasswordStrength
{

    WEAK(0, Color.RED), MEDIUM(1, Color.argb(255, 220, 185, 0)), STRONG(2, Color.GREEN), VERY_STRONG(3, Color.BLUE);

    //--------REQUIREMENTS--------
    static int REQUIRED_LENGTH = 6;
    static int MAXIMUM_LENGTH = 6;
    static boolean REQUIRE_SPECIAL_CHARACTERS = true;
    static boolean REQUIRE_DIGITS = true;
    static boolean REQUIRE_LOWER_CASE = true;
    static boolean REQUIRE_UPPER_CASE = true;

    int resId;
    int color;

    PasswordStrength(int resId, int color)
    {
        this.resId = resId;
        this.color = color;
    }

    public int getValue()
    {
        return resId;
    }

    public int getColor()
    {
        return color;
    }

    public static PasswordStrength calculateStrength(String password)
    {
        int currentScore = 0;
        boolean sawUpper = false;
        boolean sawLower = false;
        boolean sawDigit = false;
        boolean sawSpecial = false;

        for (int i = 0; i < password.length(); i++)
        {
            char c = password.charAt(i);

            if (!sawSpecial && !Character.isLetterOrDigit(c))
            {
                currentScore += 1;
                sawSpecial = true;
            }
            else
            {
                if (!sawDigit && Character.isDigit(c))
                {
                    currentScore += 1;
                    sawDigit = true;
                }
                else
                {
                    if (!sawUpper || !sawLower)
                    {
                        if (Character.isUpperCase(c))
                            sawUpper = true;
                        else
                            sawLower = true;
                        if (sawUpper && sawLower)
                            currentScore += 1;
                    }
                }
            }
        }

        if (password.length() > REQUIRED_LENGTH)
        {
            if ((REQUIRE_SPECIAL_CHARACTERS && !sawSpecial) || (REQUIRE_UPPER_CASE && !sawUpper) || (REQUIRE_LOWER_CASE && !sawLower) || (REQUIRE_DIGITS && !sawDigit))
            {
                currentScore = 1;
            }
            else
            {
                currentScore = 2;
                if (password.length() > MAXIMUM_LENGTH)
                {
                    currentScore = 3;
                }
            }
        }
        else
        {
            currentScore = 0;
        }

        switch (currentScore)
        {
            case 0:
                return WEAK;
            case 1:
                return MEDIUM;
            case 2:
                return STRONG;
            case 3:
                return VERY_STRONG;
            default:
        }

        return VERY_STRONG;
    }

}

and how to use it:

if(PasswordStrength.calculateStrength(mViewData.mRegisterData.password). getValue() < PasswordStrength.STRONG.getValue())
{
    message = "Password should contain min of 6 characters and at least 1 lowercase, 1 uppercase and 1 numeric value";
    return null;
}

you may use PasswordStrength.VERY_STRONG.getValue() as alternative. or MEDIUM