Drift to Android Studio

Migrating your projects to Android Studio requires adapting to a new project structure, build system, and IDE functionality. If you lot are migrating an Android project from Eclipse, Android Studio provides an import tool then you can quickly move your existing code into Android Studio projects and Gradle-based build files. For more information, see Migrating from Eclipse.

If you are migrating from IntelliJ and your projection already uses Gradle, yous tin can simply open your existing projection from Android Studio. If y'all are using IntelliJ, but your project does not already use Gradle, you volition need to exercise a piddling scrap of manual preparation before you can import your project into Android Studio. For more data, see Migrating from IntelliJ.

Android Studio basics

Here are some of the fundamental differences you should exist aware of equally you prepare to migrate to Android Studio.

Project and module organization

Android Studio is based on the IntelliJ Idea IDE. To go familiar with the IDE basics, such as navigation, lawmaking completion, and keyboard shortcuts, encounter Meet Android Studio.

Android Studio does not employ workspaces, then separate projects open in split up Android Studio windows. Android Studio organizes code into projects, which contain everything that defines your Android app, from app source code to build configurations and test lawmaking. Each project contains one or more modules, which allow you to carve up your project into discrete units of functionality. Modules can exist independently built, tested, and debugged.

For more information almost Android Studio projects and modules, see the Projects overview.

Gradle-based build system

Android Studio's build organization is based on Gradle and uses build configuration files written in Groovy syntax for ease of extensibility and customization.

Gradle-based projects offering meaning features for Android evolution, including the following:

  • Support for binary libraries (AARs). You no longer need to copy library sources into your own projects, you tin can simply declare a dependency and the library is automatically downloaded and merged into your projection. This includes automatically merging in resource, manifest entries, proguard exclusion rules, custom lint rules, so on at build fourth dimension.
  • Support for build variants. For instance, build variants let you build different versions of your app (such as a costless version and a pro version) from the aforementioned project.
  • Easy build configuration and customization. For example, you can pull version names and version codes from Git tags as part of the build.
  • Gradle can be used from the IDE but too from the command line and from continuous integration servers like Jenkins, providing the same build everywhere, every time.

For more than information about using and configuring Gradle, see Configure your build.

Dependencies

Library dependencies in Android Studio apply Gradle dependency declarations and Maven dependencies for well-known local source and binary libraries with Maven coordinates. For more data see, Configure build variants.

Exam code

With Eclipse ADT, instrumentation tests are written in split projects and integrated through the <instrumentation> element in your manifest file. Android Studio provides an androidTest/ directory in your projection's main sourceset so you lot can hands add and maintain your instrumentation exam code within the same project view. Android Studio also provides a test/ directory in your project'southward chief sourceset for local JVM tests.

Migrating from Eclipse

Android Studio offers an automated import tool for existing Android projects created using Eclipse.

Migration prerequisites

Before migrating your app from Eclipse to Android Studio, review the following steps to brand sure your project is set for conversion, and verify you lot have the tool configuration you demand in Android Studio:

In Eclipse ADT:

  • Make certain the Eclipse ADT root directory contains the AndroidManifest.xml file. Besides, the root directory must contain either the .project and .classpath files from Eclipse or the res/ and src/ directories.
  • Build your project to ensure your latest workspace and project updates are saved and included in the import.
  • Annotate out any references to Eclipse ADT workspace library files in the projection.properties or.classpath files for import. Y'all can add together these references in the build.gradle file after the import. For more data, see Configure your build.
  • It may be useful to record your workspace directory, path variables, and any actual path maps that could be used to specify any unresolved relative paths, path variables, and linked resource references. Android Studio allows you to manually specify whatever unresolved paths during the import procedure.

In Android Studio:

  • If you don't have it, download Android Studio. If you do take Android Studio, verify that it is the latest stable release by clicking Help > Bank check for Updates (on Mac, Android Studio > Check for Updates).
  • Because Android Studio does non migrate any third-party Eclipse ADT plugins, make a note of any tertiary-party plugins you lot use in Eclipse. Yous can bank check for equivalent features in Android Studio or search for a compatible plugin in the IntelliJ Android Studio Plugins repository. Use the File > Settings > Plugins menu option to manage plugins in Android Studio.
  • If you plan to run Android Studio behind a firewall, exist sure to fix the proxy settings for Android Studio and the SDK Managing director. Android Studio requires an internet connection for Setup Sorcerer synchronization, 3rd-party library access, access to remote repositories, Gradle initialization and synchronization, and Android Studio version updates. For more than information, come across Proxy settings.

