Codechain Dev

Sunday, January 11, 2026

Top AI Trends Developers Should Focus On in 2026

By Salil · Published January 11, 2026 No comments

Artificial Intelligence is rapidly changing modern software development.

Developers are now using AI tools for coding, debugging, testing, automation, documentation, and deployment workflows.

But while AI tools are improving productivity, developers still need strong engineering fundamentals to build scalable and secure systems.

In this article, we will explore the most important AI trends developers should understand in 2026.

1. AI Coding Assistants Are Becoming Standard

Tools like ChatGPT, GitHub Copilot, Cursor, Claude, and Gemini are now part of daily development workflows.

Developers use them for:

Generating boilerplate code
Creating APIs
Writing SQL queries
Refactoring functions
Debugging errors
Generating documentation

Example Express API:


app.get("/users", async (req, res) => {
  const users = await prisma.user.findMany();
  res.json(users);
});

AI tools can generate this structure quickly, helping developers save time.

2. AI Agents and Automation

AI systems are moving beyond simple chat interfaces.

Modern AI agents can:

Read project documentation
Generate pull requests
Create tickets
Review code
Automate workflows

This improves developer productivity significantly.

However, developers still need to review architecture, security, and performance carefully.

3. AI Is Changing Search and Documentation

Developers are increasingly using AI tools instead of traditional search engines for technical help.

AI can summarize:

Framework documentation
Error messages
API responses
Configuration issues

But official documentation is still important because AI responses can sometimes be outdated or incorrect.

4. Edge AI and On-Device Processing

One of the biggest trends in 2026 is Edge AI.

Instead of sending all data to cloud servers, applications are processing AI tasks directly on devices.

Benefits include:

Lower latency
Better privacy
Offline support
Reduced server cost

This is especially important for:

Mobile apps
IoT devices
AI assistants
Real-time translation apps

5. AI in Debugging and Testing

AI tools are helping developers debug applications faster.

Developers can now analyze:

Stack traces
Crash logs
Performance bottlenecks
API failures

AI can also generate:

Unit tests
Mock responses
Validation schemas

Example JSON schema:


{
  "name": "string",
  "email": "string",
  "age": "number"
}

6. AI Security and Cybersecurity

As AI tools become more powerful, security becomes even more important.

AI can help developers:

Identify vulnerabilities
Detect suspicious patterns
Improve authentication systems
Analyze logs

But AI-generated code should always be reviewed carefully.

Common problems include:

Insecure dependencies
Exposed secrets
Weak validation logic
SQL injection risks

7. Real Challenges Developers Face

AI tools are powerful, but they also introduce new challenges.

Common Problems

Hallucinated functions
Incorrect code suggestions
Large API costs
Over-dependence on AI
Context limitations

Developers should always:

Test generated code
Review architecture
Optimize performance
Understand the implementation

8. Skills Developers Should Focus On

AI is changing workflows, but strong fundamentals still matter.

Developers should continue improving:

JavaScript fundamentals
React and React Native
Backend development
Database optimization
System architecture
Performance optimization
Security practices

FAQ

Will AI replace developers?

No. AI improves productivity, but developers are still required for architecture, debugging, optimization, and decision-making.

Should beginners use AI tools?

Yes, but beginners should also focus on understanding core programming concepts.

What is the biggest AI trend in 2026?

AI-assisted development workflows and Edge AI are among the biggest trends developers should watch.

Final Thoughts

AI is transforming software development rapidly.

The developers who succeed in 2026 will be those who combine:

Strong engineering fundamentals
Practical development experience
Modern AI-assisted workflows

AI should improve developer productivity — not replace engineering understanding.

CodeChain Dev — Build Modern Products. Solve Real Problems.

JSON Parsing Best Practices for Modern Web and Mobile Applications

By Salil · Published January 11, 2026 No comments

JSON is one of the most widely used data formats in modern software development.

It is commonly used for:

REST APIs
Mobile applications
Frontend applications
Configuration files
Data exchange between services

