New Project Setup

pluginManagement {
    repositories {
        gradlePluginPortal()
        google()
        mavenCentral()
    }
}

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
        maven {
            name = "IMG.LY Artifactory"
            url = uri("https://artifactory.img.ly/artifactory/maven")
            mavenContent {
                includeGroup("ly.img")
            }
        }
    }
}

rootProject.name = "My App"
include(":app")

plugins {
    id("com.android.application")
    id("kotlin-android")
}

android {
    namespace = "com.example.cesdkapp"
    compileSdk = 36

    defaultConfig {
        applicationId = "com.example.cesdkapp"
        minSdk = 24
        targetSdk = 36
        versionCode = 1
        versionName = "1.0"
        ndk {
            abiFilters += arrayOf("arm64-v8a", "armeabi-v7a", "x86_64", "x86")
        }
    }

    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_1_8
        targetCompatibility = JavaVersion.VERSION_1_8
    }

    kotlinOptions {
        jvmTarget = "1.8"
    }

    buildFeatures {
        compose = true
    }

    composeOptions {
        kotlinCompilerExtensionVersion = "1.5.3"
    }
}

dependencies {
    // This dependency makes main compose and coroutine APIs available in your project
    implementation("ly.img:editor:1.74.1")
    // Other dependencies here
}

Who Is This Guide For?#

This guide is for developers who:

• Have experience with Android development and Kotlin
• Want to create a new Android Activity-based project with integrated creative editing capabilities
• Need to implement user-friendly editing interfaces
• Want to add professional-grade image editing, design creation, and video editing to their Android apps
• Prefer using traditional Android Views with Activity-based architecture

What You’ll Achieve#

By following this guide, you:

• Create a new Android Activity-based project with CreativeEditor SDK integration
• Configure platform-specific requirements for Android
• Implement a functional editor that you can launch from your app
• Test and verify the integration works correctly

Prerequisites#

Before you begin, ensure you have the following requirements:

Development Environment#

• Android Studio: Latest version (Hedgehog or later)
• Kotlin: 1.9.10 or later
• Gradle: 8.4 or later
• Git CLI for version control

Platform Requirements#

• Android: 7.0+ (API level 24+)
• Minimum SDK: 24
• Target SDK: Latest stable version

License#

• A valid CE.SDK license key (Get a free trial), use null or an empty string to run in evaluation mode with watermark.

Verify Your Setup#

Run the following command to verify your Android development environment:

gradle --version

This command checks your Gradle installation and reports any issues to resolve before proceeding.

Step 1: Create a New Android Activity-Based Project#

First, verify your Android Studio installation and create a new project:

1. Open Android Studio and select “New Project”
2. Choose “Empty Views Activity” template
3. Configure your project:
   • Name: cesdk_android_activity_app
   • Package name: com.example.cesdkactivityapp
   • Language: Kotlin
   • Minimum SDK: API 24 (Android 7.0)
   • Build configuration language: Kotlin DSL

Project Structure#

Your new project should have this structure:

cesdk_android_activity_app/
├── app/                    # Main application module
│   ├── src/main/
│   │   ├── java/          # Kotlin source files
│   │   ├── res/           # Resources
│   │   └── AndroidManifest.xml
│   ├── build.gradle.kts   # App-level build configuration
│   └── proguard-rules.pro # ProGuard rules
├── gradle/                 # Gradle wrapper
├── build.gradle.kts        # Project-level build configuration
├── settings.gradle.kts     # Project settings
└── gradle.properties       # Gradle properties

Step 2: Add the CreativeEditor SDK Dependency#

Add the CreativeEditor SDK to your project by updating the build configuration:

2.1 Add IMG.LY Repository#

Update your settings.gradle.kts to include the IMG.LY repository:

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
        maven {
            name = "IMG.LY Artifactory"
            url = uri("https://artifactory.img.ly/artifactory/maven")
            mavenContent {
                includeGroup("ly.img")
            }
        }
    }
}

2.2 Add Editor Dependency#

Update your app/build.gradle.kts to include the editor dependency:

dependencies {
    // This dependency makes main compose and coroutine APIs available in your project
    implementation("ly.img:editor:1.74.1")
    // Other dependencies here
}

This adds the latest version of the CreativeEditor SDK editor to your build.gradle.kts file.

2.3 Configure Android Settings#

Update your app/build.gradle.kts to ensure proper configuration:

android {
    namespace = "com.example.cesdkapp"
    compileSdk = 36

    defaultConfig {
        applicationId = "com.example.cesdkapp"
        minSdk = 24
        targetSdk = 36
        versionCode = 1
        versionName = "1.0"
        ndk {
            abiFilters += arrayOf("arm64-v8a", "armeabi-v7a", "x86_64", "x86")
        }
    }

    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_1_8
        targetCompatibility = JavaVersion.VERSION_1_8
    }

    kotlinOptions {
        jvmTarget = "1.8"
    }

    buildFeatures {
        compose = true
    }

    composeOptions {
        kotlinCompilerExtensionVersion = "1.5.3"
    }
}

