Cómo migrar a Android Studio

Para migrar tus proyectos a Android Studio, debes adaptarte a una estructura de proyecto, una funcionalidad IDE y un sistema de compilación nuevos. Si realizas la migración de un proyecto de Android desde Eclipse, Android Studio proporciona una herramienta de importación para que traslades rápidamente tu código existente a proyectos de Android Studio y archivos de compilación basados en Gradle. Para obtener más información, consulta Cómo migrar desde Eclipse.

Si realizas la migración desde IntelliJ y tu proyecto ya usa Gradle, puedes abrir directamente tu proyecto existente desde Android Studio. Si usas IntelliJ, pero tu proyecto todavía no usa Gradle, deberás implementar algunas acciones manuales para poder importar tu proyecto a Android Studio. Para obtener más información, consulta Cómo migrar desde IntelliJ.

Conceptos básicos de Android Studio

A continuación, te indicamos algunas de las diferencias clave que debes conocer mientras te preparas para la migración a Android Studio.

Organización del proyecto y de los módulos

Android Studio está basado en el IDE de IntelliJ IDEA. Para familiarizarte con los conceptos básicos de IDE, como la navegación, la compleción de código y las combinaciones de teclas, consulta Introducción a Android Studio.

Android Studio no usa lugares de trabajo, por lo que cada proyecto se abre en una ventana diferente del programa. Android Studio organiza el código en proyectos, que contienen todo lo que define tu app para Android: desde el código fuente hasta las configuraciones de compilación y el código de prueba. Cada proyecto contiene uno o más módulos que te permiten dividirlo en unidades de funcionalidad discretas. Los módulos se pueden compilar, probar y depurar de forma independiente.

Para obtener más información sobre los proyectos y módulos de Android Studio, consulta Descripción general de proyectos.

Sistema de compilación basado en Gradle

El sistema de compilación de Android Studio se basa en Gradle y usa archivos de configuración de compilación escritos con sintaxis Groovy para facilitar la extensibilidad y personalización.

Los proyectos basados en Gradle ofrecen funciones importantes para el desarrollo de Android. Se incluyen las siguientes:

  • Compatibilidad con bibliotecas binarias (AAR). Ya no necesitas copiar recursos de biblioteca a tus proyectos; puedes simplemente declarar una dependencia y la biblioteca se descargará y fusionará de manera automática en tu proyecto. Esta función incluye la fusión automática en recursos, entradas de manifiesto, reglas de exclusión de ProGuard y reglas de Lint personalizadas, entre otros aspectos, en tiempo de compilación.
  • Compatibilidad con variantes de compilación. Por ejemplo, las variantes de compilación te permiten compilar diferentes versiones de tu app (como una versión gratuita y otra profesional) a partir del mismo proyecto.
  • Fácil configuración de compilación y personalización. Por ejemplo, puedes obtener nombres de versión y códigos de versión de las etiquetas Git como parte de la compilación.
  • Gradle se puede usar desde el IDE, pero también desde la línea de comandos y desde servidores de integración continua como Jenkins, lo que proporciona la misma compilación en cualquier momento y lugar.

Para obtener más información sobre el uso y la configuración de Gradle, consulta Cómo configurar tu compilación.

Dependencias

Las dependencias de bibliotecas en Android Studio usan declaraciones de dependencia de Gradle y dependencias Maven para bibliotecas fuente locales y binarias conocidas con coordenadas Maven. Para obtener más información, consulta Cómo configurar variantes de compilación.

Código de prueba

Con el complemento de ADT para Eclipse, las pruebas de instrumentación se escriben en proyectos diferentes y se integran a través del elemento <instrumentation> en tu archivo de manifiesto. Android Studio proporciona un directorio androidTest/ en el conjunto principal de archivos fuente de tu proyecto, para que puedas agregar y mantener fácilmente tu código de prueba de instrumentación en la misma vista del proyecto. Android Studio también proporciona un directorio test/ en el conjunto de fuentes principal de su proyecto para las pruebas de JVM locales.

Migración desde Eclipse

Android Studio ofrece una herramienta de importación automatizada para los proyectos de Android creados con Eclipse.

Requisitos previos para la migración