Import Eclipse projects to Android Studio

You should decide how you will import your existing Eclipse ADT projects depending on their structure:

  • If you lot have multiple related projects sharing the same workspace in Eclipse ADT, import the first project as a projection, and then add subsequent related projects as modules within that project.
  • If your Eclipse ADT projects share dependencies within the same workspace but are not otherwise related, import each Eclipse ADT projection individually into Android Studio as a dissever project. Android Studio maintains the shared dependencies across the newly created projects every bit part of the import procedure.
  • If your Eclipse ADT project includes native (C/C++) libraries, run across Link Gradle to your native library for instructions on how to include your native libraries as Gradle build dependencies.

Import as a project:

  1. Get-go Android Studio and close any open Android Studio projects.
  2. From the Android Studio menu click File > New > Import Project.
    • Alternatively, from the Welcome screen, click Import project (Eclipse ADT, Gradle, etc.).
  3. Select the Eclipse ADT project folder with the AndroidManifest.xml file and click Ok.

  4. Select the destination folder and click Next.

  5. Select the import options and click Finish.

  6. The import process prompts yous to drift any library and projection dependencies to Android Studio, and add together the dependency declarations to the build.gradle file. Come across Create an Android library for more information almost this process.

    The import procedure besides replaces any well-known source libraries, binary libraries, and JAR files that have known Maven coordinates with Maven dependencies, and so y'all no longer demand to maintain these dependencies manually. The import options also allow you to enter your workspace directory and any actual path maps to handle whatsoever unresolved relative paths, path variables, and linked resource references.

  7. Android Studio imports the app and displays the project import summary. Review the summary for details almost the project restructuring and the import procedure.

After importing the projection from Eclipse ADT into Android Studio, each app module binder in Android Studio contains the complete source set for that module, including the src/chief/ and src/androidTest/ directories, resources, build file, and Android manifest. Earlier starting app evolution, you lot should resolve whatsoever issues shown in the project import summary to make certain the project re-structuring and import process completed properly.

Import every bit a module:

  1. Start Android Studio and open the project you'd similar to add together the module to.
  2. From the Android Studio menu click File > New > Import Module.
  3. Select the Eclipse ADT project folder with the AndroidManifest.xml file and click Ok.
  4. Modify the module proper name if desired, and click Next.
  5. The import procedure prompts you to drift whatsoever library and project dependencies to Android Studio, and add the dependency declarations to the build.gradle file. For more about migrating library and project dependencies, run across Create an Android library. The import process likewise replaces whatsoever well-known source libraries, binary libraries, and JAR files that have known Maven coordinates with Maven dependencies, so yous no longer demand to maintain these dependencies manually. The import options besides allow yous to enter your workspace directory and any actual path maps to handle whatever unresolved relative paths, path variables, and linked resources references.
  6. Click Stop.

Validate imported projects

After completing the import procedure, use the Android Studio Build and Run carte options to build your project and verify the output. If your project is not edifice properly, check the post-obit settings:

  • Verify the installed versions of your tools match the settings for your Eclipse projection by opening the SDK Managing director (click the Android SDK Director button in Android Studio or Tools > SDK Manager). Android Studio inherits the SDK Manager and JDK settings from your imported Eclipse project.

  • To verify boosted Android Studio Settings, click File > Projection Construction and audit the following:

    • Under SDK Location verify Android Studio has access to the correct SDK, NDK, and JDK locations and versions.

    Note: If you used the default settings, Eclipse ADT installed Android SDK in User\user-name\android-sdks\ on Windows, and in Users/user-proper noun/Library/Android/sdk/ on Mac.

    • Under Project verify the Gradle version, Android plugin version, and related repositories.
    • Under Modules verify the app and module settings, such as signing configuration and library dependencies.

  • If your projection depends on another projection, make certain that dependency is defined properly in the build.gradle file in the app module folder. For more information about defining dependencies, run into Configure build variants.

If there even so are unexpected bug when edifice and running your project in Android Studio after you have checked these settings, consider modifying the Eclipse ADT project and re-starting the import process.

Note: Importing an Eclipse ADT project to Android Studio creates a new Android Studio project and does not impact the existing Eclipse ADT projection.

Migrating from IntelliJ

