Sunday, May 24, 2026

React Native Interview Preparation Guide For 7+ Years Experienced Developers

By Salil · Published May 24, 2026 No comments

The React Native ecosystem has evolved rapidly over the last few years. Earlier, companies mainly looked for developers who could build screens, integrate APIs, and deliver features quickly. But today, especially for senior-level roles, the expectations are much higher.

If you have 7+ years of experience, interviewers are not just checking whether you can write React Native code. They expect you to think like an architect, mentor, problem solver, and product-minded engineer.

Modern companies want developers who can:

Build scalable mobile architectures
Handle performance optimization
Debug production issues
Improve app security
Work with CI/CD pipelines
Understand native Android/iOS integrations
Lead teams and code reviews
Design maintainable systems
Improve app stability and user experience

This guide will help experienced React Native developers prepare properly for senior-level interviews.

What Companies Expect From Senior React Native Developers

At the senior level, companies focus more on:

1. Architecture Understanding

You should know:

Modular architecture
Feature-based folder structure
Scalable state management
API layer separation
Offline-first design
Dependency injection concepts
Reusable component systems

Interviewers often ask:

“How would you structure a large-scale React Native application?”

They want to understand how you think beyond screens and components.

2. Performance Optimization

This is one of the most important areas.

You should know how to optimize:

FlatList rendering
Memory usage
Re-renders
Image optimization
Animation performance
Navigation performance
Bundle size
App startup time

Important concepts:

React.memo
useMemo
useCallback
Hermes engine
JSI
Fabric architecture
Lazy loading
Virtualization

Example interview question:

“Why does FlatList lag in production and how would you optimize it?”

3. Native Module Understanding

Many companies now expect senior developers to understand native integrations.

You should know:

Android Side

Kotlin basics
Gradle
Build variants
Deep linking
Push notification setup
ProGuard
APK/AAB generation

iOS Side

CocoaPods
Xcode basics
Provisioning profiles
Certificates
App signing

Even if you are not a full native developer, you should be comfortable debugging native issues.

4. State Management

Senior developers should know when to use:

Redux Toolkit
Zustand
Context API
React Query / TanStack Query
MobX

Interviewers may ask:

“Why would you choose Zustand over Redux?”

“How do you manage caching and API synchronization?”

5. Security Concepts

Security has become very important in fintech, healthcare, and enterprise apps.

You should know:

Token storage
Secure storage
SSL pinning
Root/jailbreak detection
API encryption basics
Deep link security
Biometric authentication
Session handling

6. Real Production Experience

Senior interviews focus heavily on real-world experience.

Be ready to explain:

Biggest production issue you solved
App crash debugging experience
Performance bottlenecks
Release management
CI/CD setup
Firebase integration
Push notification handling
Store deployment issues

Real experience matters more than theoretical answers.

Important Topics To Prepare

React Native Core

Bridge architecture
New architecture
Fabric
TurboModules
JSI
Native modules
Hooks lifecycle
Reconciliation

Navigation

React Navigation
Deep linking
Nested navigation
Performance handling
Authentication flow

API Handling

Axios interceptors
Token refresh flow
Error handling
Retry mechanisms
Pagination
WebSockets

Performance

Memory leaks
Re-render optimization
Profiling
Flipper
Hermes
Animation optimization

Testing

Jest
React Native Testing Library
Unit testing
Integration testing
E2E testing basics

DevOps & Deployment

Fastlane
Firebase App Distribution
Play Store release flow
App Store release flow
Environment management
CI/CD pipelines

Common Senior-Level Interview Questions

Architecture

Q1. How do you structure a scalable React Native application?

A good answer should include:

Feature-based architecture
Separation of concerns
Reusable UI components
API abstraction
Centralized state management
Environment configuration

Performance

Q2. How do you optimize FlatList for large datasets?

Key points:

getItemLayout
keyExtractor
removeClippedSubviews
Pagination
Memoized item components
Avoid inline functions

State Management

Q3. Redux vs Zustand — which one would you choose?

A strong answer:

Redux for enterprise-level predictability
Zustand for lightweight simplicity
Depends on project complexity

Debugging

Q4. Describe a production issue you solved.

This question is extremely important.

Use STAR format:

Situation
Task
Action
Result

