In this guide, I’ll walk you through the exact process I followed to successfully set up my environment on Windows. By the end, you’ll be able to:

• Run your React Native project on an Android emulator
• Build your app locally
• Avoid common JDK, SDK, and NDK issues
• Launch your app smoothly using npx react-native run-android

This setup is ideal for long-term development and future-proofing your workflow.

Why Proper Environment Setup Is Important

React Native development for Android requires multiple tools working together:

• Node.js
• React Native CLI
• Java Development Kit (JDK)
• Android Studio
• Android SDK
• Android Emulator

If even one component is misconfigured, you may face:

• CMake build errors
• Device detection issues
• Gradle failures
• Emulator launch problems

So let’s set everything up properly from scratch.

Step 1: Install Node.js (LTS Recommended)

React Native depends on Node.js.

Recommended Method (Windows)

Use Chocolatey package manager.

Open Command Prompt as Administrator and run:

choco install -y nodejs-lts microsoft-openjdk17

Important Notes

• Use an LTS version of Node.
• Node 22.11.0 or newer is recommended.
• If you want multiple Node versions, use nvm-windows.

Verify installation:

node -v
npm -v

Step 2: Install Java Development Kit (JDK 17)

React Native works most reliably with JDK 17.

Even if you have a newer JDK installed, I strongly recommend using JDK 17 to avoid Gradle compatibility issues.

Verify:

java -version

It should show something like:

openjdk version "17.x.x"

Step 3: Install Android Studio

Download and install Android Studio.

During installation, make sure these are selected:

• Android SDK
• Android SDK Platform
• Android Virtual Device
• Performance (Intel HAXM if not using Hyper-V)

After installation completes, proceed to SDK configuration.

Step 4: Install Required Android SDK Components

Open Android Studio → More Actions → SDK Manager.

In SDK Platforms Tab

1. Enable “Show Package Details”.
2. Expand Android 15 (VanillaIceCream).
3. Select:
   • Android SDK Platform 35
   • Intel x86 Atom_64 System Image or Google APIs System Image

In SDK Tools Tab

1. Enable “Show Package Details”.
2. Select:
   • Android SDK Build-Tools 36.0.0
   • Android SDK Command-line Tools (latest)
   • NDK (Side by side)
   • CMake

Click Apply and install.

Step 5: Set ANDROID_HOME Environment Variable

React Native requires Android environment variables.

How to Set It (Windows)

1. Open Control Panel
2. Go to User Accounts → Environment Variables
3. Click New

Create:

Variable Name: ANDROID_HOME
Variable Value: %LOCALAPPDATA%\Android\Sdk

Open a new Command Prompt and verify:

Get-ChildItem -Path Env:\

Make sure ANDROID_HOME appears.

Step 6: Add platform-tools to PATH

Still in Environment Variables:

1. Edit the Path variable
2. Add:

%LOCALAPPDATA%\Android\Sdk\platform-tools

Verify:

adb --version
adb devices

Step 7: Create and Launch an Android Virtual Device (AVD)

Open Android Studio → AVD Manager.

1. Click Create Virtual Device
2. Select a phone model
3. Choose API Level 35 (VanillaIceCream)
4. Finish setup

Click the green ▶ button to launch the emulator.

Step 8: Verify Device Connection

Once emulator is running:

adb devices

You should see:

emulator-5554 device

If not, restart ADB:

adb kill-server
adb start-server
adb devices

Step 9: Create and Run React Native Project

Create project:

npx react-native init MyApp

Navigate into project:

cd MyApp

Run Android app:

npx react-native run-android

If multiple devices are connected:

npx react-native run-android --device emulator-5554

Important Compatibility Notes (Very Important)

During my setup, I faced the following real issues:

1. Gradle Using Wrong Java Version

Fix: Force JDK 17 in android/gradle.properties

2. CMake Error: std::format Not Found

Cause: Using NDK 26
Fix: Install and use NDK 27.1.12297006

Add inside android {} in build.gradle:

ndkVersion "27.1.12297006"

Then clean:

cd android
gradlew clean

This resolved C++ build errors completely.

Final Working Configuration Summary

For a stable React Native Android setup on Windows:

• Node: LTS (22+ recommended)
• Java: JDK 17
• Android SDK Platform: 35
• Build Tools: 36.0.0
• NDK: 27.1.12297006
• Emulator: API 35
• Correct ANDROID_HOME + PATH

Conclusion

Setting up React Native Android development correctly takes time — but once done properly, everything runs smoothly.

By following this guide:

• Emulator launches correctly
• ADB detects devices
• Gradle builds without errors
• Native C++ compilation works
• App runs smoothly using run-android

If you’re setting this up for the first time, expect about an hour. After that, development becomes fast and seamless.

This guide will help you avoid common mistakes and future build headaches.

The post Complete Guide to Setting Up React Native Android Development Environment on Windows (Step-by-Step) appeared first on Artificial Intelligence.

• Opens the emulator but does not launch the app
• Fails with configureCMakeDebug error
• Shows std::format not found error
• Or says “No Android device connected”

Then this complete guide will help you fix everything step by step.

This guide is based on a real-world troubleshooting session on Windows with React Native 0.84.