Although JSON parsing looks simple, improper handling can cause crashes, performance issues, and invalid application states.

In this article, we will explore practical JSON parsing techniques, common mistakes, performance optimization strategies, and debugging approaches for modern applications.

Why Proper JSON Parsing Matters

Many developers simply use:


JSON.parse(data)

But in production applications, this is often not enough.

Common problems include:

Invalid API responses
HTML returned instead of JSON
Unexpected null values
Incorrect data types
Large payload performance issues

Proper validation and error handling improve application stability and user experience.

Common JSON Parsing Error

One of the most common errors developers see is:


Unexpected token < in JSON at position 0

This usually happens when the server returns HTML instead of JSON.

For example:

404 error pages
Authentication redirects
Server downtime
Invalid API routes

Safe JSON Parsing Example

Instead of directly parsing responses, validate the content type first.


const safeParse = async (response) => {
  const contentType = response.headers.get("content-type");

  if (!contentType?.includes("application/json")) {
    throw new Error("Expected JSON response");
  }

  try {
    return await response.json();
  } catch (error) {
    console.error("Invalid JSON:", error);
    throw new Error("JSON parsing failed");
  }
};

This approach prevents many common runtime crashes.

Why JSON Validation Is Important

APIs may return incomplete or invalid data.

Without validation, applications can display:

undefined values
broken UI states
incorrect calculations
application crashes

Validation libraries like:

help developers validate API responses safely.

Handling Unicode and Emoji Data

Modern applications often support:

Unicode characters
Emoji content
International languages

Developers should avoid manually constructing JSON strings.

Always use:


JSON.stringify(data)

This ensures proper escaping and encoding.

Date Handling Best Practices

JSON does not support a native Date type.

To avoid timezone and formatting issues, use ISO 8601 format.

Example:


2026-01-23T10:30:00Z

Using a standardized date format improves consistency across frontend and backend systems.

Performance Optimization Tips

1. Avoid Repeated Parsing

If the same JSON data is used repeatedly, cache the parsed object instead of calling:


JSON.parse()

multiple times.

2. Minify JSON for Production

Large formatted payloads increase bandwidth usage.

Minified JSON improves performance and reduces network transfer size.

3. Use Streaming for Large Files

Very large JSON datasets can block the main thread.

For large files, developers can use streaming parsers such as:

JSONStream
oboe.js

JSON Parsing in Mobile Applications

Mobile apps should avoid heavy JSON parsing on the UI thread.

Large payloads can cause:

UI freezes
Frame drops
Slow rendering
Increased memory usage

Background processing and optimized payload handling improve app performance significantly.

Useful JSON Debugging Features

Modern JSON tools should support:

Syntax highlighting
Tree view
Validation
Error line detection
Large file handling

These features improve debugging speed and developer productivity.

Example JSON Structure


{
  "user": {
    "id": 1,
    "name": "Salil",
    "role": "Developer"
  }
}

FAQ

Why does JSON parsing fail?

JSON parsing usually fails because of invalid syntax, unexpected server responses, or incorrect data formatting.

Should developers validate API responses?

Yes. Validation improves stability and prevents invalid data from reaching the UI.

What is the best date format for JSON?

ISO 8601 is the recommended format for consistency across systems.

Final Thoughts

JSON parsing is a fundamental part of modern application development.

Proper validation, safe parsing, optimized handling, and structured debugging approaches improve application reliability and performance.

Developers should treat JSON handling as an important engineering practice instead of a simple utility task.

CodeChain Dev — Build Modern Products. Solve Real Problems.

Friday, January 24, 2025

Clean Code Principles Every Developer Should Follow in 2026

By Salil · Published January 24, 2025 No comments

Clean code is one of the most important skills in modern software development.

As applications become larger and more complex, developers need codebases that are:

Readable
Maintainable
Scalable
Easy to debug

Writing clean code improves collaboration, reduces bugs, and makes long-term maintenance easier.

In this article, we will explore practical clean code principles developers should follow in 2026.

What Is Clean Code?