Antes de migrar tu app de Eclipse a Android Studio, repasa los siguientes pasos a fin de asegurarte de que tu proyecto esté listo para la conversión y confirma que dispones de la configuración de herramientas que necesitas en Android Studio:

En el complemento ADT de Eclipse:

  • Asegúrate de que el directorio raíz del complemento de ADT para Eclipse contenga el archivo AndroidManifest.xml. Asimismo, el directorio raíz debe contener los archivos .project y .classpath de Eclipse o los directorios res/ y src/.
  • Compila tu proyecto para asegurarte de que se guarden y se incluyan en la importación las últimas actualizaciones del área de trabajo y el proyecto.
  • Realiza comentarios sobre las referencias a los archivos de biblioteca del lugar de trabajo del complemento de ADT para Eclipse en los archivos project.properties o .classpath para la importación. Puedes agregar estas referencias en el archivo build.gradle después de la importación. Para obtener más información, consulta Cómo configurar tu compilación.
  • Puede resultar útil registrar tu directorio de lugar de trabajo, las variables de ruta de acceso y los mapas de ruta de acceso reales que podrían usarse para especificar rutas de acceso relativas, variables de ruta de acceso y referencias a recursos vinculados no resueltas. Android Studio te permite especificar manualmente las rutas de acceso no resueltas durante el proceso de importación.

En Android Studio:

  • So no tienes Android Studio, descárgalo. Si lo tienes, asegúrate de contar con la última versión estable. Para ello, haz clic en Help > Check for Updates (en Mac, Android Studio > Check for Updates).
  • Como Android Studio no migra complementos de ADT de terceros para Eclipse, toma nota de los complementos de terceros que usas en Eclipse. Puedes comprobar si existen funciones equivalentes en Android Studio o buscar un complemento compatible en el repositorio de Complementos de Android Studio de IntelliJ. Usa la opción del menú File > Settings > Plugins para administrar complementos en Android Studio.
  • Si piensas ejecutar Android Studio detrás de un firewall, asegúrate de configurar los ajustes del proxy para Android Studio y el administrador de SDK. Android Studio requiere una conexión a Internet para la sincronización del asistente de configuración, el acceso a bibliotecas de terceros, el acceso a repositorios remotos, la inicialización y sincronización de Gradle, y actualizaciones de versión de Android Studio. Para obtener más información, consulta Configuración de proxy.

Cómo importar proyectos de Eclipse a Android Studio

Debes decidir cómo importarás tus proyectos de ADT para Eclipse según su estructura:

  • Si tienes varios proyectos relacionados que comparten el mismo lugar de trabajo en el complemento ADT para Eclipse, importa el primer proyecto como un proyecto y, luego, agrega proyectos relacionados posteriores como módulos dentro de ese proyecto.
  • Si tus proyectos de ADT para Eclipse comparten dependencias dentro del mismo lugar de trabajo y no están relacionados de otra manera, importa cada proyecto de ADT para Eclipse de forma individual a Android Studio como un proyecto independiente. Como parte del proceso de importación, Android Studio mantiene las dependencias compartidas en los proyectos recientemente creados.
  • Si tu proyecto de ADT para Eclipse incluye bibliotecas (C/C++) nativas, consulta Cómo vincular Gradle a tu biblioteca nativa para obtener instrucciones sobre cómo incluir tus bibliotecas nativas como dependencias de compilación de Gradle.

Cómo importar como proyecto:

  1. Inicia Android Studio y cierra los proyectos de Android Studio abiertos.
  2. Desde el menú de Android, haz clic en File > New > Import Project.
    • Como opción, en la pantalla de bienvenida, haz clic en Import project (Eclipse ADT, Gradle, etc.).
  3. Selecciona la carpeta del proyecto de ADT para Eclipse con el archivo AndroidManifest.xml y haz clic en Ok.

  4. Selecciona la carpeta de destino y haz clic en Next.

  5. Selecciona las opciones de importación y haz clic en Finish.
  6. El proceso de importación te indicará que migres las dependencias de bibliotecas y proyectos a Android Studio, y que agregues las declaraciones de las dependencias al archivo build.gradle. Consulta Cómo crear una biblioteca de Android para obtener más información sobre este proceso.

    El proceso de importación también reemplaza las bibliotecas fuente conocidas, las bibliotecas binarias y los archivos JAR que poseen coordenadas Maven conocidas con dependencias de Maven, de modo que ya no necesites mantener esas dependencias manualmente. Las opciones de importación también te permiten ingresar al directorio de tu lugar de trabajo y a los mapas de ruta de acceso reales para abordar las vías de acceso relativas, variables de vías de acceso y referencias a recursos vinculados no resueltas.

  7. Android Studio importa la app y muestra el resumen de importación del proyecto. Lee el resumen para obtener información detallada sobre la reestructuración del proyecto y el proceso de importación.