Example:

App crashing on Android 14
Investigated native logs
Found issue in third-party SDK
Patched and released hotfix

Behavioral Questions

Senior interviews also evaluate communication and leadership.

Prepare for:

Conflict handling
Mentoring juniors
Code review process
Deadline management
Client communication
Ownership examples

System Design For React Native Developers

Many senior interviews now include mobile system design rounds.

Examples:

Design a chat application
Design an offline-first app
Design a crypto trading app
Design notification architecture

Focus on:

Scalability
Performance
Caching
Security
Offline sync
Real-time updates

How To Prepare Effectively

1. Build One Production-Level Project

Do not rely only on tutorials.

Create:

Authentication
API handling
Notifications
Offline support
CI/CD
Analytics
Performance optimization

2. Revise Native Concepts

Even basic native understanding gives a huge advantage.

3. Practice Explaining Architecture

Most experienced developers fail because they cannot explain their decisions clearly.

Communication matters.

4. Prepare Real Examples

Interviewers trust real production stories more than textbook answers.

Final Advice

For 7+ years experience, companies are not hiring only a React Native developer anymore.

They are hiring someone who can:

Lead mobile development
Improve product quality
Solve critical production issues
Scale applications
Mentor teams
Deliver reliable apps

Your interview preparation should reflect that maturity.

Focus less on memorizing syntax and more on:

Architecture
Performance
Problem-solving
Communication
Real-world engineering decisions

That is what truly separates senior React Native developers from mid-level developers.

Written for Code Chain Dev
Practical engineering insights for modern developers building scalable applications.

Friday, May 15, 2026

Why Developers Should Build Real Projects in 2026

By Salil · Published May 15, 2026 No comments

Technology is changing very fast. AI tools, automation, cloud platforms, and modern frameworks are making software development easier than before. But one thing still separates average developers from strong developers:

The ability to build real products that solve real problems.

This is the core purpose of CodeChain Dev — helping developers move beyond theory and understand practical, production-level software development.

Why Only Watching Tutorials Is Not Enough

Tutorials are useful when you are starting. They help you understand syntax, tools, and basic concepts. But real learning begins when you build something by yourself.

When you build a real project, you face real problems like:

API errors
Database issues
Performance problems
Deployment failures
UI bugs
Authentication issues
Mobile responsiveness problems

These problems make you a better developer because they teach you how software actually works in production.

What Makes a Developer Valuable Today?

Companies are no longer looking only for people who can write code. They want developers who can understand the complete product lifecycle.

A strong developer should know how to:

Build frontend interfaces
Connect APIs
Design databases
Debug production issues
Optimize performance
Deploy applications
Think from the user’s point of view

Example: Building a Real Web Application

Suppose you are building a service marketplace website. You will need:

A homepage
User login
Vendor dashboard
Admin panel
Service listing pages
Search and filters
Database models
Image upload system
SEO-friendly pages

This type of project teaches frontend, backend, database design, authentication, deployment, SEO, and user experience together.

AI Will Help Developers, Not Replace Strong Developers

AI can write code, generate ideas, and speed up development. But AI still needs a developer who understands architecture, security, performance, and product logic.

AI can help you faster, but you still need to know:

What to build
How to structure the system
How to test the result
How to fix bugs
How to improve user experience

Best Projects Developers Should Build

If you want to improve your development skills, start with projects that solve practical problems.

1. Personal Portfolio Website

This teaches HTML, CSS, JavaScript, responsive design, SEO, and hosting.

2. Blog Platform

This teaches content management, routing, database design, authentication, and SEO.

3. Service Marketplace

This teaches user roles, dashboards, search, filters, image uploads, payments, and admin management.

4. Mobile App

This teaches React Native, Android development, API integration, push notifications, and app performance.

5. API-Based Tool

This teaches backend development, API design, validation, rate limiting, and deployment.

Skills You Learn From Real Projects

Project Area	Skill Learned
Frontend	UI, layout, responsiveness, user experience
Backend	APIs, authentication, server logic
Database	Models, relations, queries, optimization
Deployment	Hosting, environment variables, build errors
SEO	Meta tags, sitemap, page structure, content quality

Common Mistakes Beginners Make