Clean code is code that is easy to understand and easy to modify.

Good code should clearly explain:

What the system is doing
Why the logic exists
How components interact

Readable code reduces confusion during debugging and feature development.

Why Clean Code Matters

1. Faster Development

Well-structured code makes it easier to add new features without breaking existing functionality.

2. Easier Debugging

Clear logic and proper structure make bugs easier to identify and fix.

3. Better Team Collaboration

Developers can understand and contribute to clean codebases more quickly.

4. Improved Maintainability

Applications often grow for years after launch.

Clean architecture helps teams maintain and scale projects more efficiently.

Important Clean Code Principles

Use Meaningful Variable Names

Bad example:


const a = true;

Better example:


const isUserAuthenticated = true;

Descriptive naming improves readability significantly.

Keep Functions Small

Functions should focus on a single responsibility.

Large functions become difficult to debug and maintain.

Example:


function calculateTotal(price, tax) {
  return price + tax;
}

Avoid Repeated Logic

Duplicate code increases maintenance complexity.

Reusable utility functions improve consistency and reduce bugs.

Write Modular Components

Modern frontend frameworks like React and React Native work best with reusable components.

Modular architecture improves scalability and testing.

Example of Clean Service Structure


class UserService {
  constructor() {
    this.cache = new UserCache();
  }

  async getUser(id) {
    const cachedUser = this.cache.get(id);

    if (cachedUser) {
      return cachedUser;
    }

    const user = await database.users.find(id);

    if (user) {
      this.cache.set(id, user);
    }

    return user;
  }
}

This example demonstrates:

Clear naming
Separated responsibilities
Readable structure
Performance optimization through caching

Testing and Automation

Clean code is closely connected with testing and automation.

Developers should use:

Unit testing
Linting
Formatting tools
CI/CD pipelines

Automation helps maintain consistency across projects.

Role of AI in Clean Code

AI tools are becoming part of modern development workflows.

Tools like ChatGPT, GitHub Copilot, and Claude can help developers:

Refactor code
Detect code smells
Improve readability
Suggest optimizations

However, developers should still review generated code carefully.

AI improves productivity, but engineering understanding remains essential.

Common Clean Code Mistakes

Large functions with multiple responsibilities
Poor variable naming
Duplicate logic
Unused code
Inconsistent formatting
Lack of testing

Best Tools for Maintaining Clean Code

ESLint
Prettier
SonarQube
Jest
TypeScript

These tools help maintain code quality and consistency.

Clean Code in React and React Native

Frontend applications benefit heavily from clean structure.

Developers should focus on:

Reusable components
Proper state management
Performance optimization
Folder organization
API abstraction

This improves scalability for large applications.

FAQ

What is the biggest benefit of clean code?

Clean code improves maintainability, readability, and debugging efficiency.

Does clean code improve performance?

In many cases, cleaner architecture and optimized logic improve application performance.

Should beginners focus on clean code?

Yes. Developing clean coding habits early helps developers build better long-term projects.

Final Thoughts

Clean code is not about perfection.

It is about creating software that developers can understand, maintain, and improve over time.

By focusing on readability, modularity, testing, and consistency, developers can build scalable and production-ready applications.

CodeChain Dev — Build Modern Products. Solve Real Problems.

Sunday, January 5, 2025

How Ethereum Smart Contract Deposits Work in Modern Crypto Platforms

By Salil · Published January 05, 2025 No comments

Ethereum smart contracts are one of the most important technologies in modern blockchain systems.

They enable decentralized applications (dApps), automated payments, token systems, staking platforms, and decentralized finance (DeFi) protocols.

However, smart contract transactions also create challenges for crypto exchanges, wallets, and payment tracking systems.

In this article, we will explore how Ethereum smart contract deposits work, why exchanges sometimes reject them, and how modern platforms handle blockchain payment tracking in 2026.

What Is a Smart Contract?

A smart contract is a self-executing program deployed on the Ethereum blockchain.

It automatically performs actions when predefined conditions are met.