If your IntelliJ project uses the Gradle build system, you can automatically import your projection directly into Android Studio. If your IntelliJ project uses Maven or another build system, you need to set information technology up to piece of work with Gradle before you can migrate to Android Studio.

Import a Gradle-based IntelliJ project

If you are already using Gradle with your IntelliJ projection, you can open it in Android Studio using the following steps:

  1. Click File > New > Import Projection.
  2. Select your IntelliJ project directory, and click OK. Your projection will open in Android Studio.

Import a non-Gradle IntelliJ projection

If your IntelliJ project does not already use the Gradle build organisation, y'all have two options for importing your project into Android Studio:

  • Create a new empty Android Studio projection and copy your existing source code into the directories associated with the new projection. For more than information, see Migrate by creating a new empty project.
  • Manually create a new Gradle build file for your project and and so import the project and new build file into Android Studio. For more data run into Migrate by creating a custom Gradle build file.

Migrate by creating a new empty projection

To migrate your project into Android Studio by creating a new empty project and copying your source files into the new directories, proceed as follows:

  1. Open Android Studio, and click File > New > New Projection.
  2. Enter a name for your app project and specify the location where it should be created, and so click Next.
  3. Select the form factors your app will run on, and then click Adjacent.
  4. Click Add No Activity, and and then click Finish.
  5. In the Project tool window, click the arrow to open up the view dropdown, and select the Projection view to encounter and explore the organization of your new Android Studio project. To read more about irresolute views and how Android Studio structures projects, see Project Files.
  6. Navigate to the location you selected for your new project and move the lawmaking, unit tests, instrumentation tests, and resource from your old project directories into the correct locations in your new project structure.
  7. In Android Studio, click File > Project Structure to open up the Project Structure dialog. Ensure that your app's module is selected in the left pane.
  8. Make whatsoever necessary modifications in the Properties tab for your projection (for example, modifying the minSdkVersion or targetSdkVersion).
  9. Click Dependencies and add any libraries your projection depends on equally Gradle dependencies. To add together a new dependency, click Add together , then select the blazon of dependency you would like to add and follow the prompts.
  10. Click OK to save your modifications.
  11. Click Build > Brand Project to examination edifice your project, and resolve any outstanding errors.

Migrate by creating a custom Gradle build file