Only watching tutorials without building projects
Copying code without understanding it
Ignoring database design
Not testing on mobile devices
Not learning deployment
Not writing clean and readable code

How CodeChain Dev Helps Developers

CodeChain Dev focuses on practical development guides, real-world software problems, and production-level solutions.

Topics covered on this blog include:

React Native development
Next.js development
Backend engineering
AI tools for developers
Deployment guides
Database design
System architecture
Performance optimization

FAQ

Can beginners start building real projects?

Yes. Beginners should start with small projects like portfolio websites, notes apps, calculators, blogs, and simple dashboards.

Is AI enough to become a developer?

No. AI is helpful, but developers still need strong fundamentals, debugging skills, architecture knowledge, and practical experience.

Which skill is most important for developers?

Problem-solving is the most important skill. Tools and frameworks change, but problem-solving always remains valuable.

Final Thoughts

The future belongs to developers who can build real products, solve real problems, and keep learning with modern tools.

Do not only consume tutorials. Build projects, face errors, debug issues, deploy applications, and improve your work step by step.

CodeChain Dev — Build Modern Products. Solve Real Problems.

Monday, April 13, 2026

Why Strong Fundamentals Still Matter in React Native Development

By Salil · Published April 13, 2026 No comments

Modern development is faster than ever.

With React Native, AI coding tools, GitHub Copilot, ChatGPT, and prebuilt libraries, developers can now build mobile apps in days instead of months.

But over time, I realized something important:

The faster you build without understanding fundamentals, the harder debugging becomes later.

This is one of the biggest problems many developers face today.

How Development Has Changed

Earlier, developers spent more time understanding core concepts before building applications.

Today the workflow looks different:

Install libraries quickly
Copy implementation examples
Use AI-generated code
Ship features rapidly

And honestly — this speed is amazing.

React Native and modern tooling have dramatically improved productivity.

But speed without understanding creates long-term problems.

Where React Native Projects Usually Start Breaking

At first, everything feels smooth.

The UI works
API integration works
Navigation works
Features are shipping quickly

Then slowly, issues start appearing:

FlatList performance becomes slow
State updates behave unpredictably
Animations start lagging
Memory usage increases
The app crashes only in production
Native Android/iOS errors become difficult to debug

And suddenly development becomes more debugging than building.

The Real Problem Is Usually Fundamentals

In many cases, React Native itself is not the problem.

The actual issue is skipping the “boring” middle part of learning.

Things like:

Understanding JavaScript deeply
Knowing how React rendering works
Managing state properly
Understanding component lifecycle
Learning app architecture
Structuring reusable components

These topics do not feel exciting in the beginning.

But they are exactly what make large applications maintainable.

Example: Poor State Management

One of the most common issues in React Native apps is unnecessary re-rendering.

Example:


const HomeScreen = () => {
  const [count, setCount] = useState(0);

  return (
    <View>
      <HeavyComponent />
      <Button
        title="Increase"
        onPress={() => setCount(count + 1)}
      />
    </View>
  );
};

If HeavyComponent is not optimized using React.memo, it will re-render every time the state changes.

In small apps this may not matter.

But in production apps with charts, animations, and APIs, this becomes expensive.

Why AI Cannot Replace Understanding

AI tools are incredibly powerful.

I personally use AI daily for:

Code generation
Architecture ideas
Debugging
Optimization suggestions
Documentation

But here is the reality:

AI amplifies understanding. It does not replace it.

If you understand the system, AI can save hours.

If you do not understand the system, AI can generate more confusion.

Common React Native Problems Developers Face

Problem	Common Cause
Slow UI	Unnecessary re-renders
Large APK size	Unoptimized dependencies
Memory leaks	Improper listeners/timers
Navigation lag	Heavy screen rendering
App crashes	Native module issues

What Actually Helped Me Improve

Over time, these changes improved my development process significantly:

Understanding JavaScript fundamentals properly
Learning React rendering behavior
Keeping architecture simple
Writing reusable components
Optimizing before scaling
Using AI as a helper instead of dependency

Best Skills React Native Developers Should Focus On

JavaScript fundamentals
React hooks and rendering
State management
API integration
Performance optimization
Debugging skills
Android and iOS basics
Production deployment

FAQ

Is React Native still worth learning in 2026?