Smart contracts are commonly used for:

Token transfers
Decentralized exchanges
NFT marketplaces
Staking systems
Automated payments

Direct ETH Transfers vs Smart Contract Transfers

Direct ETH Transfer

A direct Ethereum transaction is simple:


Wallet A → Wallet B

The blockchain clearly records:

Sender address
Receiver address
Transfer amount

This makes deposit tracking straightforward.

Smart Contract Transfer

Smart contract transactions work differently.

Instead of directly transferring ETH between wallets, the transaction interacts with a contract.

Example:


Wallet A → Smart Contract → Wallet B

The transfer may happen internally during contract execution.

This makes payment tracking more complicated for exchanges and wallet systems.

Why Exchanges Sometimes Reject Smart Contract Deposits

Many exchanges assign unique Ethereum deposit addresses to users.

Their backend systems monitor these addresses for incoming deposits.

However, smart contract deposits can be difficult to identify because:

Transfers may happen internally
Transaction logs can be complex
Some systems only monitor direct transfers
Internal contract calls require additional parsing

As a result, some exchanges display warnings such as:

Do not send funds from smart contracts.

Common Deposit Tracking Methods

1. Direct Transaction Monitoring

The simplest method is monitoring direct ETH transfers.

Example:


from: 0x123...
to: 0x456...
value: 1 ETH

This method is fast and efficient.

However, it may fail to detect complex smart contract interactions.

2. Balance Difference Tracking

Some systems monitor wallet balances after every block.

Formula:

:contentReference[oaicite:1]{index=1}

This approach detects incoming funds even if the transfer is hidden inside smart contract execution.

But it also creates limitations:

Higher infrastructure cost
More blockchain requests
Difficult sender identification
Problems during simultaneous deposits

3. Event Log Parsing

Modern blockchain systems often parse smart contract events.

Ethereum contracts emit logs such as:


Transfer(address from, address to, uint256 amount)

Backend systems scan these events to identify deposits accurately.

This method is widely used by modern exchanges and blockchain analytics systems.

Challenges in Smart Contract Deposit Tracking

Internal transactions are difficult to trace
High blockchain indexing costs
Large transaction volume
Complex contract execution paths
Node synchronization delays

These issues become more significant for large exchanges handling thousands of transactions per minute.

How Modern Platforms Handle Ethereum Deposits

Modern crypto platforms use advanced infrastructure such as:

Blockchain indexers
Event parsers
WebSocket listeners
Real-time monitoring systems
Transaction confirmation queues

Popular blockchain infrastructure providers include:

Alchemy
Infura
QuickNode

These services help platforms track deposits more efficiently.

Security Considerations

Blockchain payment systems must also handle:

Double-spend prevention
Re-org handling
Pending transaction monitoring
Fraud detection
Confirmation validation

Most exchanges wait for multiple confirmations before crediting deposits.

Example Ethereum Deposit Flow


User Wallet
   ↓
Smart Contract
   ↓
Exchange Deposit Address
   ↓
Blockchain Listener
   ↓
Backend Verification
   ↓
User Balance Updated

Future of Smart Contract Payment Tracking

Blockchain infrastructure is improving rapidly.

Modern indexing systems and AI-assisted blockchain analytics are making smart contract tracking faster and more reliable.

Layer 2 scaling solutions and improved Ethereum tooling are also reducing infrastructure complexity.

FAQ

Why do exchanges reject smart contract deposits?

Some exchanges only monitor direct ETH transfers and cannot reliably detect internal smart contract transactions.

What is the safest way to send ETH to an exchange?

Using a direct wallet-to-wallet transfer is usually the safest option unless the exchange explicitly supports smart contract deposits.

How do exchanges detect deposits?

Exchanges use blockchain monitoring systems, event parsing, and transaction indexing to identify incoming funds.

Final Thoughts

Ethereum smart contracts enable powerful blockchain applications, but they also increase payment tracking complexity.

Modern crypto platforms solve these problems using event parsing, blockchain indexing, and real-time monitoring infrastructure.

