page.title=Developer Tools
@jd:body

    
<img src="{@docRoot}images/tools-home.png" style="float:right;" height="415" width="763" />

<div style="position:relative;height:0">
<div style="position:absolute;width:420px"> 
  <p>The Android Developer Tools (ADT) plugin for Eclipse provides
    a professional-grade development environment for building
  Android apps. It's a full Java IDE with advanced features to help you build, test, debug,
  and package your Android apps. </p>
  <p>Free, open-source, and runs on most major OS platforms.<br>To get started, 
  <a href="{@docRoot}sdk/index.html">download the Android SDK.</a></p>
</div>
</div>

<div style="margin-top:20px;"></div>

<div class="col-7" style="margin-left:0">
<h3>Full Java IDE</h3>

  <ul>
    <li>Android-specific refactoring, quick fixes, integrated navigation between Java and XML resources.</li> 
    <li>Enhanced XML editors for Android XML resources.</li> 
    <li>Static analysis tools to catch performance, usability, and correctness problems.</li> 
    <li>Build support for complex projects, command-line support for CI through Ant. Includes ProGuard and app-signing. </li> 
    <li>Template-based wizard to create standard Android projects and components.</li> 
  </ul>
</div>


<div class="col-6" style="margin-right:0">

<h3>Graphical UI Builders</h3>
  <ul>
    <li>Build rich Android UI with drag and drop. 
    <li>Visualize your UI on tablets, phones, and other devices. Switch themes, locales, even platform versions instantly, without building.</li>
    <li>Visual refactoring lets you extracts layout for inclusion, convert layouts, extract styles.</li>
    <li>Editor support for working with custom UI components.</li>
  </ul>

</div>


<div class="col-7" style="clear:both;margin-left:0;">

<h3>On-device Developer Options</h3>
<ul>
  <li>Enable debugging over USB.</li>
  <li>Quickly capture bug reports onto the device.</li>
  <li>Show CPU usage on screen.</li>
  <li>Draw debugging information on screen such as layout bounds,
    updates on GPU views and hardware layers, and other information.</li>
  <li>Plus many more options to simulate app stresses or enable debugging options.</li>
</ul>
<p>To access these settings, open the <em>Developer options</em> in the
system Settings. On Android 4.2 and higher, the Developer options screen is
hidden by default. To make it available, go to
<b>Settings > About phone</b> and tap <b>Build number</b> seven times. Return to the previous
screen to find Developer options.</p>

</div>

<div class="col-6" style="margin-right:0">
  <img src="{@docRoot}images/tools/dev-options-inmilk.png" alt="" style="margin:-10px 0 0;">
</div>


<div class="col-7" style="clear:both;margin-left:0;">
<h3>Develop on Hardware Devices</h3>

  <ul>
    <li>Use any commercial Android hardware device or multiple devices.</li> 
    <li>Deploy your app to connected devices directy from the IDE.</li> 
    <li>Live, on-device debugging, testing, and profiling.</li> 
  </ul>
</div>

<div class="col-6" style="margin-right:0">
<h3>Develop on Virtual Devices</h3>
  <ul>
    <li>Emulate any device. Use custom screen sizes, keyboards, and other hardware components. </li>
    <li>Advanced hardware emulation, including camera, sensors, multitouch, telephony.</li>
    <li>Develop and test for broad device compatibility.</li>
  </ul>

</div>

<div style="margin-top:20px;"></div>

<div class="col-7" style="margin-left:0">
<h3>Powerful Debugging</h3>

  <ul>
    <li>Full Java debugger with on-device debugging and Android-specific tools.</li>
    <li>Built-in memory analysis, performance/CPU profiling, OpenGL ES tracing.</li>
    <li>Graphical tools for debugging and optimizing UI, runtime inspecton of UI structure and performance.</li>
    <li>Runtime graphical analysis of your app's network bandwidth usage.</li>
  </ul>

<h3>Testing</h3>
    
  <ul>
    <li>Fully instrumentated, scriptable test environment.</li>
    <li>Integrated reports using standard test UI.</li>
    <li>Create and run unit tests on hardware devices or emulator.</li>
  </ul>

<h3>Native Development</h3>
    
  <ul>
    <li>Support for compiling and packaging existing code written in C or C++.</li>
    <li>Support for packaging multiple architectures in a single binary, for broad compatibility.</li>
  </ul>
</div>

<div class="col-6" style="margin-right:0">
  <img src="{@docRoot}images/debugging-tall.png" align="left" style="margin-top:10px">
</div>


