Creating a game for Android in Android Studio: a complete guide from idea to release

Developing mobile games on Android is an exciting process that combines programming, design and creativity. With the advent Android Studio and powerful game engines, even a beginner can create his first game from scratch. But where to start? Which engine to choose? And how to avoid typical mistakes that slow down development?

This article will help you understand all the stages - from installing the necessary software to publishing the game in Google Play. We will consider two main approaches: creating a game in pure Java/Kotlin and using a popular engine Unity (through integration with Android Studio). We will pay special attention to performance optimization, adaptation to different screens and monetization. If you dream of your own game, but don’t know which way to approach it, you’re in the right place.

1. Preparing the working environment: what needs to be installed

Before you start development, you need to set up the working environment. Without the tools installed correctly, you risk running into compilation errors or compatibility issues. Here is the minimum set of software:

• 📱 Android Studio (latest stable version) - official IDE for Android development. Download only from official websiteto avoid viruses.
• 🔧 Java Development Kit (JDK) versions 11 or 17. Android Studio may offer to install it automatically the first time you start it.
• 🎮 Unity Hub (if you plan to use Unity) + module Android Build Support.
• 📦 Android SDK with packages for the latest versions of the API (API 33+ is recommended for new projects).

After installing Android Studio, launch it and wait for the initial setup to complete. Then go to SDK Manager (Tools → SDK Manager) and install:

• Packages Android SDK Platform for the selected API.
• Tools Android SDK Build-Tools.
• Emulators for testing (we recommend Pixel 5 c API 33).

⚠️ Attention: If you are using Mac with an M1/M2 chip, make sure to download the version of Android Studio for Apple Silicon. Otherwise, emulators may not start or work extremely slowly.

For the convenience of game development, it is also useful:

• 🖼️ GIMP or Photoshop to create 2D graphics.
• 🎵 Audacity or FL Studio for sound effects.
• 📝 Trello or Notion for scheduling tasks.

2. Choosing an engine: pure Android or Unity?

One ​​of the key questions is what to write the game in. Each approach has pros and cons:

Pure Android suitable if:

• You already know Java or Kotlin and want full control over the code.
• Planning a simple 2D game (for example, Flappy Bird or 2048).
• Maximum performance is important (for example, for arcade games with high FPS).

Unity choose if:

• You need cross-platform (iOS, PC, consoles).
• You want to create a 3D game with physics and animations.
• A quick prototype with minimal code is important.

3. Creating the first project: step by step

Let's consider the process using the example of a simple 2D game in Kotlin (similarly for Java). avoiding falling objects.

3.1. Creating a new project

In Android Studio, select New Project → Empty Activity. Specify:

• Project name: SimpleGame.
• Language: Kotlin.
• Minimum SDK: API 24 (Android 7.0) (covers ~95% of devices).

3.2. Setting up the playing field

Open the file activity_main.xml and replace the contents with SurfaceView —it will allow you to draw graphics in real time:

<?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">

<SurfaceView
android:id="@+id/gameSurface"
android:layout_width="match_parent"
android:layout_height="match_parent"/>
</FrameLayout>

3.3. Game logic: touch processing and rendering

Create a class GameView, inherited from SurfaceView, and implement in it:

• Thread for updating the game state (Thread).
• Touch handler (onTouchEvent).
• Method draw for displaying objects.

Example code for moving a square:

class GameView(context: Context) : SurfaceView(context), Runnable {
private var playerX = 100f
private var playerY = 100f
private var thread: Thread? = null
private var isPlaying = false

init {
holder.addCallback(object : SurfaceHolder.Callback {
override fun surfaceCreated(holder: SurfaceHolder) {
startGame()
}
// ... other methods
})
}

override fun run() {
while (isPlaying) {
update() // Update the player's position
draw() // Redrawing the screen
Thread.sleep(17) // ~60 FPS
}
}

private fun update() {
// Motion logic
}

override fun onTouchEvent(event: MotionEvent): Boolean {
when (event.action) {
MotionEvent.ACTION_MOVE -> {
playerX = event.x
playerY = event.y
}
}
return true
}
}

4. Adding graphics and animations

Static objects are boring - let's add animation and sprites. To do this:

4.1. Uploading images

Place graphics files (for example, player.png) in the folder res/drawable. To support different resolutions, use subfolders:

• drawable-mdpi (160 dpi)
• drawable-hdpi (240 dpi)
• drawable-xhdpi (320 dpi)

To upload an image to code:

val bitmap = BitmapFactory.decodeResource(resources, R.drawable.player)

4.2. Sprite animation

For smooth animation (for example, a character running), use AnimationDrawable or a custom class. Example for animation of 4 frames:

