Plugins - Android Code Studio

Android Code Studio supports plugins and custom modules to extend functionality and organize your projects.

Overview

Plugins in Android Code Studio come in two forms:

Project Modules - Additional modules within your Android project
Build System Plugins - Gradle plugins and custom build logic

This guide focuses on project modules and Gradle plugins. Android Code Studio doesn’t currently support IDE plugins like IntelliJ IDEA or Android Studio.

Project Modules

Multi-module projects help organize code and improve build times.

Module Types

The IDE supports these module types:

Android Library
Java Library
Dynamic Feature

Reusable Android code libraries:

library/build.gradle.kts

plugins {
    id("com.android.library")
    id("org.jetbrains.kotlin.android")
}

android {
    namespace = "com.example.library"
    compileSdk = 34
}

Use for:

Shared UI components
Common utilities
Feature modules
Library distribution

Pure Java/Kotlin libraries:

javalib/build.gradle.kts

plugins {
    id("java-library")
    id("org.jetbrains.kotlin.jvm")
}

java {
    sourceCompatibility = JavaVersion.VERSION_17
    targetCompatibility = JavaVersion.VERSION_17
}

Use for:

Business logic
Data models
API clients
Platform-independent code

On-demand app features:

feature/build.gradle.kts

plugins {
    id("com.android.dynamic-feature")
    id("org.jetbrains.kotlin.android")
}

android {
    namespace = "com.example.feature"
}

Use for:

Optional features
Reducing initial APK size
On-demand delivery

Creating Modules

Open Plugin Creator

Select File → New → Module from the menu.

Choose Module Type

Select:

Android Library - For Android-specific code
Java Library - For pure Java/Kotlin code

Configure Module

Set:

Module name - e.g., library, feature-login
Package name - e.g., com.example.library
Language - Java or Kotlin

Create Module

The IDE generates:

Module directory
build.gradle.kts
Source directories
Updates settings.gradle.kts

Module Structure

MyProject/
├── app/                  # Main application module
│   ├── src/
│   └── build.gradle.kts
├── library/              # Android library module
│   ├── src/
│   └── build.gradle.kts
├── feature-login/        # Feature module
│   ├── src/
│   └── build.gradle.kts
└── settings.gradle.kts   # Includes all modules

Module Dependencies

Reference modules in build.gradle.kts:

app/build.gradle.kts

dependencies {
    // Local modules
    implementation(project(":library"))
    implementation(project(":feature-login"))
    
    // External libraries
    implementation("androidx.appcompat:appcompat:1.6.1")
}

Gradle Plugins

Gradle plugins extend build functionality.

Android Gradle Plugin (AGP)

The core plugin for Android development:

build.gradle.kts

plugins {
    id("com.android.application") version "8.2.0" apply false
    id("com.android.library") version "8.2.0" apply false
}

Android Code Studio requires AGP 7.2.0 or newer. Older versions are not supported.

Kotlin Plugin

For Kotlin support:

build.gradle.kts

plugins {
    id("org.jetbrains.kotlin.android") version "1.9.20" apply false
    id("org.jetbrains.kotlin.jvm") version "1.9.20" apply false
}

Common Plugins

// Root build.gradle.kts
plugins {
    id("com.google.gms.google-services") version "4.4.0" apply false
}

// app/build.gradle.kts
plugins {
    id("com.google.gms.google-services")
}

Applying Plugins

Kotlin DSL
Groovy

app/build.gradle.kts

plugins {
    id("com.android.application")
    id("org.jetbrains.kotlin.android")
    id("com.google.gms.google-services")
}

app/build.gradle

plugins {
    id 'com.android.application'
    id 'org.jetbrains.kotlin.android'
    id 'com.google.gms.google-services'
}

Custom Build Logic

Create custom Gradle logic:

buildSrc Module

For build configuration:

MyProject/
├── buildSrc/
│   ├── src/main/kotlin/
│   │   ├── Dependencies.kt
│   │   └── Versions.kt
│   └── build.gradle.kts

buildSrc/src/main/kotlin/Dependencies.kt

object Versions {
    const val kotlin = "1.9.20"
    const val agp = "8.2.0"
    const val appCompat = "1.6.1"
}

object Deps {
    const val kotlinStdlib = "org.jetbrains.kotlin:kotlin-stdlib:${Versions.kotlin}"
    const val appCompat = "androidx.appcompat:appcompat:${Versions.appCompat}"
}

Use in build scripts:

app/build.gradle.kts

dependencies {
    implementation(Deps.kotlinStdlib)
    implementation(Deps.appCompat)
}

Version Catalogs

Modern dependency management:

gradle/libs.versions.toml

[versions]
kotlin = "1.9.20"
appcompat = "1.6.1"

[libraries]
appcompat = { module = "androidx.appcompat:appcompat", version.ref = "appcompat" }
material = { module = "com.google.android.material:material", version = "1.11.0" }

[plugins]
android-application = { id = "com.android.application", version = "8.2.0" }
kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }

Use in build scripts:

app/build.gradle.kts

plugins {
    alias(libs.plugins.android.application)
    alias(libs.plugins.kotlin.android)
}

dependencies {
    implementation(libs.appcompat)
    implementation(libs.material)
}

Template System

Android Code Studio includes a template system for project creation.

