# Introduction

**EasyValidation** is a text validation library for Android developed in Kotlin. It supports text validation for `String`, `EditText`, `TextView`, `AutoCompleteTextView`, `TextInputLayout`, and `Spinner`. It comes with lots of built-in rules for validation such as email, password, credit cards, special character validations and so on. 

### Quick String Validation

For example, you can validate any email string like this:

```kotlin
var myEmailStr = "john.doe@gmail.com"
var isValid = myEmailStr.validEmail()  // isValid will be true or false

// Or you can also validate with an error callback method
myEmailStr.validEmail() {
    // This method will be called when myEmailStr is not a valid email.
    Toast.makeText(contex, it, Toast.LENGTH_SHORT).show()
}
```

### Text View Validations

These built-in rules can also be applied on text views like `EditText`, `TextView`, `AutoCompleteTextView`, `TextInputLayout`, and `Spinner` like this.

```kotlin
var myEditText = findViewById<EditText>(R.id.myEditText)
var isValid = myEditText.nonEmpty()        // Checks if edit text is empty or not

// Or with error callback method like this
myEditText.nonEmpty() {
    // This method will be called when myEditText is empty.
    myEditText.error = it
}
```

There are around 30+ built-in rules in the **core** module library. You can check all these in Rules page.

### Multiple Validation Checks

EasyValidation also supports multiple validation checks at same time using `Validator` class like this:

```kotlin
// This example will check that whether user entered password has
// atleast one number, one spcial character, and one upper case.

var txtPassword = findViewById<EditText>(R.id.txtPassword)
txtPassword.validator()
           .nonEmpty()
           .atleastOneNumber()
           .atleastOneSpecialCharacters()
           .atleastOneUpperCase()
           .addErrorCallback { 
                txtPassword.error = it
                // it will contain the right message. 
                // For example, if edit text is empty, 
                // then 'it' will show "Can't be Empty" message
           }
           .check()
```

### Create Your Own Custom Validation Checks

You can also add your own custom by extending `BaseRule` class.

```kotlin
class HelloRule : BaseRule
{
    // add your validation logic in this method
    override fun validate(text: String) : Boolean
    {
        // Apply your validation rule logic here
        return text.contains("hello")
    }
    
    // Add your invalid check message here
    override fun getErrorMessage() : String
    {
        return "Text should contain 'hello' keyword"
    }
}
```

You can use this rule using `Validator.addRule()` method like this:

```kotlin
var myEditText = findViewById<EditText>(R.id.myEditText)
var myEditText.validator()
    .addRule(HelloRule())
    .addErrorCallback { 
        // In case of invalid, this method will be called.
        // The 'it' will be "Text should contain 'hello' keyword" message.
        myEditText.error = it
    }
    .check()
```

### Applying Rules on Multiple Views/Strings

For example, your app has a long text input form where you have got lots of input views. You might perform checks in EasyValidation like this.

#### WRONG WAY

```kotlin
var txtUsername = findViewById<EditText>(R.id.txtUsername)
var txtEmail = findViewById<EditText>(R.id.txtEmail)
var txtMobileNum = findViewById<EditText>(R.id.txtMobileNum)
var txtPassword = findViewById<EditText>(R.id.txtPassword)

if (txtUsername.nonEmpty() 
    && txtEmail.nonEmpty() 
    && txtMobileNum.nonEmpty()
    && txtPassword.nonEmpty())
{
    // All views are non-empty. You are safe to submit the data to server.
    
}
else
{
    // Any one or more fields are empty. Show the error to the user
    // to fill the whole form.
    // You don't know which field is empty. So you might need to find it.
}
```

But, EasyValidation also provides you the collection extensions to make this easier.

#### RIGHT WAY

```kotlin
var txtUsername = findViewById<EditText>(R.id.txtUsername)
var txtEmail = findViewById<EditText>(R.id.txtEmail)
var txtMobileNum = findViewById<EditText>(R.id.txtMobileNum)
var txtPassword = findViewById<EditText>(R.id.txtPassword)

// Empty check
nonEmptyList(txtUsername, txtEmail, txtMobileNum, txtPassword) { view, msg ->
    view.error = msg
    // The view will contain the exact view which is empty
    // The msg will contain the error message 
}

// Min-length Check - all views should have atleast 5 characters
minLengthList(5, txtUsername, txtEmail, txtMobileNum, txtPassword) { view, msg ->
    view.error = msg
    // The view will contain the exact view which is less than 5 characters
    // The msg will contain the error message 
}
```

&#x20;You can apply all the built-in rules just by adding `List` suffix in the rule name. For example, `nonEmpty` becomes `nonEmptyList`, the `validEmail` becomes `validEmailList` and so on.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://wajahatkarim.gitbook.io/easyvalidation/master.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.