To migrate your project into Android Studio by creating a new Gradle build file to signal to your existing source files, keep as follows:

  1. Before you lot begin, be sure to back up your project files in a separate location, as the migration process will modify the contents of your project in place.
  2. Next, create a file in your project directory chosen build.gradle. The build.gradle file will contain all the data required for Gradle to run your build.

    By default, Android Studio expects your project to exist organized as shown in figure 1.

    Figure ane. The default project structure for an Android app module.

    Since your IntelliJ project does not employ the same structure, your build.gradle file needs to indicate the source directories for the build to your existing folders (for case, res/ and src/) instead of the default new directory structure. The following example build.gradle file includes the basic setup for a Gradle build, also as a sourceSets{} cake inside the android{} cake to ascertain the correct source directories and move the tests and build types to avoid naming conflicts. Copy the code block below into your build.gradle file and make whatever changes necessary to work with your existing project setup. For instance, you may have additional dependencies to include, be using a different target SDK version, or need to specify dissimilar locations for your source directories.

    Slap-up

    // This buildscript{} block configures the code driving the build buildscript {    /**     * The nested repositories{} block declares that this build uses the     * jcenter repository.     */     repositories {         jcenter()     }     /**     * This block declares a dependency on the 7.1.2 version     * of the Gradle plugin for the buildscript.     */     dependencies {         classpath 'com.android.tools.build:gradle:vii.1.2'     } }  /**  * This line applies the com.android.application plugin. Note that y'all should  * only apply the com.android.application plugin. Applying the Java plugin as  * well will result in a build error.  */ plugins {   id 'com.android.application' }  /**  * This dependencies block includes any dependencies for the projection itself. The  * post-obit line includes all the JAR files in the libs directory.  */ dependencies {     compile fileTree(dir: 'libs', include: ['*.jar'])     // Add other library dependencies here (run into the next step) }  /**  * The android{} cake configures all of the parameters for the Android build.  * You must provide a value for at least the compilation target.  */ android {     compileSdkVersion 28      /**     * This nested sourceSets block points the source code directories to the     * existing folders in the project, instead of using the default new     * organization.     */     sourceSets {         main {             manifest.srcFile 'AndroidManifest.xml'             java.srcDirs = ['src']             resources.srcDirs = ['src']             aidl.srcDirs = ['src']             renderscript.srcDirs = ['src']             res.srcDirs = ['res']             assets.srcDirs = ['assets']         }          // Move the tests to tests/java, tests/res, etc...         instrumentTest.setRoot('tests')         /**         * Move the build types to build-types/<type>         * For instance, build-types/debug/java, build-types/debug/AndroidManifest.xml, ...         * This moves them out of them default location under src/<type>/... which would         * conflict with src/ being used past the master source set.         * Adding new build types or product flavors should exist accompanied         * past a similar customization.         */         debug.setRoot('build-types/debug')         release.setRoot('build-types/release')      } }

    Kotlin

    // This buildscript{} block configures the lawmaking driving the build buildscript {    /**     * The nested repositories{} block declares that this build uses the     * jcenter repository.     */     repositories {         jcenter()     }     /**     * This block declares a dependency on the 7.1.two version     * of the Gradle plugin for the buildscript.     */     dependencies {         classpath("com.android.tools.build:gradle:7.i.2")     } }  /**  * This section applies the com.android.awarding plugin. Notation that you  * should simply apply the com.android.application plugin. Applying the Coffee  * plugin likewise will effect in a build fault.  */ plugins {     id("com.android.application") }  /**  * This dependencies cake includes any dependencies for the project itself. The  * following line includes all the JAR files in the libs directory.  */ dependencies {     implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.jar"))))     // Add together other library dependencies here (see the next step) }  /**  * The android{} block configures all of the parameters for the Android build.  * You must provide a value for at least the compilation target.  */ android {     compileSdkVersion(28)      /**     * This nested sourceSets block points the source code directories to the     * existing folders in the project, instead of using the default new     * organization.     */     sourceSets {         getByName("primary") {             manifest.srcFile("AndroidManifest.xml")             coffee.srcDirs("src")             resources.srcDirs("src")             aidl.srcDirs("src")             renderscript.srcDirs("src")             res.srcDirs("res")             assets.srcDirs("assets")         }          // Move the tests to tests/java, tests/res, etc...         getByName("instrumentTest").setRoot("tests")         /**         * Motion the build types to build-types/<blazon>         * For instance, build-types/debug/java, build-types/debug/AndroidManifest.xml, ...         * This moves them out of them default location under src/<type>/... which would         * conflict with src/ being used by the main source set up.         * Calculation new build types or production flavors should exist accompanied         * by a similar customization.         */         getByName("debug").setRoot('build-types/debug')         getByName("release").setRoot('build-types/release')      } }

    Warning: The JCenter repository became read-only on March 31st, 2021. For more information, encounter JCenter service update.

    For more information well-nigh setting up and customizing a Gradle build file, read Configure your build.
  3. Next, place which library projects you are using. With Gradle, you no longer need to add these libraries as source code projects, y'all tin refer to them in the dependencies{} block of your build file instead. The build system then handles these libraries for y'all, including downloading libraries, merging in resource, and merging manifest entries. The following example adds the declaration statements for Google Play Services and a number of support libraries to the dependencies{} block shown in the instance build file higher up.

    Groovy

    ... dependencies {     compile fileTree(dir: 'libs', include: ['*.jar'])      // Google Play Services     compile 'com.google.android.gms:play-services:nine.8.0'      // Support Libraries     compile 'com.android.support:appcompat-v7:28.0.0'     compile 'com.android.back up:cardview-v7:28.0.0'     compile 'com.android.back up:blueprint:28.0.0'     compile 'com.android.support:gridlayout-v7:28.0.0'     compile 'com.android.support:leanback-v17:28.0.0'     compile 'com.android.back up:mediarouter-v7:28.0.0'     compile 'com.android.back up:palette-v7:28.0.0'     compile 'com.android.support:recyclerview-v7:28.0.0'     compile 'com.android.support:support-annotations:28.0.0'     compile 'com.android.back up:back up-v13:28.0.0'     compile 'com.android.support:support-v4:28.0.0'      // Annotation: these libraries require the "Google Repository" and "Android Repository"     //       to exist installed via the SDK manager. }

    Kotlin

    ... dependencies {     implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.jar"))))      // Google Play Services     implementation("com.google.android.gms:play-services:nine.eight.0")      // Support Libraries     implementation("com.android.support:appcompat-v7:28.0.0")     implementation("com.android.support:cardview-v7:28.0.0")     implementation("com.android.support:design:28.0.0")     implementation("com.android.support:gridlayout-v7:28.0.0")     implementation("com.android.support:leanback-v17:28.0.0")     implementation("com.android.support:mediarouter-v7:28.0.0")     implementation("com.android.support:palette-v7:28.0.0")     implementation("com.android.support:recyclerview-v7:28.0.0")     implementation("com.android.support:support-annotations:28.0.0")     implementation("com.android.support:support-v13:28.0.0")     implementation("com.android.support:support-v4:28.0.0")      // Note: these libraries require the "Google Repository" and "Android Repository"     //       to be installed via the SDK managing director. }
    For help determining the correct declaration statements for your libraries, Gradle, please can provide you with the right announcement statements based on Maven Key.
  4. Save your build.gradle file, then close the projection in IntelliJ. Navigate to your project directory, and delete the .thought directory and any .iml files inside your project.
  5. Launch Android Studio, and click File > New > Import Project.
  6. Locate your project directory, click the build.gradle file you lot created above to select it, and and then click OK to import your project.
  7. Click Build > Make Projection to test your build file by building your project and address whatever errors you find.

Next steps

Once you have migrated your projection to Android Studio, learn more about edifice with Gradle and running your app in Android Studio by reading Build and run your app.

Depending on your projection and workflow, you lot may also wish to read more about using version control, managing dependencies, signing and packaging your app, or configuring and updating Android Studio. To get started using Android Studio, read Run across Android Studio.

Configure version control

Android Studio supports a variety of version control systems, including Git, GitHub, CVS, Mercurial, Subversion, and Google Cloud Source Repositories.

After importing your app into Android Studio, utilize the Android Studio VCS menu options to enable VCS support for the desired version control organisation, create a repository, import the new files into version control, and perform other version control operations:

  1. From the Android Studio VCS menu, click Enable Version Control Integration.
  2. Select a version control organization to associate with the projection root from the drop down carte du jour, so click OK. The VCS menu at present displays a number of version control options based on the organization you selected.

Annotation: You tin also apply the File > Settings > Version Control bill of fare option to gear up upward and modify the version control settings.

For more data about working with Version Control see IntelliJ Version Command Reference.

Android Back up repository and Google Play Services repository

While Eclipse ADT uses the Android Back up Library and Google Play services Library, Android Studio replaces these libraries during the import procedure with the Android Support Repository and Google Repository to maintain compatible functionality and back up new Android features. Android Studio adds these dependencies as Maven dependencies using the known Maven coordinates, and so these dependencies exercise non require transmission updates.

In Eclipse, in order to use a Back up Library, you must change your project's classpath dependencies within your evolution environs for each Support Library you want to utilise. In Android Studio, y'all no longer need to copy library sources into your ain projects, y'all can simply declare a dependency and the library is automatically downloaded and merged into your project. This includes automatically merging in resources, manifest entries, ProGuard exclusion rules, and custom lint rules at build time. For more information about dependencies, run into Configure build variants.

App signing

If your app used a debug certificate in Eclipse ADT, Android Studio continues to reference that certificate. Otherwise, the debug configuration uses the Android Studio generated debug keystore, with a known password and a default key with a known password located in $HOME/.android/debug.keystore. The debug build type is ready to employ this debug configuration automatically when you run or debug your projection from Android Studio.

When building your app for release, Android Studio applies the release certificate used in Eclipse ADT. If no release certificate was located during the import process, add together the release signing configuration to the build.gradle file or utilize the Build > Generate Signed APK menu option to open the Generate Signed APK Magician. For more data about signing your app, see Sign your app.

Adjusting Android Studio's maximum heap size

By default, Android Studio has a maximum heap size of 1280MB. If you are working on a large project, or your arrangement has a lot of RAM, y'all can improve performance by increasing the maximum heap size.

Software updates

Android Studio updates separately from the Gradle plugin, the build tools, and the SDK tools. You lot can specify which versions you would like to utilise with Android Studio.

By default, Android Studio provides automatic updates whenever a new stable version is released, but yous can cull to update more than frequently and also receive preview or beta versions.

For more information well-nigh updating Android Studio and using preview and beta versions, see Stay updated.