As blockchain ecosystems continue evolving, smart contract deposit handling will become faster, more scalable, and more reliable.

CodeChain Dev — Build Modern Products. Solve Real Problems.

Tuesday, October 13, 2020

1. What is Java?

Java is a high-level, object-oriented, platform-independent programming language. It follows the principle of Write Once, Run Anywhere because Java code is compiled into bytecode that runs on the JVM.

2. What is JVM, JRE, and JDK?

Term	Meaning
JVM	Java Virtual Machine runs Java bytecode.
JRE	Java Runtime Environment contains JVM and libraries required to run Java programs.
JDK	Java Development Kit contains JRE plus development tools like compiler.

3. What is the difference between Class and Object?

A class is a blueprint. An object is an instance of that class.


class User {
  String name;
}

User user = new User();
user.name = "Salil";

4. What are the main OOP concepts in Java?

Encapsulation
Inheritance
Polymorphism
Abstraction

5. What is method overloading?

Method overloading means having multiple methods with the same name but different parameters.


class Calculator {
  int add(int a, int b) {
    return a + b;
  }

  double add(double a, double b) {
    return a + b;
  }
}

6. What is method overriding?

Method overriding happens when a child class provides its own implementation of a method already defined in the parent class.


class Animal {
  void sound() {
    System.out.println("Animal sound");
  }
}

class Dog extends Animal {
  @Override
  void sound() {
    System.out.println("Dog barks");
  }
}

7. What is the difference between overloading and overriding?

Overloading	Overriding
Same method name with different parameters	Same method name and parameters in child class
Compile-time polymorphism	Runtime polymorphism
Can happen in same class	Requires inheritance

8. What is inheritance?

Inheritance allows one class to acquire properties and methods of another class.


class Vehicle {
  void start() {
    System.out.println("Vehicle started");
  }
}

class Car extends Vehicle {
}

9. How can we stop inheritance in Java?

Use the final keyword with a class.


final class PaymentService {
}

10. What is encapsulation?

Encapsulation means wrapping data and methods together and restricting direct access using private variables and public methods.


class Account {
  private double balance;

  public double getBalance() {
    return balance;
  }
}

11. What is abstraction?

Abstraction hides implementation details and shows only essential behavior.


abstract class Shape {
  abstract void draw();
}

12. What is the difference between abstract class and interface?

Abstract Class	Interface
Can have abstract and non-abstract methods	Mainly defines contracts
Supports constructors	Does not support constructors
Used for shared base behavior	Used for capability-based design

13. What is the difference between == and equals()?

== compares object references. equals() compares object content when properly overridden.


String s1 = "Java";
String s2 = new String("Java");

System.out.println(s1 == s2);      // false
System.out.println(s1.equals(s2)); // true

14. What is String Pool?

String Pool is a special memory area where Java stores string literals to optimize memory usage.


String a = "Java";
String b = "Java";

System.out.println(a == b); // true

15. Difference between String, StringBuilder and StringBuffer

Type	Use
String	Immutable text
StringBuilder	Mutable and faster, not thread-safe
StringBuffer	Mutable and thread-safe

16. What is exception handling?

Exception handling allows Java programs to handle runtime errors gracefully using try, catch, finally, throw, and throws.


try {
  int result = 10 / 0;
} catch (ArithmeticException e) {
  System.out.println("Cannot divide by zero");
}

17. Checked vs Unchecked Exceptions

Checked Exception	Unchecked Exception
Checked at compile time	Occurs at runtime
Example: IOException	Example: NullPointerException

18. What is HashMap?

HashMap stores data in key-value pairs. It allows fast lookup using hashing.


Map<String, Integer> map = new HashMap<>();
map.put("Java", 1);
System.out.println(map.get("Java"));

19. Difference between ArrayList and LinkedList

ArrayList	LinkedList
Fast for searching	Fast for insertion/deletion
Uses dynamic array	Uses linked nodes

20. What is multithreading?

Multithreading allows multiple tasks to run concurrently in a Java program.


