page.title=Developer Workflow
@jd:body

<p>To develop apps for Android, you use a set of tools that are included in Android Studio.
In addition to using the tools from Android Studio,
you can also access most of the SDK tools from the command line. Developing with Android Studio is the
preferred method because it can directly invoke the tools that you need while developing applications.</p>

<p>However, you may choose to develop with another IDE or a simple text editor and invoke the
tools on the command line or with scripts. This is a less streamlined way to develop because you
will sometimes have to call command line tools manually, but you will have access to the same
number of features that you would have in Android Studio.</p>

<div class="figure" style="width:461px">
  <img src="{@docRoot}images/developing/developing_overview.png"
       alt="Development process for Android applications"
       height="738" />
  <p class="img-caption">
    <strong>Figure 1.</strong> The development process for Android applications.
  </p>
</div>

<h2>App Workflow</h2>

<p>The basic steps for developing applications (with or without Android Studio) are shown in 
figure 1. The development steps encompass four development phases, which include:</p>

<ul>
  <li><strong>Environment Setup</strong>
    <p>During this phase you install and set up your development environment. You also create
      Android Virtual Devices (AVDs) and connect hardware devices on which you can install your
      applications.</p>
    <p>See <a href="{@docRoot}tools/devices/index.html">Managing Virtual Devices</a>
      and <a href="{@docRoot}tools/device.html">Using Hardware Devices</a> for more
      information.
  </li>
  <li><strong>Project Setup and Development</strong>
    <p>During this phase you set up and develop your Android Studio project and application modules,
    which contain all of the source code and resource files for your application. For more
    information, see
    <a href="{@docRoot}tools/projects/index.html">Create an Android project</a>.</p>
  </li>
  <li><strong>Building, Debugging and Testing</strong>
    <p>During this phase you build your project into a debuggable <code>.apk</code> package(s) 
    that you can install and run on the emulator or an Android-powered device. Android Studio uses 
    a build system based on <a href="http://www.gradle.org/" target="_android">Gradle</a> 
    that provides flexibility, customized build variants, dependency resolution, and much more. 
    If you're using another IDE, you can build your project using Gradle and install it on a device 
    using <a href="{@docRoot}tools/help/adb.html">adb</a>. For more information, see
    <a href="{@docRoot}tools/building/index.html">Build and run your application</a>.</p>
    <p>Next, with Android Studio you debug your application using the
    <a href="{@docRoot}tools/help/monitor.html">Android Debug Monitor</a> and device log messages
    (<a href="{@docRoot}tools/help/logcat.html">logact</a>) along with the IntelliJ IDEA intelligent
    coding features. You can also use a JDWP-compliant debugger along with the debugging and logging
    tools that are provided with the Android SDK. For more information see
    <a href="{@docRoot}tools/debugging/index.html">Debug your application with the SDK debugging and logging tools</a>.</p>
    <p>Last, you test your application using various Android SDK testing tools. For more
    information, see <a href="{@docRoot}tools/testing/index.html">Test your application
    with the Testing and Instrumentation framework</a>.</p>
  </li>
  <li><strong>Publishing</strong>
    <p>During this phase you configure and build your application for release and distribute your
    application to users. For more information, see
    <a href="{@docRoot}tools/publishing/publishing_overview.html">Publishing
    Overview</a>.</p>
  </li>
</ul>



<h2 id="EssentialTools">Essential command line tools</h2>

  <p>When developing in IDEs or editors other than Android Studio, be familiar with
  all of the tools below, because you will have to run them from the command line or script.</p>

  <dl>
    <dt><a href="{@docRoot}tools/help/android.html">android</a></dt>

    <dd>Create and update Android projects and create, move, and delete AVDs.</dd>

    <dt><a href="{@docRoot}tools/help/emulator.html">Android Emulator</a></dt>

    <dd>Run your Android applications on an emulated Android platform.</dd>

    <dt><a href="{@docRoot}tools/help/adb.html">Android Debug Bridge</a></dt>

    <dd>Interface with your emulator or connected device (install apps, shell the device, issue
    commands, etc.).</dd>
  </dl>

  <p>In addition to the above tools that are included with the SDK, you need the following open
  source and third-party tools:</p>

  <dl>
    <dt><a href="http://www.gradle.org/">Gradle</a> </dt>

    <dd>To compile and build your Android project into an installable .apk file(s).</dd>

    <dt>Keytool</dt>

    <dd>To generate a keystore and private key, used to sign your .apk file. Keytool is part of the
    JDK.</dd>

    <dt>Jarsigner (or similar signing tool)</dt>

    <dd>To sign your .apk file with a private key generated by Keytool. Jarsigner is part of the
    JDK.</dd>
  </dl>

  <p>If you are using Android Studio, tools such as <code>adb</code> and <code>android</code>
  are automatically called by Android Studio so you don't have to manually invoke these tools.
  You need to be familiar with <code>adb</code>, however, because certain functions are not
  accessible from Android Studio, such as the <code>adb</code> shell commands. You might also
  need to call Keytool and Jarsigner to sign your applications, but you can set up Android Studio 
  to do this automatically as well.</p>

<p>For more information on the tools provided with the Android SDK, see the
  <a href="{@docRoot}tools/help/index.html">Tools</a> section of the documentation.</p>