Yes. React Native is still one of the most powerful frameworks for cross-platform mobile app development.

Should developers use AI tools?

Absolutely. AI tools improve productivity significantly. But developers should still understand the code they use.

Why do React Native apps become slow?

Common reasons include unnecessary re-renders, poor state management, large dependencies, and unoptimized rendering.

Final Thoughts

Building fast is good.

But building on weak fundamentals creates long-term problems.

Modern developers should combine:

Strong engineering fundamentals
Practical development experience
Modern AI tools

That combination creates developers who can build scalable, maintainable, and production-ready applications.

CodeChain Dev — Build Modern Products. Solve Real Problems.

Tuesday, February 10, 2026

How AI Is Changing Modern Software Development in 2026

By Salil · Published February 10, 2026 No comments

Artificial Intelligence is changing software development faster than most developers expected.

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

Developers are using AI to:

Generate boilerplate code
Debug applications
Create APIs
Write documentation
Optimize queries
Generate test cases
Improve productivity

But despite all this progress, one thing is still true:

AI improves developers. It does not replace strong engineering fundamentals.

How AI Is Improving Developer Productivity

One of the biggest advantages of AI is speed.

Tasks that previously took hours can now be completed in minutes.

1. Faster Boilerplate Generation

Developers can generate repetitive code much faster using AI tools.

Example:


const express = require("express");
const app = express();

app.get("/api/users", (req, res) => {
  res.json({ success: true });
});

app.listen(3000);

AI tools can quickly generate API structures, route handlers, validation logic, and database models.

2. Faster Debugging

AI tools can analyze stack traces, explain errors, and suggest possible fixes.

For example, developers can paste:

React errors
Prisma issues
Next.js deployment logs
Android crashes

And AI can help identify possible root causes faster.

3. Code Refactoring

AI is also useful for improving existing codebases.

Example tasks:

Converting callbacks into async/await
Improving component structure
Splitting large functions
Improving readability

This helps developers maintain cleaner and more scalable applications.

Why JSON and APIs Are More Important Than Ever

Modern software systems heavily depend on APIs and JSON data.

Whether you are building:

React applications
Mobile apps
Crypto exchanges
AI systems
SaaS platforms

You are constantly working with JSON payloads.

Example JSON response:


{
  "userId": 1,
  "name": "Salil",
  "role": "Developer"
}

AI tools can help generate schemas, TypeScript interfaces, and validation logic from API responses.

Where AI Still Struggles

Even though AI is powerful, it still has limitations.

AI can generate incorrect logic, insecure code, or inefficient architecture if developers do not review the output carefully.

Common problems include:

Hallucinated functions
Incorrect package usage
Security vulnerabilities
Outdated implementation patterns
Inefficient database queries

This is why developers still need strong understanding of:

System architecture
Performance optimization
Databases
Security
Frontend rendering
Backend scalability

How Developers Should Use AI Properly

The best developers are not avoiding AI.

Instead, they are using AI strategically.

Good AI Workflow

Use AI for repetitive tasks
Use AI for debugging help
Review generated code carefully
Understand the implementation
Optimize architecture manually

AI should act like a development assistant — not a replacement for understanding.

Real Example: AI + Human Workflow

Suppose a React Native application becomes slow.

AI may suggest:

React.memo
useCallback
FlatList optimization

But developers still need to:

Analyze re-renders
Understand component lifecycle
Measure memory usage
Test on real devices

This combination of AI assistance and engineering understanding creates better results.

Skills Developers Should Focus On in 2026

JavaScript fundamentals
React and React Native
Backend development
Database optimization
API architecture
System design
AI-assisted workflows
Performance optimization

FAQ

Will AI replace software developers?

No. AI will improve developer productivity, but strong engineering knowledge is still required.

Should beginners use AI tools?

Yes, but beginners should also focus on learning core concepts instead of blindly copying code.

What is the biggest advantage of AI for developers?

Speed and productivity improvement are the biggest advantages of AI-assisted development.

Final Thoughts

AI is changing software development rapidly.

Developers who combine:

Strong fundamentals
Real project experience
Modern AI tools

will build faster, smarter, and more scalable products.

The future is not AI versus developers.

The future is developers working effectively with AI.

