Building and running from android studio

Building and Running from Android Studio

In this document

See also

This document shows you how to use Android Studio to build an application .apk for testing or release and how to run your application on an emulator or a real device.

Build your Project in Android Studio

To build the project on Android Studio, click Build and select Make Project. The status bar at the bottom of the window shows the current progress of the build:

Gradle: Executing tasks: [:app:assembleDebug, :lib:bundleDebug]

Click on the bottom right part of the window to show the Gradle Console, as shown in figure 1.

Figure 1. The Gradle Console in Android Studio.

The Gradle Console shows the build tasks and subtasks that the build system runs for Android Studio. If the build fails, you can find more details on the console. To hide the Gradle Console, click again.

If your project uses product flavors, Android Studio invokes the task for the selected build variant. For more information, see the Build System guide.

To view the list of all available build tasks in Android Studio, click Gradle on the right side of the IDE window. The Gradle tasks panel appears.

Build a release version

You can now use the Build menu options to build the release version of your application for distribution.

The build generates an APK for each build variant: the app/build/apk/ directory contains packages named app- — .apk ; for example, app-full-release.apk and app-demo-debug.apk .

For more build system information, see Build System.

Running your app

This section shows you how to run your application on an emulator or a real device from Android Studio—all of which is done using the debug version of your application. For more information about how to sign your application with a private key for release, see Signing Your Applications

Creating a Run Configuration

The run configuration specifies the module to run, package to deploy, Activity to start, target device, emulator settings, and Logcat options. Run configuration can be set at the project, default, and module levels. When you first run a module as an Android Application, Android Studio will automatically create a run configuration. The default run configuration will launch the default project Activity and use automatic target mode for device selection (with no preferred AVD). If the default settings don’t suit your project or module, you can customize the run configuration or even create a new one.

To create or modify a run configuration, see the IntelliJ documentation on Run/Debug configurations.