val frame1 = BitmapFactory.decodeResource(resources, R.drawable.run1)
val frame2 = BitmapFactory.decodeResource(resources, R.drawable.run2)
// ... frame3, frame4
val frames = listOf(frame1, frame2, frame3, frame4)

var currentFrame = 0
fun update() {
currentFrame = (currentFrame + 1) % frames.size
// Rendering frames[currentFrame]
}

4.3. Graphics optimization

Using vector images (SVG) via VectorDrawable can reduce APK size by 30-50% compared to raster graphics. To convert SVG to XML, use Android Studio Vector Asset Studio (File → New → Vector Asset).

⚠️ Attention: Avoid loading highly detailed textures (more than 2048x2048 in size) on mobile devices. This can lead to OutOfMemoryError on weak devices.

android {
buildTypes {
release {
crunchPngs true // PNG compression
}
}
}

5. Working with sound and music

Sound effects and background music make the game come alive. In Android there is a class for this SoundPool (for short sounds) and MediaPlayer (for music).

5.1. Adding sound files

Place files in the format .mp3 or .ogg to the folder res/raw. For example, res/raw/background_music.mp3.

5.2. Playing sounds

Initialization SoundPool:

val soundPool = SoundPool.Builder()
.setMaxStreams(5) // Maximum 5 sounds simultaneously
.build()
val soundId = soundPool.load(context, R.raw.explosion, 1)

Playing:

soundPool.play(soundId, 1f, 1f, 0, 0, 1f)

5.3. Background music

For music, use MediaPlayer:

val mediaPlayer = MediaPlayer.create(context, R.raw.background_music)
mediaPlayer.isLooping = true // Looping
mediaPlayer.start()

⚠️ Attention: Always release audio object resources in the onDestroy() activity method to avoid memory leaks:

override fun onDestroy() {
super.onDestroy()
soundPool.release()
mediaPlayer.release()
}

6. Testing and optimization

Before release, the game must be tested on different devices and optimized. Here are the key aspects:

6.1. Testing on real devices

Emulators do not always show real performance. Use:

• 📱 Devices with different screens (4", 5.5", 6.5").
• 🔋 Different versions of Android (from 7.0 to 14).
• 🎮 Gamepads (if you support).

6.2. Performance profiling

Android Studio has built-in analysis tools:

• CPU Profiler —shows processor load.
• Memory Profiler —monitors memory leaks.
• GPU Rendering —identifies rendering problems.

To open the profiler, select View → Tool Windows → Profiler.

6.3. Code optimization

Some tricks to speed up the game:

• 🔄 Use Object Pool to reuse objects (for example, bullets or enemies).
• 🗑️ Avoid creating objects in a loop update().
• 🖼️ Turn off unnecessary transparency layers (setHasTranslucentBackground(false)).

7. Publishing on Google Play

When the game is ready, it's time to share it with world! The publishing process in Google Play Console consists of several steps:

7.1. Preparation of materials

You will need:

• 📌 APK/AAB file (recommended .aab - it is 15-20% less).
• 🖼️ Game icon (512×512, without transparency).
• 📸 Screenshots (minimum 2, preferably 4-6 for different resolutions).
• 🎬 Video preview (optional, but increases conversion).
• 📝 Description in Russian and English (up to 4000 characters).

7.2. Assembly of the release version

B build.gradle set up a signature:

android {
signingConfigs {
release {
storeFile file("keystore.jks")
storePassword "your_password"
keyAlias "your_alias"
keyPassword "your_password"
}
}
buildTypes {
release {
signingConfig signingConfigs.release
minifyEnabled true
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
}
}
}

Collect .aab via Build → Generate Signed Bundle / APK.

7.3. Upload to Google Play Console

Go to Google Play Console i:

1. Create a new application.
2. Fill in the information about the game (name, category, age rating).
3. Upload .aab to the section Production.
4. Indicate the price (free or paid).
5. Set up monetization (advertising, purchases).
6. Submit for review (usually takes 1-3 days).

⚠️ Attention: Google charges one-time fee of $25 for registering a developer account. Also, a commission of 15-30% is charged on sales, depending on the type of monetization.

8. Monetization: how to make money on the game

There are several ways to monetize mobile games:

For integration AdMob add dependency to build.gradle:

implementation 'com.google.android.gms:play-services-ads:22.6.0'

Example of banner display:

val adView = AdView(this)
adView.adUnitId = "ca-app-pub-3940256099942544/6300978111" // Test ID
adView.adSize = AdSize.BANNER
adView.loadAd(AdRequest.Builder().build())

FAQ: Frequently asked questions about creating games in Android Studio