CodeChain Dev — Build Modern Products. Solve Real Problems.

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.

Thursday, October 1, 2020

How to Validate Email and Password in Android Using Regex

By Salil · Published October 01, 2020 No comments

Form validation is an important part of modern Android application development.

Applications commonly validate:

Email addresses
Usernames
Passwords
Phone numbers

Proper client-side validation improves user experience, reduces invalid API requests, and helps maintain better data quality.

In this tutorial, we will learn how to validate email addresses and passwords in Android using Regular Expressions (Regex).

What Is Regex?

Regex (Regular Expression) is a pattern matching technique used to validate and process text data.

Developers use regex for:

Email validation
Password rules
Phone number formatting
Input filtering

What We Will Build

In this Android example, we will:

Validate email format
Validate username length
Validate strong passwords
Display error messages using Material TextInputLayout

Step 1 — Add Material Design Dependency

Open your build.gradle file and add:


implementation 'com.google.android.material:material:1.11.0'

Then sync the Gradle project.

Step 2 — Create Layout File

Create the UI inside activity_main.xml.


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

<LinearLayout
    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"
    android:orientation="vertical"
    android:padding="16dp">

    <com.google.android.material.textfield.TextInputLayout
        android:id="@+id/text_input_email"
        android:layout_width="match_parent"
        android:layout_height="wrap_content">

        <com.google.android.material.textfield.TextInputEditText
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:hint="Email"
            android:inputType="textEmailAddress"/>

    </com.google.android.material.textfield.TextInputLayout>

    <com.google.android.material.textfield.TextInputLayout
        android:id="@+id/text_input_username"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        app:counterEnabled="true"
        app:counterMaxLength="15">

        <com.google.android.material.textfield.TextInputEditText
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:hint="Username"/>

    </com.google.android.material.textfield.TextInputLayout>

    <com.google.android.material.textfield.TextInputLayout
        android:id="@+id/text_input_password"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        app:endIconMode="password_toggle">

        <com.google.android.material.textfield.TextInputEditText
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:hint="Password"
            android:inputType="textPassword"/>

    </com.google.android.material.textfield.TextInputLayout>

    <Button
        android:id="@+id/button_confirm"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Confirm"/>

</LinearLayout>

Step 3 — Implement Validation Logic

Open MainActivity.java and add the following code:


package com.example.validationapp;

import android.os.Bundle;
import android.util.Patterns;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

import androidx.appcompat.app.AppCompatActivity;

import com.google.android.material.textfield.TextInputLayout;

import java.util.regex.Pattern;

public class MainActivity extends AppCompatActivity {

    private static final Pattern PASSWORD_PATTERN =
            Pattern.compile("^" +
                    "(?=.*[a-zA-Z])" +
                    "(?=.*[@#$%^&+=])" +
                    "(?=\\\\S+$)" +
                    ".{6,}" +
                    "$");

    private TextInputLayout textInputEmail;
    private TextInputLayout textInputUsername;
    private TextInputLayout textInputPassword;

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

        textInputEmail =
                findViewById(R.id.text_input_email);

        textInputUsername =
                findViewById(R.id.text_input_username);

        textInputPassword =
                findViewById(R.id.text_input_password);

        Button buttonConfirm =
                findViewById(R.id.button_confirm);

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

    private boolean validateEmail() {

        String emailInput =
                textInputEmail.getEditText()
                        .getText()
                        .toString()
                        .trim();

        if (emailInput.isEmpty()) {

            textInputEmail.setError(
                    "Field can't be empty"
            );

            return false;

        } else if (!Patterns.EMAIL_ADDRESS
                .matcher(emailInput)
                .matches()) {

            textInputEmail.setError(
                    "Please enter a valid email"
            );

            return false;

        } else {

            textInputEmail.setError(null);

            return true;
        }
    }

    private boolean validateUsername() {

        String usernameInput =
                textInputUsername.getEditText()
                        .getText()
                        .toString()
                        .trim();

        if (usernameInput.isEmpty()) {

            textInputUsername.setError(
                    "Field can't be empty"
            );

            return false;

        } else if (usernameInput.length() > 15) {

            textInputUsername.setError(
                    "Username too long"
            );

            return false;

        } else {

            textInputUsername.setError(null);

            return true;
        }
    }