Después de importar el proyecto del complemento ADT para Eclipse a Android Studio, la carpeta de cada módulo de la app en Android Studio contendrá el conjunto completo de archivos fuente para ese módulo, incluidos los directorios src/main/ y src/androidTest/, los recursos, el archivo de compilación y el manifiesto de Android. Antes de comenzar a desarrollar la app, debes resolver los problemas que se muestran en el resumen de importación del proyecto para asegurarte de que el proceso de reestructuración y de importación del proyecto se haya completado correctamente.

Cómo importar como módulo:

  1. Inicia Android Studio y abre el proyecto al que quieras agregar el módulo.
  2. Desde el menú de Android Studio, haz clic en File > New > Import Module.
  3. Selecciona la carpeta del proyecto de ADT para Eclipse con el archivo AndroidManifest.xml y haz clic en Ok.
  4. Si lo deseas, puedes modificar el nombre del módulo y, luego, hacer clic en Next.
  5. El proceso de importación te indicará que migres las dependencias de bibliotecas y proyectos a Android Studio, y que agregues las declaraciones de las dependencias al archivo build.gradle. Para obtener más información sobre la migración de dependencias de bibliotecas y proyectos, consulta Cómo crear una biblioteca de Android. El proceso de importación también reemplaza las bibliotecas fuente conocidas, las bibliotecas binarias y los archivos JAR que poseen coordenadas Maven conocidas con dependencias de Maven, de modo que ya no necesites mantener esas dependencias manualmente. Las opciones de importación también te permiten ingresar al directorio de tu lugar de trabajo y a los mapas de ruta de acceso reales para abordar las vías de acceso relativas, variables de vías de acceso y referencias a recursos vinculados no resueltas.
  6. Haz clic en Finish.

Cómo validar proyectos importados

Después de completar el proceso de importación, usa las opciones de menú "Build" y "Run" de Android Studio para compilar tu proyecto y verificar el resultado. Si tu proyecto no se compila correctamente, revisa los siguientes ajustes de configuración:

  • Verifica que las versiones instaladas de tus herramientas coincidan con la configuración de tu proyecto de Eclipse. Para ello, abre SDK Manager (haz clic en el botón de Android SDK Manager en Android Studio o en Tools > SDK Manager). Android Studio hereda la configuración del administrador de SDK y de JDK de tu proyecto de Eclipse importado.
  • Para verificar opciones adicionales de Android Studio, haz clic en File > Project Structure y consulta lo siguiente:

    • En SDK Location, verifica que Android Studio tenga acceso a las ubicaciones y versiones correctas de SDK, NDK y JDK.

    Nota: Si usaste la configuración predeterminada, el complemento de ADT para Eclipse instala el SDK de Android en User\user-name\android-sdks\ en Windows, o en Users/user-name/Library/Android/sdk/ en Mac.

    • En Project, verifica la versión de Gradle, la versión del complemento de Android y los repositorios relacionados.
    • En Modules, verifica la configuración de la app y los módulos; por ejemplo, la configuración de firma y las dependencias de bibliotecas.
  • Si tu proyecto depende de otro proyecto, asegúrate de que la dependencia se haya definido correctamente en el archivo build.gradle de la carpeta de módulos de la app. Para obtener más información sobre la definición de dependencias, consulta Cómo configurar variantes de compilación.

Si aún se presentan problemas inesperados al compilar y ejecutar tu proyecto en Android Studio después de haber comprobado estas configuraciones, considera modificar el proyecto de ADT para Eclipse y volver a iniciar el proceso de importación.