The following steps highlight the important things you need to do for an Android project:

  1. Open Edit Configurations from the Run Menu.
  2. Expand the Android Application item and create a new configuration or open an existing one.
  3. With the Run Configuration selected, adjust your desired run configuration settings:
    • In the General tab, specify the Module settings to launch. In Target tab, consider whether you’d like to use Manual or Automatic mode when selecting an AVD to run your application. See the following section on Automatic and manual target modes).
    • In the Emulator tab, specify any emulator options to the Additional Emulator Command Line Options field. For example, you could add -scale 96dpi to scale the AVD’s screen to an accurate size, based on the dpi of your computer monitor. For a full list of emulator options, see the Android Emulator document.
  • In the Logcat tab, set the LogCat options for the application.
  • Automatic and manual target modes

    By default, a run configuration uses the automatic target mode in order to select an AVD. In this mode, Android Studio will select an AVD for the application in the following manner:

    1. If there’s a device or emulator already running and its AVD configuration meets the requirements of the application’s build target, the application is installed and run upon it.
    2. If there’s more than one device or emulator running, each of which meets the requirements of the build target, a device chooser is shown to let you select which device to use.
    3. If there are no devices or emulators running that meet the requirements of the build target, Android Studio looks at the available AVDs. If there is an AVD that matches the build target of the project, Android Studio chooses that AVD. If the AVD versions are newer than the build target of the project, Android Studio chooses the oldest possible version of an AVD that meets the project or module build target requirement.
    4. If there are no suitable AVDs, the application is not installed and a console error warning tells you that there is no existing AVD that meets the build target requirements.
    Читайте также:  Диагностика дэу нексия для андроид

    However, if a «preferred» AVD is selected in the run configuration, then the application will always be deployed to that AVD. If it’s not already running, then a new emulator will be launched.

    If your run configuration uses manual mode, then the «device chooser» is presented every time that your application is run, so that you can select which AVD to use.

    Running on the emulator

    Before you can run your application on the Android Emulator, you verify the default AVD or create an AVD.

    To run (or debug) your application, select Run > Run (or Run > debug) from the Android Studio menu bar. Android Studio automatically creates a default run configuration for the project. Android Studio will then perform the following:

    1. Compile the project (if there have been changes since the last build).
    2. Create a default run configuration (if one does not already exist for the project).
    3. Install and start the application on an emulator (or device), based on the Deployment Target defined by the run configuration.

    By default, Android run configurations use an «automatic target» mode for selecting a device target. For information on how automatic target mode selects a deployment target, see Automatic and manual target modes above.

    If you run the application with Debug, the Choose a Device option appears so you can select an attached device or emulator. Once the device or emulator is selected, Android Studio opens the Debug console and starts the application’s main activity. Otherwise, if you run the application with the normal Run command, Android Studio installs the application on the device and launches the main activity.

    To set or change the run configuration used for your project or module, select Run > Edit Configurations. See the section below about Creating a Run Configuration for more information.

    Be certain to create multiple AVDs upon which to test your application. You should have one AVD for each platform and screen type with which your application is compatible. For instance, if your application compiles against the Android 4.0 (API Level 14) platform, you should create an AVD for each platform equal to and greater than 4.0 and an AVD for each screen type you support, then test your application on each one.

    Running on a device

    Before you can run your application on a device, you must perform some basic setup for your device:

    Note: On Android 4.2 and newer, Developer options is hidden by default. To make it available, go to Settings > About phone and tap Build number seven times. Return to the previous screen to find Developer options.

  • Ensure that your development computer can detect your device when connected via USB
  • Read Using Hardware Devices for more information.

    Once set up and your device is connected via USB, install your application on the device by selecting Run > Run (or Run > Debug) from the Android Studio menu bar.

    Источник

    Managing Projects from Android Studio

    In this document

    Android Studio provides graphical tools for creating and managing Android projects, which contain everything that define your Android apps, from app source code to build configurations and test code. Each project contains one or more different types of modules, such as application modules, library modules, and test modules.

    This guide explains how to create Android projects and different modules using Android Studio. For more information about the Android project structure and module types, read Managing Projects Overview.

    Creating an Android Project

    Android Studio makes it easy to create Android apps for several form factors, such as phone, tablet, TV, Wear, and Google Glass. The New Project wizard lets you choose the form factors for your app and populates the project structure with everything you need to get started.

    Follow the steps in this section to create a project in Android Studio.

    Step 1: Create a New Project

    If you didn’t have a project opened, Android Studio shows the Welcome screen. To create a new project, click New Project.

    If you had a project opened, Android Studio shows the development environment. To create a new project, click File > New Project.

    The next window lets you configure the name of your app, the package name, and the location of your project.

    Figure 1. Choose a name for your project.

    Enter the values for your project then click Next.

    Step 2: Select Form Factors and API Level

    The next window lets you select the form factors supported by your app, such as phone, tablet, TV, Wear, and Google Glass. The selected form factors become the application modules within the project. For each form factor, you can also select the API Level for that app. To get more information, click Help me choose.

    Figure 2. Select the API Level.

    The API Level window shows the distribution of mobile devices running each version of Android, as shown in figure 3. Click on an API level to see a list of features introduced in the corresponding version of Android. This helps you choose the minimum API Level that has all the features that your apps needs, so you can reach as many devices as possible. Then click OK.

    Figure 3. Choose form factors for your app.

    Then, on the Form Factors Window, click Next.

    Step 3: Add an Activity

    The next screen lets you select an activity type to add to your app, as shown in figure 4. This screen displays a different set of activities for each of the form factors you selected earlier.

    Figure 4. Add an activity to your app.

    Choose an activity type then click Next.

    Note: If you choose «Add No Activity», click Finish to create the project.

    Step 4: Configure Your Activity

    The next screen lets you configure the activity to add to your app, as shown in figure 5.

    Figure 5. Choose a name for your activity.

    Enter the activity name, the layout name, and the activity title. Then click Finish.

    Step 5: Develop Your App

    Android Studio creates the default structure for your project and opens the development environment. If your app supports more than one form factor, Android Studio creates a module folder with complete source files for each of them as shown in figure 6.

    Figure 6. The default project structure for a mobile app.

    Now you are ready to develop your app. For more information, see the following links:

    Creating an Android Module

    Android application modules contain the src/main/ , AndroidManifest.xml , build.gradle , build output and other files you need to generate your app’s APK files. Android Studio provides a New Module Wizard that you can use to quickly create a new Android module (or a module from existing code) based on selected application settings, such as minimum SDK level and activity template.

    To create a new module, select File > New > Module. Select the desire module type then click Next to enter the basic module settings:

    • Enter an Application Name. This name is used as the title of your application launcher icon when it is installed on a device.
    • Enter a Module Name. This text is used as the name of the folder where your Java-based activity files are stored.
    • Enter a Package Name and Package Location. This class package namespace creates the initial package structure for your applications code files and is added as the package attribute in your application’s Android manifest file. This manifest value serves as the unique identifier for your application app when you distribute it to users. The package name must follow the same rules as packages in the Java programming language.
    • Select the Minimum required SDK. This setting indicates the lowest version of the Android platform that your application supports for the selected form factor. This value sets the minSdkVersion attribute in the build.gradle file.

    Note: You can manually change the minimum and target SDK for your module at any time: Double-click the module’s build.gradle in the Project Explorer, set the targetSdkVersion and targetSdkVersion in the defaultConfig section.

  • Select a Target SDK. This setting indicates the highest version of Android with which you have tested with your application and sets the targetSdkVersion attribute in your application’s’ build.gradle file.
  • Select a Compile With API version. This setting specifies what version of the SDK to compile your project against. We strongly recommend using the most recent version of the API.
  • Select a Language Level API version. This setting specifies what version of the SDK to compile your project against. We strongly recommend using the most recent version of the API.
  • Select a Theme. This setting specifies which standard Android visual style is applied to your application. Select activity template. For more information about Android code templates, see Using Code TemplatesLeave the Create activity option checked so you can start your application with some essential components.
  • Click the check box for the required Support Libraries then click Next.
  • In the Configure Launcher Icon page, create an icon and options, then click Next.
  • In the Create Activity page, select activity template then click Next. For more information about Android code templates, see Using Code Templates.
  • Review the new module settings then click Finish.
  • The wizard creates a new Android application module according to the options you have chosen.

    Setting up a Library Module

    A library module is a standard Android module, so you can create a new one in the same way as you would a new application module, using the New Module wizard and selecting Android Library as the module type. The created library module will appear in your project view along with the other modules.

    You can easily change an existing application module to a library module by changing the plugin assignment in the build.gradle file to com.android.library.

    Adding a dependency on a library module

    The library dependency can be declared in the module’s manifest file or in the GameActivity :

    To add the dependency declaration to the build file, edit the build file for the app module ( app/build.gradle ) and add a dependency on the lib module:

    In this example, the lib module can still be built and tested independently, and the build system creates an AAR package for it that you could reuse in other projects.

    Note: The library settings in the app/build.gradle file will override any shared library resources declared in the manifest file.

    Referencing a library module

    If you are developing an application and want to include the shared code or resources from a library module, you can also do so easily by adding a reference to the library module in the module’s dependency page.

    To add a reference to a library module, follow these steps:

    1. Make sure that both the module library and the application module that depends on it are in your project. If one of the modules is missing, import it into your project.
    2. In the project view, right-click the dependent module and select Open >Module Settings.
    3. Right-click the plus icon to add a new dependencies.

    If you are adding references to multiple libraries, you can set their relative priority (and merge order) by selecting a library and using the Up and Down controls. The tools merge the referenced libraries with your application starting from lowest priority (bottom of the list) to highest (top of the list). If more than one library defines the same resource ID, the tools select the resource from the library with higher priority. The application itself has highest priority and its resources are always used in preference to identical resource IDs defined in libraries.

  • Use the Scope drop-down to select how the dependency will be applied.
  • Click Apply to create the dependency and OK to close the Project Structure window.
  • Android Studio rebuilds the module, including the contents of the library module the next time the project or module is built.

    Declaring library components in the manifest file

    In the manifest file of the application module, you must add declarations of all components that the application will use that are imported from a library module. For example, you must declare any , , ,

    , and so on, as well as

    , , and similar elements.

    Declarations should reference the library components by their fully-qualified package names, where appropriate.

    For example, the TicTacToeMain example application declares the library activity GameActivity like this:

    For more information about the manifest file, see the documentation for AndroidManifest.xml.

    Using the Android Project View

    The Android project view in Android Studio shows a flattened version of your project’s structure that provides quick access to the key source files of Android projects and helps you work with the new Gradle-based build system. The Android project view:

    • Groups the build files for all modules at the top level of the project hierarchy.
    • Shows the most important source directories at the top level of the module hierarchy.
    • Groups all the manifest files for each module.
    • Shows resource files from all Gradle source sets.
    • Groups resource files for different locales, orientations, and screen types in a single group per resource type.

    Use the Android Project View

    The Android project view is enabled by default and shows all the build files at the top level of the project hierarchy under Gradle Scripts. The project module appears as a folder at the top level of the project hierarchy and contains these three elements at the top level:

    • manifests/ — Manifest files for the module.
    • java/ — Source files for the module.
    • res/ — Resource files for the module.

    Notice how the Android project view groups all instances of the ic_launcher.png resource for different screen densities under the same element.

    Note: The Android project view shows a hierarchy that helps you work with Android projects by providing a flattened structure that highlights the most commonly used files while developing Android applications. However, the project structure on disk differs from this representation and maintains the traditional project structure.

    Figure 10: Android and Traditional project view

    Источник

    Читайте также:  Реклама гугле отключить андроид
    Оцените статью