class MyThread extends Thread {
  public void run() {
    System.out.println("Thread running");
  }
}

21. What is synchronization?

Synchronization prevents multiple threads from accessing shared resources at the same time.


synchronized void updateBalance() {
  // critical section
}

22. What is garbage collection?

Garbage collection automatically removes unused objects from memory.

This helps prevent memory leaks and improves memory management.

23. What are Java 8 features?

Lambda expressions
Stream API
Functional interfaces
Default methods
Optional class

24. What is Stream API?

Stream API is used to process collections in a functional style.


List<String> names = Arrays.asList("Java", "Kotlin", "Android");

names.stream()
     .filter(name -> name.startsWith("J"))
     .forEach(System.out::println);

25. What is an immutable class?

An immutable class cannot be changed after object creation.


final class Employee {
  private final String name;

  Employee(String name) {
    this.name = name;
  }

  public String getName() {
    return name;
  }
}

Java Interview Preparation Tips

Focus on OOP concepts first
Practice collections deeply
Understand JVM basics
Write small code examples
Revise exception handling
Practice multithreading questions
Prepare Java 8 features

FAQ

Is Java still useful in 2026?

Yes. Java is widely used in enterprise software, Android projects, fintech systems, backend services, and large-scale applications.

Which Java topic is most important for interviews?

OOP, collections, exception handling, multithreading, JVM, and Java 8 features are very important.

Is Java required for Android development?

Kotlin is now preferred for Android, but Java is still useful because many existing Android projects are written in Java.

About the Author

Salil Jha is a Full Stack and Mobile Developer with experience in Android, React Native, blockchain applications, crypto exchange platforms, SaaS products, and scalable backend systems.

Final Thoughts

Java interview preparation becomes easier when you understand concepts with practical examples.

Do not only memorize answers. Practice small programs, understand real use cases, and revise core Java fundamentals regularly.

CodeChain Dev — Build Modern Products. Solve Real Problems.

Tuesday, October 6, 2020

How to Implement Color Picker Dialog in Android Using AmbilWarna Library

By Salil · Published October 06, 2020 No comments

Color picker components are useful in many Android applications such as drawing apps, theme customization apps, note applications, and profile customization screens.

In this tutorial, we will learn how to implement a simple color picker in Android using the AmbilWarna library.

We will:

Add the AmbilWarna dependency
Open a color picker dialog
Select colors dynamically
Change the background color of the layout

What Is AmbilWarna?

AmbilWarna is a lightweight Android color picker library that provides a simple and customizable color selection dialog.

It is easy to integrate and works well for basic color selection use cases.

Step 1 — Add Dependency

Open your build.gradle file and add the following dependency:


implementation 'yuku.ambilwarna:ambilwarna:2.0.1'

After adding the dependency, sync your Gradle project.

Step 2 — Create Layout File

Create the UI inside activity_main.xml.


<?xml version="1.0" encoding="utf-8"?>

<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:id="@+id/layout"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <Button
        android:id="@+id/button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Open Color Picker"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent"/>

</androidx.constraintlayout.widget.ConstraintLayout>

Step 3 — Implement Color Picker Logic

Now open MainActivity.java and add the following code:


package com.example.colorpicker;

import android.os.Bundle;
import android.view.View;
import android.widget.Button;

import androidx.appcompat.app.AppCompatActivity;
import androidx.constraintlayout.widget.ConstraintLayout;
import androidx.core.content.ContextCompat;

import yuku.ambilwarna.AmbilWarnaDialog;

public class MainActivity extends AppCompatActivity {

    ConstraintLayout layout;
    Button button;

    int defaultColor;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        layout = findViewById(R.id.layout);
        button = findViewById(R.id.button);