Available Templates

From the source code analysis:

templates-impl/

- emptyActivity
- basicActivity
- bottomNavActivity
- navDrawerActivity
- tabbedActivity
- composeActivity
- withCpp (Native C++)
- noActivity

Template Structure

Template API

interface Template {
    val templateName: Int        // Display name resource
    val thumb: Int              // Thumbnail resource
    val widgets: List<Widget>   // Configuration UI
    val recipe: TemplateRecipe  // Generation logic
}

Creating Custom Templates

While the IDE doesn’t expose custom template creation in the UI, you can create module templates:

Create a template module
Configure as needed
Copy/paste for similar modules

Plugin Configuration

Configure plugin behavior:

Android Plugin

app/build.gradle.kts

android {
    // Compilation options
    compileSdk = 34
    
    defaultConfig {
        minSdk = 21
        targetSdk = 34
    }
    
    // Build features
    buildFeatures {
        viewBinding = true
        dataBinding = false
        compose = false
    }
    
    // Lint options
    lint {
        abortOnError = false
        checkReleaseBuilds = false
    }
}

Kotlin Plugin

app/build.gradle.kts

kotlin {
    jvmToolchain(17)
}

kotlinOptions {
    jvmTarget = "17"
    freeCompilerArgs += listOf(
        "-opt-in=kotlin.RequiresOptIn"
    )
}

Module Communication

Share code between modules:

Expose APIs

library/src/main/kotlin/Library.kt

package com.example.library

class LibraryClass {
    fun doSomething(): String {
        return "Hello from library"
    }
}

Consume APIs

app/src/main/kotlin/MainActivity.kt

import com.example.library.LibraryClass

class MainActivity : AppCompatActivity() {
    private val library = LibraryClass()
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        val result = library.doSomething()
        Log.d("MainActivity", result)
    }
}

Dependency Management

Module Dependencies

app/build.gradle.kts

dependencies {
    // Project modules
    implementation(project(":library"))
    api(project(":core"))           // Transitive
    compileOnly(project(":annotations"))
    
    // Different configurations
    debugImplementation(project(":debug-tools"))
    releaseImplementation(project(":release-tools"))
}

Repository Configuration

settings.gradle.kts

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
        maven { url = uri("https://jitpack.io") }
    }
}

Build Variants

Configure per-module variants:

library/build.gradle.kts

android {
    buildTypes {
        debug {
            isMinifyEnabled = false
        }
        release {
            isMinifyEnabled = true
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
        }
    }
    
    flavorDimensions += "version"
    productFlavors {
        create("free") {
            dimension = "version"
        }
        create("pro") {
            dimension = "version"
        }
    }
}

Best Practices

Modularize by Feature

Organize modules by features, not layers. This improves build times and team collaboration.

Use API Dependencies

Use api instead of implementation when dependencies must be transitive.

Keep Modules Focused

Each module should have a single, well-defined purpose.

Version Consistently

Use version catalogs or buildSrc to maintain consistent dependency versions.

Troubleshooting

Module Not Found

Error: Project ':module' not foundSolution:

Check settings.gradle.kts includes the module:
```
include(":app", ":library")
```
Verify the module directory exists
Run File → Sync Project with Gradle Files

Circular Dependencies

Error: Circular dependency between...Solution:

Review module dependency graph
Extract shared code to a common module
Use dependency inversion principle

Plugin Version Conflicts

Error: Plugin version mismatchSolution: Ensure all modules use compatible versions:

// Root build.gradle.kts
plugins {
    id("com.android.application") version "8.2.0" apply false
    id("com.android.library") version "8.2.0" apply false
}

Resource Conflicts

Error: Duplicate resourcesSolution: Add resource prefixes:

android {
    resourcePrefix = "library_"
}

Next Steps

Build your modular app
Configure environment variables for modules
Debug module issues
Use the AI Agent to generate module code

Get Started

Core Features

Development Tools

Guides

Language Support

Configuration

​Overview

​Project Modules

​Module Types

​Creating Modules

​Module Structure

​Module Dependencies

​Gradle Plugins

​Android Gradle Plugin (AGP)

​Kotlin Plugin

​Common Plugins

​Applying Plugins

​Custom Build Logic

​buildSrc Module

​Version Catalogs

​Template System

​Available Templates

​Template Structure

​Creating Custom Templates

​Plugin Configuration

​Android Plugin

​Kotlin Plugin

​Module Communication

​Expose APIs

​Consume APIs

​Dependency Management

​Module Dependencies

​Repository Configuration

​Build Variants

​Best Practices

Modularize by Feature

Use API Dependencies

Keep Modules Focused

Version Consistently

​Troubleshooting

​Next Steps

Build docs developers (and LLMs) love

Overview

Project Modules

Module Types

Creating Modules

Module Structure

Module Dependencies

Gradle Plugins

Android Gradle Plugin (AGP)

Kotlin Plugin

Common Plugins

Applying Plugins

Custom Build Logic

buildSrc Module

Version Catalogs

Template System

Available Templates

Template Structure

Creating Custom Templates

Plugin Configuration

Android Plugin

Kotlin Plugin

Module Communication

Expose APIs

Consume APIs

Dependency Management

Module Dependencies

Repository Configuration

Build Variants

Best Practices

Troubleshooting

Next Steps