Nota: Cuando importas un proyecto de ADT para Eclipse a Android Studio, se crea un nuevo proyecto de Android Studio que no afecta el proyecto existente de ADT para Eclipse.

Realiza la migración desde IntelliJ

Si tu proyecto de IntelliJ usa el sistema de compilación de Gradle, puedes importar tu proyecto directamente a Android Studio. Si tu proyecto de IntelliJ usa Maven o algún otro sistema de compilación, para poder realizar la migración a Android Studio debes configurarlo de modo que funcione con Gradle.

Cómo importar un proyecto de IntelliJ basado en Gradle

Si ya usas Gradle con tu proyecto de IntelliJ, sigue estos pasos para abrirlo en Android Studio:

  1. Haz clic en File > New > New Project.
  2. Selecciona tu directorio de proyectos de IntelliJ y haz clic en OK. Tu proyecto se abrirá en Android Studio.

Cómo importar un proyecto de IntelliJ no basado en Gradle

Si tu proyecto de IntelliJ todavía no usa el sistema de compilación de Gradle, tienes dos opciones para importar tu proyecto a Android Studio:

Cómo realizar la migración creando un nuevo proyecto vacío

Para migrar tu proyecto a Android Studio creando un nuevo proyecto vacío y copiando tus archivos fuente en nuevos directorios, sigue estos pasos:

  1. Abre Android Studio y haz clic en File > New > New Project.
  2. Escribe un nombre para tu proyecto de app, especifica la ubicación en la que debe crearse y, luego, haz clic en Next.
  3. Selecciona los factores de forma sobre los que se ejecutará tu app y haz clic en Siguiente.
  4. Haz clic en Add No Activity y, luego, en Finish.
  5. En la ventana de herramientas Project, haz clic en la flecha para abrir la lista desplegable de vistas, y selecciona la vista Project para ver y explorar la organización de tu nuevo proyecto de Android Studio. Para obtener más información sobre la forma en que se cambian las vistas y en que Android Studio estructura los proyectos, consulta Project Files.
  6. Dirígete a la ubicación que seleccionaste para tu nuevo proyecto y mueve el código, las pruebas de unidad, las pruebas de instrumentación y los recursos de tus antiguos directorios de proyectos a las ubicaciones correspondientes en tu nueva estructura de proyecto.
  7. En Android Studio, haz clic en File > Project Structure para abrir el diálogo Project Structure. Asegúrate de que el módulo de tu app esté seleccionado en el panel izquierdo.
  8. Realiza todas las modificaciones necesarias a tu proyecto en la pestaña Properties (por ejemplo, modifica minSdkVersion o targetSdkVersion).
  9. Haz clic en Dependencies y agrega las bibliotecas de las que depende tu proyecto como dependencias de Gradle. Para agregar una dependencia nueva, haz clic en Add , selecciona el tipo de dependencia que desees agregar y sigue las indicaciones.
  10. Haz clic en OK para guardar las modificaciones.
  11. Haz clic en Build > Make Project para realizar pruebas de compilación de tu proyecto y resolver cualquier error existente.

Cómo realizar la migración creando un archivo de compilación de Gradle personalizado