        defaultColor = ContextCompat.getColor(
                MainActivity.this,
                R.color.purple_500
        );

        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                openColorPicker();
            }
        });
    }

    private void openColorPicker() {

        AmbilWarnaDialog colorPicker =
                new AmbilWarnaDialog(
                        this,
                        defaultColor,
                        new AmbilWarnaDialog.OnAmbilWarnaListener() {

                            @Override
                            public void onCancel(AmbilWarnaDialog dialog) {
                            }

                            @Override
                            public void onOk(
                                    AmbilWarnaDialog dialog,
                                    int color
                            ) {

                                defaultColor = color;

                                layout.setBackgroundColor(defaultColor);
                            }
                        });

        colorPicker.show();
    }
}

How This Implementation Works

The application works in the following steps:

User clicks the button
AmbilWarna dialog opens
User selects a color
Selected color is returned
Background color updates dynamically

Expected Output

After running the application:

A button appears in the center of the screen
Clicking the button opens the color picker dialog
Selecting a color changes the activity background color

Common Mistakes Developers Make

1. Missing Dependency

If the library is not added correctly, Gradle sync will fail.

2. Wrong View ID

Ensure the IDs inside XML match the IDs used in Java code.

3. Theme Compatibility Issues

Some older Android themes may create UI inconsistencies with dialog appearance.

Modern Android Improvement Suggestions

For production-grade Android applications, developers can improve this implementation by:

Using Kotlin instead of Java
Using ViewBinding
Saving selected color using SharedPreferences
Supporting dark mode
Adding color preview components

Example: Saving Selected Color


SharedPreferences.Editor editor =
        getSharedPreferences("settings", MODE_PRIVATE).edit();

editor.putInt("selected_color", defaultColor);
editor.apply();

This allows the application to restore the selected color after reopening the app.

FAQ

Can this library work with Kotlin?

Yes. AmbilWarna works with both Java and Kotlin Android projects.

Can I customize the color picker dialog?

Yes. Developers can modify dialog appearance or use alternative libraries for advanced customization.

Is AmbilWarna suitable for production apps?

Yes, for basic color selection functionality. However, large applications may require more advanced UI customization.

Conclusion

Implementing a color picker in Android is simple using the AmbilWarna library.

This approach is useful for applications that require dynamic UI customization or drawing-related features.

Modern Android applications can further improve this implementation using Kotlin, Material Design components, and persistent theme settings.

About the Author

Salil Jha is a Full Stack and Mobile Developer with experience in Android, React Native, scalable SaaS platforms, fintech applications, and developer tooling systems.

CodeChain Dev — Build Modern Products. Solve Real Problems.

Sunday, October 4, 2020

How to Request Runtime Permissions in Android Using EasyPermissions Library

By Salil · Published October 04, 2020 No comments

Runtime permissions became mandatory in Android starting from Android Marshmallow (API level 23).

Instead of automatically granting permissions during installation, Android now asks users to approve dangerous permissions while the app is running.

Managing permissions manually can become repetitive and difficult, especially when handling multiple permissions and permanently denied states.

In this tutorial, we will learn how to use the EasyPermissions library in Android to request runtime permissions more efficiently.

What Is EasyPermissions?

EasyPermissions is a lightweight Android library developed to simplify runtime permission handling.

It helps developers:

Request multiple permissions
Handle permission callbacks
Show rationale dialogs
Handle permanently denied permissions
Redirect users to app settings

Why Runtime Permissions Are Important

Dangerous permissions allow access to sensitive device features such as:

Camera
Storage
Location
Microphone
Contacts

Android requires developers to request these permissions during runtime for better user privacy and security.

Step 1 — Add Dependency

Open your build.gradle file and add the following dependency:


implementation 'pub.devrel:easypermissions:3.0.0'

After adding the dependency, sync your Gradle project.

Step 2 — Add Permissions in AndroidManifest.xml

Open AndroidManifest.xml and add the required permissions.


<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />

These permissions are required for camera access and reading device storage.

Step 3 — Create Layout File

Create the UI inside activity_main.xml.


<?xml version="1.0" encoding="utf-8"?>

<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <Button
        android:id="@+id/button_open_camera"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Open Camera"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent"/>

</androidx.constraintlayout.widget.ConstraintLayout>