Problem 1: Gradle Using Wrong Java Version (JDK 25 Instead of JDK 17)

Symptoms

Running:

gradlew.bat -version

Showed:

Launcher JVM: 25.0.2
Daemon JVM: jdk-25

Even though java -version showed JDK 17.

This caused:

Execution failed for task ':app:configureCMakeDebug[arm64-v8a]'
WARNING: A restricted method in java.lang.System has been called

Why This Happens

Gradle was using JDK 25 internally, but React Native Android builds are stable with JDK 17.

Gradle launcher and daemon must both use Java 17.

Solution: Force Gradle to Use JDK 17

Step 1: Locate Your JDK 17 Folder

Example:

C:\Program Files\Microsoft\jdk-17.0.18.8-hotspot

Step 2: Add This to android/gradle.properties

Open:

android/gradle.properties

Add:

org.gradle.java.home=C:\\Program Files\\Microsoft\\jdk-17.0.18.8-hotspot

Use double backslashes.

Step 3: Stop Gradle and Clean

cd android
gradlew.bat --stop
rmdir /s /q .gradle
rmdir /s /q .cxx
rmdir /s /q app\.cxx
gradlew.bat clean

Step 4: Verify

gradlew.bat -version

Now both should show:

Launcher JVM: 17.x
Daemon JVM: 17.x

If not, temporarily force in CMD:

set "JAVA_HOME=C:\Program Files\Microsoft\jdk-17.0.18.8-hotspot"
set "PATH=%JAVA_HOME%\bin;%PATH%"

Problem 2: CMake Error – std::format Not Found (NDK Issue)

After fixing Java, build failed with:

error: no member named 'format' in namespace 'std'
return std::format("{}%", dimension.value);

This came from:

react-native-safe-area-context

And NDK path showed:

ndk\26.1.10909125

Why This Happens

React Native 0.84 uses C++20 features like std::format.

NDK 26 does not properly support this setup.

You must use NDK 27.1+.

Solution: Install and Force NDK 27.1

Step 1: Install NDK 27.1

In Android Studio:

• Settings
• Android SDK
• SDK Tools
• Enable “NDK (Side by side)”
• Select 27.1.12297006
• Apply

Step 2: Force Project to Use NDK 27.1

Open:

android/build.gradle

Inside android {} add:

ndkVersion "27.1.12297006"

Step 3: Clean Native Build

cd android
gradlew.bat --stop
rmdir /s /q .cxx
rmdir /s /q app\.cxx
rmdir /s /q .gradle
gradlew.bat clean

Step 4: Run Again

cd ..
npx react-native run-android

Now build succeeds.

Problem 3: Emulator Opens but CLI Says “No Android Device Connected”

Even though:

adb devices

Showed:

emulator-5554 device

Sometimes it showed blank.

Why This Happens

• ADB server mismatch
• Multiple adb.exe in PATH
• Emulator not cold booted

Fix Emulator Detection

Step 1: Restart Emulator

Cold boot from Android Studio Device Manager.

Step 2: Reset ADB

adb kill-server
taskkill /F /IM adb.exe
adb start-server
adb devices

Now emulator should show:

emulator-5554 device

Step 3: Run with Correct Flag

New React Native versions use:

npx react-native run-android --device emulator-5554

(Not --deviceId)

Step 4: Ensure Correct ADB in PATH

where adb

Make sure this path is first:

C:\Users\YourUser\AppData\Local\Android\Sdk\platform-tools\adb.exe

If not:

set "ANDROID_SDK_ROOT=%LOCALAPPDATA%\Android\Sdk"
set "PATH=%ANDROID_SDK_ROOT%\platform-tools;%PATH%"

Final Working Configuration Summary

For React Native 0.84 (Windows):

• Java: JDK 17
• Gradle JVM: 17
• NDK: 27.1.12297006
• CMake: Installed via SDK Tools
• Use: --device instead of --deviceId

Final Command That Worked

npx react-native run-android --device emulator-5554

Everything built smoothly.

Key Lessons Learned

1. Gradle launcher and daemon must both use Java 17.
2. NDK 26 is not compatible with React Native 0.84 C++20 requirements.
3. Always force ndkVersion in build.gradle.
4. Always clean .cxx when changing NDK.
5. If emulator shows but CLI doesn’t detect, reset ADB.

The post How to Fix React Native Android Build Errors (JDK 25, NDK 26, CMake & Emulator Issues) appeared first on Artificial Intelligence.

1. Visit the Android Studio Website: Go to the official Android Studio website at https://developer.android.com/studio.

2. Download Android Studio: On the website, you’ll see a big green “Download Android Studio” button. Click on it.

3. Accept Terms and Conditions: You might be prompted to review and accept the terms and conditions of use. Read through them and if you agree, proceed.

4. Download the Installer: Click on the download button for the package you selected. The download should start automatically.

5. Once the download is complete, open the downloaded file.

6. Follow the installation instructions provided by the setup wizard.

7. Once the installation is complete, you can launch Android Studio by double-clicking on the desktop shortcut or searching for it in the Start menu.

That’s it! You’ve successfully downloaded and installed Android Studio on your Windows 10 system. Now you can start building amazing Android applications.

The post How to download android studio in windows 10 appeared first on Artificial Intelligence.