2.4 Sync Project#

After adding the dependency, sync your project to download the CreativeEditor SDK:

In Android Studio, click Sync Project with Gradle Files to download and configure all dependencies.

This downloads and installs the CreativeEditor SDK and its dependencies automatically through Gradle.

Step 3: Implement the Editor Integration#

Now let’s implement the CreativeEditor SDK editor in your Android application:

3.1 Create EditorComposable#

Create a new file EditorComposable.kt in your app module’s main source set (typically app/src/main/java/com/yourpackage/):

import android.widget.Toast
import androidx.compose.runtime.Composable
import androidx.compose.ui.platform.LocalContext
import ly.img.editor.Editor
import ly.img.editor.core.configuration.EditorConfiguration
import ly.img.editor.core.configuration.remember
import ly.img.engine.DesignBlockType

// Add this composable to your Activity, Fragment, NavHost etc.
@Composable
fun EditorComposable(onClose: (Throwable?) -> Unit) {
    val context = LocalContext.current
    Editor(
        // Get your license from https://img.ly/forms/free-trial
        // Keep this null for evaluation mode with watermark.
        // Replace it with your license key for production use.
        license = null,
        configuration = {
            EditorConfiguration.remember {
                onCreate = {
                    val scene = editorContext.engine.scene.create()
                    val page = editorContext.engine.block.create(DesignBlockType.Page)
                    editorContext.engine.block.setWidth(block = page, value = 1080F)
                    editorContext.engine.block.setHeight(block = page, value = 1080F)
                    editorContext.engine.block.appendChild(parent = scene, child = page)
                }
                onError = {
                    Toast.makeText(context, it.message, Toast.LENGTH_SHORT).show()
                }
            }
        },
        onClose = onClose,
    )
}

In this example, we create a scene with a single square page.

3.2 Create EditorActivity#

Create a new Kotlin file called EditorActivity.kt in your app module’s main source set (typically app/src/main/java/com/yourpackage/):

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent

// Launch this activity via intent
class EditorActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            EditorComposable { throwable ->
                // You can set result here
                finish()
            }
        }
    }
}

3.3 Update MainActivity#

Modify your existing MainActivity.kt file (located in app/src/main/java/com/yourpackage/) to launch the editor:

import android.content.Intent
import android.os.Bundle
import android.widget.Button
import androidx.appcompat.app.AppCompatActivity

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        findViewById<Button>(R.id.launchEditorButton).setOnClickListener {
            startActivity(Intent(this, EditorActivity::class.java))
        }
    }
}

3.4 Update Layout File#

Update your activity_main.xml to include a button:

<?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:orientation="vertical"
    android:gravity="center">

    <Button
        android:id="@+id/launchEditorButton"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Launch Creative Editor SDK" />

</LinearLayout>

3.5 Update AndroidManifest.xml#

Add the network permission that CE.SDK needs when it loads its default assets from the CDN:

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

Register the dedicated EditorActivity as well:

<activity
    android:name=".EditorActivity"
    android:exported="false"
    android:theme="@style/Theme.Material3.DayNight" />

Step 4: Test Your Editor Integration#

Now let’s test your CreativeEditor SDK editor integration:

4.1 Build and Run#

Build your Android project using Gradle:

4.2 Test on Android Device#

Connect your Android device and run:

# Build and install the app
./gradlew installDebug

# Or run from Android Studio
# Click the "Run" button (green play icon)

4.3 Verify Features#

After launching your app, verify these features work correctly:

• App Launch: The main activity opens without errors
• Button Interaction: The “Launch Creative Editor SDK” button responds to taps
• Editor Launch: The CreativeEditor SDK opens without errors
• Canvas Interaction: The blank page can be panned and zoomed.

Step 5: Customize for Your Use Case#

Step 6: Troubleshooting#

Common Issues and Solutions#

Gradle Sync Issues#

• Problem: Repository not found
• Solution: Verify the IMG.LY repository URL in settings.gradle.kts

Compilation Errors#

• Problem: Missing dependencies
• Solution: Ensure all required dependencies are included

Runtime Errors#

• Problem: Invalid license
• Solution: Verify your license key is correct and valid (or pass null for evaluation mode with watermark)

Performance Issues#

• Problem: Slow editor loading
• Solution: Check device specifications and memory usage

Integration Issues#

• Problem: Editor not displaying
• Solution: Verify the activity is properly registered in AndroidManifest.xml

Step 7: Next Steps#

Advanced Features#

• Implement custom asset sources
• Add custom filters and effects
• Integrate with your backend services
• Implement user authentication

Other Integrations#

• Explore camera integration
• Add video editing capabilities
• Implement batch processing
• Add cloud storage integration

Production Considerations#

• Optimize for performance
• Implement proper error handling
• Add analytics and monitoring
• Test on different device configurations

Additional Resources#

• CreativeEditor SDK Documentation
• Android Examples Repository
• Android Activity Documentation
• Android Development Guide