Para migrar tu proyecto a Android Studio creando un nuevo archivo de compilación de Gradle que apunte a tus archivos fuente existentes, sigue estos pasos:

  1. Antes de comenzar, asegúrate de crear una copia de seguridad de los archivos de tu proyecto en una ubicación separada, ya que el proceso de migración modificará los contenidos de tu proyecto actual.
  2. A continuación, crea un archivo en tu directorio de proyecto llamado build.gradle. El archivo build.gradle contendrá toda la información requerida para que Gradle ejecute tu compilación.

    De forma predeterminada, Android Studio espera que tu proyecto se organice como se observa en la figura 1.

    Figura 1: Estructura de proyecto predeterminada para un módulo de app de Android

    Como tu proyecto de IntelliJ no usa la misma estructura, tu archivo build.gradle debe orientar los directorio fuente de la compilación hacia tus carpetas existentes (por ejemplo, res/ y src/) en lugar de la nueva estructura de directorio predeterminada. El siguiente archivo build.gradle de ejemplo incluye la configuración básica para una compilación Gradle, así como un bloque sourceSets{} dentro del bloque android{} para definir los directorios fuente correctos y trasladar las pruebas y los tipos de compilación para evitar conflictos de nombres. Copia el siguiente bloque de código a tu archivo build.gradle y haz los cambios necesarios para trabajar con tu configuración de proyecto existente. Por ejemplo, es posible que debas incluir dependencias adicionales, que uses una versión de SDK de destino diferente o que debas especificar diferentes ubicaciones para tus directorios fuente.
        // 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 3.5.0 version
            * of the Gradle plugin for the buildscript.
            */
            dependencies {
                classpath 'com.android.tools.build:gradle:3.5.0'
            }
        }
    
        /**
         * This line applies the com.android.application plugin. Note that you should
         * only apply the com.android.application plugin. Applying the Java plugin as
         * well will result in a build error.
         */
        apply plugin: 'com.android.application'
    
        /**
         * This dependencies block includes any dependencies for the project itself. The
         * following line includes all the JAR files in the libs directory.
         */
        dependencies {
            compile fileTree(dir: 'libs', include: ['*.jar'])
            // Add 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 {
                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 by the main source set.
                * Adding new build types or product flavors should be accompanied
                * by a similar customization.
                */
                debug.setRoot('build-types/debug')
                release.setRoot('build-types/release')
             }
        }
        
    Para obtener más información sobre la configuración y la personalización de un archivo de compilación de Gradle, consulta Cómo configurar tu compilación.
  3. A continuación, identifica los proyectos de biblioteca que uses. Con Gradle, ya no necesitas agregar estas bibliotecas como proyectos de código fuente; como alternativa, puedes hacer referencia a ellas en el bloque dependencies{} de tu archivo de compilación. De esta manera, el sistema de compilación se encargará de controlar estas bibliotecas; por ejemplo, las descargará y fusionará recursos y entradas de manifiesto. En el siguiente ejemplo, se agregan las instrucciones para los servicios de Google Play y varias bibliotecas de compatibilidad al bloque dependencies{} que se muestra en el ejemplo de archivo de compilación anterior.
        ...
        dependencies {
            compile fileTree(dir: 'libs', include: ['*.jar'])
    
            // Google Play Services
            compile 'com.google.android.gms:play-services:9.8.0'
    
            // Support Libraries
            compile 'com.android.support:appcompat-v7:28.0.0'
            compile 'com.android.support:cardview-v7:28.0.0'
            compile 'com.android.support:design:28.0.0'
            compile 'com.android.support:gridlayout-v7:28.0.0'
            compile 'com.android.support:leanback-v17:28.0.0'
            compile 'com.android.support:mediarouter-v7:28.0.0'
            compile 'com.android.support: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.support:support-v13:28.0.0'
            compile 'com.android.support:support-v4:28.0.0'
    
            // Note: these libraries require the "Google Repository" and "Android Repository"
            //       to be installed via the SDK manager.
        }
        
    Si deseas obtener orientación al determinar las declaraciones correctas para tus bibliotecas, Gradle, please puede proporcionarte las declaraciones correctas basadas en Maven Central.
  4. Guarda tu archivo build.gradle y, luego, cierra el proyecto en IntelliJ. Dirígete a tu directorio de proyectos y quita el directorio .idea y cualquier archivo .iml dentro de tu proyecto.
  5. Inicia Android Studio y haz clic en File > New > Import Project.
  6. Localiza tu directorio de proyectos, haz clic en el archivo build.gradle que creaste antes para seleccionarlo y haz clic en OK para importar tu proyecto.
  7. Para comprobar tu archivo de compilación, haz clic en Build > Make Project crea tu proyecto y resuelve cualquier error que encuentres.

Próximos pasos

Una vez que hayas migrado tu proyecto a Android Studio, consulta Cómo compilar y ejecutar tu app para obtener más información sobre cómo compilar con Gradle y ejecutar tu app en Android Studio.

Según tu proyecto y tu flujo de trabajo, probablemente también desees leer más información sobre cómo usar el control de versiones, gestionar dependencias, firmar y empaquetar tu app, o configurar y actualizar Android Studio. Para comenzar a usar Android Studio, lee Introducción a Android Studio.