Step 4 — Implement Permission Handling

Open MainActivity.java and add the following code:


package com.example.easypermissionexample;

import android.Manifest;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;

import java.util.List;

import pub.devrel.easypermissions.AfterPermissionGranted;
import pub.devrel.easypermissions.AppSettingsDialog;
import pub.devrel.easypermissions.EasyPermissions;

public class MainActivity extends AppCompatActivity
        implements EasyPermissions.PermissionCallbacks {

    private static final int REQUEST_CODE = 123;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Button buttonOpenCamera =
                findViewById(R.id.button_open_camera);

        buttonOpenCamera.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                openCamera();
            }
        });
    }

    @AfterPermissionGranted(REQUEST_CODE)
    private void openCamera() {

        String[] perms = {
                Manifest.permission.CAMERA,
                Manifest.permission.READ_EXTERNAL_STORAGE
        };

        if (EasyPermissions.hasPermissions(this, perms)) {

            Toast.makeText(
                    this,
                    "Permissions Granted",
                    Toast.LENGTH_SHORT
            ).show();

        } else {

            EasyPermissions.requestPermissions(
                    this,
                    "Camera and Storage permissions are required",
                    REQUEST_CODE,
                    perms
            );
        }
    }

    @Override
    public void onPermissionsGranted(
            int requestCode,
            @NonNull List<String> perms
    ) {
    }

    @Override
    public void onPermissionsDenied(
            int requestCode,
            @NonNull List<String> perms
    ) {

        if (EasyPermissions.somePermissionPermanentlyDenied(
                this,
                perms
        )) {

            new AppSettingsDialog.Builder(this)
                    .build()
                    .show();
        }
    }

    @Override
    public void onRequestPermissionsResult(
            int requestCode,
            @NonNull String[] permissions,
            @NonNull int[] grantResults
    ) {

        super.onRequestPermissionsResult(
                requestCode,
                permissions,
                grantResults
        );

        EasyPermissions.onRequestPermissionsResult(
                requestCode,
                permissions,
                grantResults,
                this
        );
    }
}

How This Implementation Works

The permission workflow is:

User clicks the button
Application checks permissions
If permissions are granted, camera logic runs
If permissions are denied, Android permission dialog appears
If user permanently denies permissions, app settings dialog opens

Handling Permanently Denied Permissions

When users check:

Don't ask again

Android will stop showing the permission dialog.

EasyPermissions helps redirect users to:

App Settings
Permission Management Screen

This improves user experience significantly.

Common Mistakes Developers Make

1. Forgetting Manifest Permissions

Runtime requests will fail if permissions are missing inside the manifest file.

2. Not Handling Denied Permissions

Applications should gracefully handle denied states instead of crashing.

3. Requesting Too Many Permissions

Request only the permissions required for the feature currently being used.

Modern Android Permission Recommendations

For production Android applications:

Request permissions only when needed
Explain clearly why permissions are required
Handle denied states properly
Support Android 13+ permission changes
Use Activity Result APIs when possible

EasyPermissions vs Manual Permission Handling

EasyPermissions	Manual Handling
Cleaner code	More boilerplate
Built-in rationale support	Manual dialog management
Settings redirection support	Manual intent handling

FAQ

Is EasyPermissions still useful in 2026?

Yes. It remains useful for simplifying Android runtime permission handling.

Can I request multiple permissions together?

Yes. EasyPermissions supports requesting multiple permissions in a single dialog.

What happens if the user permanently denies permission?

The application should redirect users to App Settings so they can manually grant permissions.

Conclusion

Runtime permission handling is an important part of modern Android development.

The EasyPermissions library simplifies permission requests, improves readability, and helps developers manage permission states efficiently.

Using proper permission handling improves application security, user trust, and overall user experience.

About the Author

Salil Jha is a Full Stack and Mobile Developer with experience in Android, React Native, scalable SaaS products, fintech applications, and developer tooling platforms.

CodeChain Dev — Build Modern Products. Solve Real Problems.