    private boolean validatePassword() {

        String passwordInput =
                textInputPassword.getEditText()
                        .getText()
                        .toString()
                        .trim();

        if (passwordInput.isEmpty()) {

            textInputPassword.setError(
                    "Field can't be empty"
            );

            return false;

        } else if (!PASSWORD_PATTERN
                .matcher(passwordInput)
                .matches()) {

            textInputPassword.setError(
                    "Password too weak"
            );

            return false;

        } else {

            textInputPassword.setError(null);

            return true;
        }
    }

    private void confirmInput() {

        if (!validateEmail()
                | !validateUsername()
                | !validatePassword()) {

            return;
        }

        Toast.makeText(
                this,
                "Validation Successful",
                Toast.LENGTH_SHORT
        ).show();
    }
}

How Password Regex Works

The regex pattern checks:

At least one alphabet character
At least one special character
No whitespace
Minimum password length

Regex pattern used:


(?=.*[a-zA-Z])
(?=.*[@#$%^&+=])
(?=\\S+$)
.{6,}

How Email Validation Works

Android provides a built-in email validation pattern:


Patterns.EMAIL_ADDRESS.matcher(email).matches()

This helps validate whether the entered email follows standard email formatting.

Expected Output

After running the application:

Users can enter email, username, and password
Invalid fields display error messages
Valid inputs show success message

Common Validation Mistakes

1. Weak Password Rules

Weak passwords reduce application security.

2. Overly Strict Validation

Very strict regex rules may block legitimate user inputs.

3. Missing Server-Side Validation

Client-side validation improves UX, but backend validation is still required for security.

Modern Android Validation Improvements

Production Android applications should also consider:

Real-time validation
Kotlin implementation
ViewBinding
MVVM architecture
Server-side verification

FAQ

Why use regex for validation?

Regex helps developers validate text patterns efficiently.

Can regex validate all email addresses perfectly?

No. Regex can validate formatting, but complete email verification requires backend confirmation.

Should passwords be validated only on frontend?

No. Password validation should always happen on both frontend and backend.

Conclusion

Input validation is an important part of Android application development.

Using regex with Material TextInputLayout improves form validation, user experience, and application reliability.

Modern Android applications should combine client-side validation with secure backend verification for better security.

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.

Monday, September 28, 2020

How to Integrate UPI Payment Gateway in Android Using EasyUpiPayment Library

By Salil · Published September 28, 2020 No comments

UPI (Unified Payments Interface) is one of the most widely used digital payment systems in India.

Many Android applications now support UPI payments for:

E-commerce payments
Subscription services
Donation systems
Recharge applications
Local business payments

In this tutorial, we will learn how to integrate UPI payments in Android using the EasyUpiPayment library.

What Is EasyUpiPayment?

EasyUpiPayment is an Android library that simplifies UPI payment integration.

It helps developers:

Launch UPI payment apps
Handle payment responses
Track transaction status
Reduce boilerplate code

Features of UPI Integration

Works with multiple UPI apps
Supports Google Pay, PhonePe, Paytm, BHIM
Easy transaction handling
Simple integration process

Important Requirements

Minimum SDK should be 19 or higher
Real device recommended for testing
At least one UPI app must be installed

Step 1 — Add Dependency

Open your build.gradle file and add:


implementation 'com.shreyaspatil:EasyUpiPayment:3.0.0'

Then sync your Gradle project.

Step 2 — Create Layout File

Create the UI inside activity_main.xml.


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

<FrameLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:padding="16dp">

    <Button
        android:id="@+id/id_pay_using_upi_app"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Pay Using UPI App"
        android:layout_gravity="center"/>

</FrameLayout>

Step 3 — Implement UPI Payment Logic

Open MainActivity.java and add the following code:


package com.example.upiintegration;

import androidx.appcompat.app.AppCompatActivity;

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

import com.shreyaspatil.easyupipayment.EasyUpiPayment;
import com.shreyaspatil.easyupipayment.listener.PaymentStatusListener;
import com.shreyaspatil.easyupipayment.model.PaymentApp;
import com.shreyaspatil.easyupipayment.model.TransactionDetails;

public class MainActivity extends AppCompatActivity
        implements PaymentStatusListener {

    private EasyUpiPayment easyUpiPayment;

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

        findViewById(R.id.id_pay_using_upi_app)
                .setOnClickListener(new View.OnClickListener() {

                    @Override
                    public void onClick(View view) {
                        startUpiPayment();
                    }
                });
    }

    private void startUpiPayment() {

        String transactionId =
                "TID" + System.currentTimeMillis();

        String transactionRefId =
                "TREF" + System.currentTimeMillis();

        EasyUpiPayment.Builder builder =
                new EasyUpiPayment.Builder(this)
                        .with(PaymentApp.ALL)
                        .setPayeeVpa("example@upi")
                        .setPayeeName("Salil Jha")
                        .setTransactionId(transactionId)
                        .setTransactionRefId(transactionRefId)
                        .setDescription("Demo Payment")
                        .setAmount("100.00");

        try {

            easyUpiPayment = builder.build();

            easyUpiPayment.setPaymentStatusListener(this);

            easyUpiPayment.startPayment();

        } catch (Exception e) {

            e.printStackTrace();

            Toast.makeText(
                    this,
                    e.getMessage(),
                    Toast.LENGTH_SHORT
            ).show();
        }
    }

    @Override
    public void onTransactionCompleted(
            TransactionDetails transactionDetails
    ) {

        Toast.makeText(
                this,
                "Transaction Successful",
                Toast.LENGTH_SHORT
        ).show();
    }

    @Override
    public void onTransactionCancelled() {

        Toast.makeText(
                this,
                "Transaction Cancelled",
                Toast.LENGTH_SHORT
        ).show();
    }
}

How UPI Payment Flow Works

The payment flow is:

User clicks payment button
UPI payment app opens
User completes payment
UPI app returns transaction response
Application receives payment status

Supported UPI Applications

The EasyUpiPayment library supports:

Google Pay
PhonePe
Paytm
BHIM
Other installed UPI apps

Important UPI Parameters

Parameter	Description
Payee VPA	Receiver UPI ID
Payee Name	Name of receiver
Transaction ID	Unique transaction identifier
Amount	Payment amount

Common Mistakes Developers Make

1. Invalid UPI ID

Incorrect VPA format may cause payment failures.

2. Testing on Emulator

UPI apps usually do not work correctly on Android emulators.

3. Missing Transaction Verification

Frontend success messages alone are not secure for production applications.

Production-Level Security Recommendations

For real production systems:

Verify transactions on backend
Store transaction logs securely
Validate transaction IDs
Use payment webhooks
Prevent duplicate transactions

Backend Verification Importance

Frontend payment success should never be treated as final confirmation.

Production applications should always verify:

Transaction status
Payment amount
Transaction reference
Receiver account

This prevents fraud and fake payment confirmations.

Modern UPI Integration Improvements

Modern Android applications can improve UPI integration using:

Kotlin
MVVM architecture
Jetpack Compose
Backend transaction verification
Payment analytics

FAQ

Does UPI integration require a payment gateway?

Basic intent-based UPI integration does not require a gateway, but production systems should use proper backend verification.

Can I test UPI payments on emulator?

UPI testing works best on physical Android devices with installed UPI apps.

Is EasyUpiPayment suitable for production apps?

Yes, for basic UPI integration. However, production applications should implement backend transaction validation.

Conclusion

UPI integration allows Android applications to support fast and simple digital payments.

The EasyUpiPayment library simplifies payment integration and reduces development complexity.

For production-grade applications, developers should combine frontend payment flow with secure backend verification systems.

About the Author

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

CodeChain Dev — Build Modern Products. Solve Real Problems.

Sunday, September 27, 2020

How to Save Activity State in Android Using onSaveInstanceState

By Salil · Published September 27, 2020 No comments

Android applications can restart automatically during runtime configuration changes such as:

Screen rotation
Language changes
Dark mode changes
Multi-window mode

When this happens, the Activity is destroyed and recreated.

If developers do not save the UI state properly, variables and temporary data may be lost.

In this tutorial, we will learn how to save and restore Activity state in Android using onSaveInstanceState().

What Is onSaveInstanceState?

onSaveInstanceState() is an Android lifecycle callback used to save temporary UI data before an Activity gets destroyed.

Android automatically restores some UI elements such as:

EditText text
RecyclerView scroll position
Fragment states

However, custom variables must be saved manually.

Why Saving State Is Important

Without proper state handling:

Counters reset
User progress is lost
UI becomes inconsistent
User experience suffers

Saving Activity state improves application reliability and usability.

What We Will Build

In this example:

User can increment and decrement a counter
Counter value survives screen rotation
State restores automatically after Activity recreation

Step 1 — Create Layout File

Create the UI inside activity_main.xml.


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

<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:gravity="center"
    android:orientation="horizontal">

    <Button
        android:id="@+id/button_decrement"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="-" />

    <TextView
        android:id="@+id/text_view_count"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_margin="16dp"
        android:text="0"
        android:textColor="@android:color/black"
        android:textSize="50sp" />

    <Button
        android:id="@+id/button_increment"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="+" />

</LinearLayout>

Step 2 — Implement MainActivity.java

Open MainActivity.java and add the following code:


package com.example.savedstateexample;

import androidx.appcompat.app.AppCompatActivity;

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

public class MainActivity extends AppCompatActivity {

    private TextView textViewCount;

    private int count;

    @Override
    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

        textViewCount =
                findViewById(R.id.text_view_count);

        Button buttonDecrement =
                findViewById(R.id.button_decrement);

        Button buttonIncrement =
                findViewById(R.id.button_increment);

        buttonDecrement.setOnClickListener(
                new View.OnClickListener() {

                    @Override
                    public void onClick(View view) {
                        decrement();
                    }
                });

        buttonIncrement.setOnClickListener(
                new View.OnClickListener() {

                    @Override
                    public void onClick(View view) {
                        increment();
                    }
                });

        if (savedInstanceState != null) {

            count = savedInstanceState.getInt("count");

            textViewCount.setText(
                    String.valueOf(count)
            );
        }
    }

    private void increment() {

        count++;

        textViewCount.setText(
                String.valueOf(count)
        );
    }

    private void decrement() {

        count--;

        textViewCount.setText(
                String.valueOf(count)
        );
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {

        super.onSaveInstanceState(outState);

        outState.putInt("count", count);
    }
}

How This Implementation Works

The workflow is:

User changes counter value
Android destroys Activity during rotation
onSaveInstanceState() stores counter value
Activity recreates automatically
Saved value restores inside onCreate()

How Android Lifecycle Handles State

When configuration changes happen:


onPause()
↓
onStop()
↓
onSaveInstanceState()
↓
onDestroy()
↓
onCreate()
↓
onStart()
↓
onResume()

This lifecycle allows Android to preserve temporary UI data.

What Type of Data Should Be Saved?

Good examples:

Counter values
Temporary form data
Selected tabs
Scroll positions
Search queries

What Should NOT Be Saved?

Avoid storing:

Large images
Database objects
Huge collections
Heavy serialized objects

Large Bundle data can cause performance issues.

Common Mistakes Developers Make

1. Forgetting Null Checks

Always check:


if (savedInstanceState != null)

before restoring values.

2. Saving Large Data

Bundles are intended for lightweight UI state only.

3. Not Updating UI After Restore

Restoring variables without updating UI components causes incorrect screen states.

Modern Android Recommendations

Modern Android applications often use:

ViewModel
SavedStateHandle
Jetpack Compose state management
MVVM architecture

These approaches improve lifecycle-aware state management.

ViewModel vs onSaveInstanceState

ViewModel	onSaveInstanceState
Survives configuration changes	Stores temporary UI state
Better for business logic	Better for small UI data
Lifecycle aware	Bundle based

FAQ

Why does Android recreate Activities during rotation?

Android recreates Activities to reload resources for the new configuration.

Can onSaveInstanceState save large objects?

No. It should only store lightweight temporary UI data.

What is the modern alternative to this approach?

ViewModel and SavedStateHandle are modern lifecycle-aware solutions.

Conclusion

Handling Activity state correctly is an important part of Android development.

Using onSaveInstanceState() helps preserve temporary UI data during configuration changes and improves user experience.

Modern Android applications should combine lifecycle-aware architecture with proper state management techniques.

About the Author

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

CodeChain Dev — Build Modern Products. Solve Real Problems.