Cómo configurar el control de versión

Android Studio admite diferentes sistemas de control de versión, incluidos Git, GitHub, CVS, Mercurial, Subversion y Google Cloud Source Repositories.

Después de importar tu app a Android Studio, usa las opciones del menú del VCS de Android Studio a fin de habilitar la compatibilidad con VCS para el sistema de control de versión deseado, crear un repositorio, importar los archivos nuevos al control de versión y realizar otras operaciones de control de versión:

  1. En el menú del VCS de Android Studio, haz clic en Enable Version Control Integration.
  2. Selecciona un sistema de control de versión para asociarlo con la raíz del proyecto en el menú desplegable y haz clic en OK. En el menú del VCS se mostrarán diversas opciones de control de versión según el sistema que hayas seleccionado.

Nota: También puedes usar la opción del menú File > Settings > Version Control para configurar y modificar los ajustes de control de versión.

Para obtener más información sobre cómo trabajar con el control de versión lee la referencia sobre el control de versión de IntelliJ.

Repositorio de compatibilidad de Android y repositorio de servicios de Google Play

Mientras el complemento ADT para Eclipse usa la biblioteca de compatibilidad de Android y la biblioteca de servicios de Google Play, Android Studio reemplaza estas bibliotecas durante el proceso de importación con el repositorio de compatibilidad de Android y el repositorio de Google para mantener una funcionalidad compatible y admitir nuevas funciones de Android. Android Studio agrega estas dependencias como dependencias Maven mediante el uso de coordenadas Maven conocidas, de modo que esas dependencias no requieran actualizaciones manuales.

En Eclipse, para poder usar una biblioteca de compatibilidad, debes modificar las dependencias de classpath de tu proyecto en tu entorno de desarrollo para cada biblioteca de compatibilidad que quieras usar. En Android Studio, ya no necesitas copiar recursos de biblioteca a tus proyectos; puedes simplemente declarar una dependencia y la biblioteca se descargará y fusionará de manera automática en tu proyecto. Se incluyen la incorporación automática de recursos, las entradas del manifiesto, las reglas de exclusión de ProGuard y las reglas de Lint personalizadas al momento de la compilación. Para obtener más información sobre las dependencias, consulta Cómo configurar variantes de compilación.

Firma de apps

Si tu app usó un certificado de depuración en el complemento ADT para Eclipse, Android Studio continúa haciendo referencia a ese certificado. De lo contrario, la configuración de depuración usa el keystore de depuración generado por Android Studio, con una contraseña conocida y una clave predeterminada con una contraseña conocida ubicada en $HOME/.android/debug.keystore. El tipo de compilación de depuración se configura automáticamente para usar esta configuración de depuración cuando ejecutas o depuras tu proyecto desde Android Studio.

Cuando compilas tu app para el lanzamiento, Android Studio aplica el certificado de lanzamiento usado en el complemento de ADT para Eclipse. Si no se localizó un certificado durante el proceso de importación, agrega la configuración de firma para el lanzamiento al archivo build.gradle o usa la opción del menú Build > Generate Signed APK para abrir el Asistente de generación de APK firmado. Para obtener más información sobre cómo firmar tu app, consulta Cómo firmar tu app.

Cómo ajustar el tamaño máximo de montón de Android Studio

De manera predeterminada, Android Studio tiene un tamaño máximo de montón de 1280 MB. Si trabajas en un proyecto grande o tu sistema tiene mucha memoria RAM, puedes mejorar el rendimiento aumentando el tamaño máximo de montón.

Actualizaciones de software

Android Studio se actualiza por separado del complemento Gradle, las herramientas de compilación y las herramientas del SDK. Puedes especificar las versiones que quieras usar con Android Studio.

De forma predeterminada, Android Studio proporciona actualizaciones automáticas cada vez que se lanza una nueva versión estable, pero puedes optar por actualizar con más frecuencia y también recibir vistas previas o versiones Beta.

Para obtener más información sobre cómo actualizar Android Studio y usar vistas previas y versiones Beta, consulta Cómo mantenerse actualizado.