Search - QuestiEssaywritercsClub


creating an android application in eclipse

Skip to main content
Start reading the article
Jump to list of all articles

Smashing Magazine


Search powered by our good friends at Algolia

Browse All Topics

  • Accessibility
  • Android
  • Animation
  • Apps
  • CSS
  • Design
  • Design Patterns
  • Design Systems
  • E-Commerce
  • Freebies
  • Graphics
  • HTML
  • Illustrator
  • Inspiration
  • iOS
  • JavaScript
  • Mobile
  • Pattern Libraries
  • Performance
  • Photoshop
  • Plugins
  • React
  • Responsive Web Design
  • Service Workers
  • Sketch
  • Typography
  • UI
  • Usability
  • User Experience
  • Wallpapers
  • Web Design
  • WordPress
  • Workflow

About The Author

Chris is a software developer working with Ruby, Rails and Android. In 2010, he founded Plymouth Software where he designs and builds applications for the web …
More about Chris

  • Leave a comment

Get Started Developing For Android With Eclipse

  • 16 min read
  • Coding ,

    Eclipse ,


  • Share on Twitter or  LinkedIn
A postcat. Sign up for our Smashing Newsletter.

Smashing Newsletter

Upgrade your inbox and get our editors’ picks twice a month.

With useful tips for web devs . Sent 2× a month.
You can unsubscribe any time — obviously.

  • Cutting-edge data exploration

  • Earn Your Master’s Degree Online

There’s a lot to get excited about in mobile application development today. With increasingly sophisticated hardware, tablet PCs and a variety of software platforms (Symbian OS, iOS, WebOS, Windows Phone 7…), the landscape for mobile developers is full of opportunities — and a little complex as well.
So much choice can be overwhelming when you just want to get started building mobile applications. Which platform should you choose? What programming language should you learn? What kit do you need for your planned project? In this tutorial, you’ll learn how to start writing applications for Android , the open-source mobile operating system popularized by Google.

There’s a lot to get excited about in mobile application development today. With increasingly sophisticated hardware, tablet PCs and a variety of software platforms (Symbian OS, iOS, WebOS, Windows Phone 7…), the landscape for mobile developers is full of opportunities — and a little complex as well.

So much choice can be overwhelming when you just want to get started building mobile applications. Which platform should you choose? What programming language should you learn? What kit do you need for your planned project? In this tutorial, you’ll learn how to start writing applications for Android , the open-source mobile operating system popularized by Google.

Further Reading on SmashingMag:

  • Getting The Best Out Of Eclipse For Android Development
  • Get Started Developing For Android With Eclipse, Reloaded
  • Mobile Design Practices For Android: Tips And Techniques

Why Develop for Android?

Android is an open-source platform based on the Linux kernel, and is installed on thousands of devices from a wide range of manufacturers. Android exposes your application to all sorts of hardware that you’ll find in modern mobile devices — digital compasses, video cameras, GPS, orientation sensors, and more.

Meet Smashing Book 6  with everything from design systems and accessible single-page apps to CSS Custom Properties, Grid, Service Workers, performance, AR/VR and responsive art direction. New frontiers in front-end and UX with Marcy Sutton, Harry Roberts, Laura Elizabeth and many others .

Android’s free development tools make it possible for you to start writing software at little or no cost. When you’re ready to show off your application to the world, you can publish it to Google’s Android Market. Publishing to Android Market incurs a one-off registration fee (US $25 at the time of writing) and, unlike Apple’s App Store which famously reviews each submission, makes your application available for customers to download and buy after a quick review process — unless the application is blatantly illegal.

Here are a few other advantages Android offers you as a developer:

  • The Android SDK is available for Windows, Mac and Linux, so you don’t need to pay for new hardware to start writing applications.
  • An SDK built on Java. If you’re familiar with the Java programming language, you’re already halfway there.
  • By distributing your application on Android Market, it’s available to hundreds of thousands of users instantly. You’re not just limited to one store, because there are alternatives, too. For instance, you can release your application on your own blog. Amazon have recently been rumoured to be preparing their own Android app store also.
  • As well as the technical SDK documentation , new resources are being published for Android developers as the platform gains popularity among both users and developers.

Enough with the talk — let’s get started developing for Android!

Installing Eclipse and the Android SDK

The recommended environment for developing Android applications is Eclipse with the Android Development Toolkit (ADT) plugin installed. I’ll summarize the process here. If you need more detail, Google’s own developer pages do a good job of explaining the installation and configuration process.

  • Download the Android SDK for your platform (Windows, Mac OS X, or Linux).
  • Extract the downloaded file to somewhere memorable on your hard drive (on Linux, I use /opt/local/).
  • If you don’t already have Eclipse installed, download and install the Eclipse IDE for Java Developers package. For programming, Google recommends using Eclipse 3.5 (Galileo).
  • Run Eclipse and choose Help->Install New Software.
  • Click Add in the Available Software window.
  • Enter Android Development Tools in the Name field, and in the Location field.
  • Click OK and check Developer Tools in the list of available software. This will install the Android Development Tools and DDMS, Android’s debugging tool.

Large image

  • Click Next and Finish to install the plugin. You’ll need to restart Eclipse once everything is installed.
  • When Eclipse restarts, choose Window->Preferences and you should see Android listed in the categories.
  • You now need to tell Eclipse where you’ve installed the Android SDK. Click Android and then Browse to select the location where you extracted the SDK files. For example, /opt/local/android-sdk. Configuring ADT Large view
  • Click OK to have Eclipse save the location of your SDK.

Targeting Android Platforms

Before you can start writing applications for Android, you need to download the SDK platforms for the Android devices for which you want to develop apps. Each platform has a different version of the Android SDK that may be installed on users’ devices. For versions of Android 1.5 and above, there are two platforms available: Android Open Source Project and Google.

The Android Open Source Project platforms are open source, but do not include Google’s proprietary extensions such as Google Maps. If you choose not to use the Google APIs, Google’s mapping functionality won’t be available to your application. Unless you have a specific reason not to, I’d recommended you to target one of the Google platforms, as this will allow you to take advantage of Google’s proprietary extensions.

  • Choose Window->Android SDK and AVD Manager.
  • Click Available Packages in the left column and check the repository to show a list of the available Android platforms.
  • You can choose which platforms to download from the list, or leave everything checked to download all the available platforms. When you’re done, click Install Selected and follow the installation instructions. Large image

Once everything has been successfully downloaded, you’re ready to start developing for Android.

Creating a New Android Project

Eclipse’s New Project Wizard can create a new Android application for you, generating files and code that are ready to run right out of the box. It’s a quick way to see something working, and a good starting point from which to develop your own applications:

  • Choose File->New->Project…
  • Choose Android Project
  • In the New Project dialog, enter the following settings:

    Project Name: BrewClock
    Build Target: Google Inc. 1.6 (Api Level 4)
    Application Name: BrewClock
    Package Name: com.example.brewclock
    Create Activity: BrewClockActivity
    Min SDK Version: 4

After clicking Finish, Eclipse will create a new Android project that’s ready to run. Notice you told Eclipse to generate an Activity called BrewClockActivity? This is the code that Android actually uses to run your application. The generated code will display a simple ‘Hello World’ style message when the application runs.


The package name is an identifier for your application. When the time comes and you are willing to publish on Android Market, it’s exactly this identifier that will be used to track your application for updates, so it’s important to make sure it’s unique. Although we’re using the com.example.brewclock namespace here, for a real application it’s best to choose something like com.yourcompanyname.yourapplication.

SDK Versions

The Min SDK Version is the earliest version of Android on which your application will run. With each new release of Android, the SDK adds and changes methods. By choosing an SDK version, Android (and the Android Market) knows that your application will only run on devices with a version of Android later or equal than the specified version.

Running Your Application

Now let’s try running the application in Eclipse. As this is the first run, Eclipse will ask what type of project you are working on:

  • Choose Run->Run or press Ctrl+F11.
  • Choose Android Application and click OK.

Eclipse will now try to run the application on an Android device. At the moment, though, you don’t have any Android devices running, so the run will fail and you’ll be asked to create a new Android Virtual Device (AVD).

Android Virtual Devices

An Android Virtual Device (AVD) is an emulator that simulates a real-world Android device, such as a mobile phone or Tablet PC. You can use AVDs to test how your application performs on a wide variety of Android devices, without having to buy every gadget on the market.

You can create as many AVDs as you like, each set up with different versions of the Android Platform. For each AVD you create, you can configure various hardware properties such as whether it has a physical keyboard, GPS support, the camera resolution, and so on.

Before you can run your application, you need to create your first AVD running the target SDK platform (Google APIs 1.6).

Let’s do that now:

  • If you haven’t tried to run your application yet, click Run now (or hit Ctrl+F11)
  • When the target device warning pops up, click Yes to create a new AVD.
  • Click New in the Android SDK and AVD Manager dialog that appears.
  • Enter the following settings for the AVD:

    Name: Android_1.6
    Target: Google APIs (Google Inc.) - API Level 4
    SD Card Size: 16 MiB
    Skin Built In: Default (HVGA)
  • Click Create AVD to have Android build your new AVD.

  • Close the Android SDK and AVD Manager dialog.

Running the Code

Try running your application again (Ctrl+F11). Eclipse will now build your project and launch the new AVD. Remember, the AVD emulates a complete Android system, so you’ll even need to sit through the slow boot process just like a real device. For this reason, once the AVD is up and running, it’s best not to close it down until you’ve finished developing for the day.

When the emulator has booted, Eclipse automatically installs and runs your application:

Large image

Building Your First Android Application

Testing generated code is all well and good, but you want to start building a real application. For this, we’ll step through a simple design process and build an application that you can deploy to your Android device.

Most developers (myself included) like a constant supply of good tea or coffee. In the next section of this article you’ll build a simple tea counter application to track how many cups of tea (brews) the user has drunk, and let them set a timer for brewing each cup.

You can download the complete code for this tutorial on GitHub .

Designing the User Interface

One of the first steps to building any Android application is to design and build the user interface. Here’s a quick sketch of how the application’s interface will look:

Large image

The user will be able to set a brew time in minutes using the + and buttons. When they click Start, a countdown will start for the specified number of minutes. Unless the user cancels the brew by tapping the button again, the brew count will be increased when the countdown timer reaches 0.

Building the Interface

Android user interfaces, or layouts, which are described in XML documents, can be found in the res/layouts folder. The template code that Eclipse generated already has a simple layout declared in res/layouts/main.xml which you may have seen previously while the application was running on the emulator.

Eclipse has a graphical layout designer that lets you build the interface by ‘dragging’ and ‘dropping’ controls around the screen. However, I often find it easier to write the interface in XML and use the graphical layout to preview the results.

Let’s do this now by changing main.xml to match the design sketch above:

  • Open res/layouts/main.xml in Eclipse by double-clicking it in the Package Explorer.
  • Click the main.xml tab along the bottom of the screen to switch to XML view.

Now change the content of main.xml to:

# /res/layouts/main.xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:andro android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent"> <LinearLayout android:orientation="horizontal" android:layout_width="fill_parent" android:layout_height="wrap_content" android:padding="10dip"> <TextView android:layout_width="wrap_content" android:layout_height="wrap_content" android:textSize="20dip" android:text="Brews: " /> <TextView android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="None" android:gravity="right" android:textSize="20dip" android: /> </LinearLayout> <LinearLayout android:orientation="horizontal" android:layout_width="fill_parent" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:padding="10dip"> <Button android: android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="-" android:textSize="40dip" /> <TextView android: android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="0:00" android:textSize="40dip" android:padding="10dip" /> <Button android: android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="+" android:textSize="40dip" /> </LinearLayout> <Button android: android:layout_width="fill_parent" android:layout_height="wrap_content" android:layout_gravity="bottom" android:text="Start" />

As you can see, Android’s XML layout files are verbose, but allow you to control virtually every aspect of elements on the screen.

One of the most important interface elements in Android are Layout containers, such as the LinearLayout used in this example. These elements are invisible to the user but act as layout containers for other elements such as Buttons and TextViews.

There are several types of layout views, each of which is used to build different types of layout. As well as the LinearLayout and AbsoluteLayout, the TableLayout allows the use of complex grid-based interfaces. You can find out more about Layouts in the Common Layout Objects section of the API documents.

Linking Your Layout With Code

After saving your layout, try running your application in the emulator again by pressing Ctrl+F11, or clicking the Run icon in Eclipse. Now instead of the ‘Hello World’ message you saw earlier, you’ll see Android now displays your application’s new interface.

If you click any of the buttons, they’ll highlight as expected, but don’t do anything yet. Let’s remedy that by writing some code behind the interface layout:

# /src/com/example/brewclock/
import android.widget.Button;
import android.widget.TextView;
public class BrewClockActivity extends Activity protected Button brewAddTime; protected Button brewDecreaseTime; protected Button startBrew; protected TextView brewCountLabel; protected TextView brewTimeLabel; ... 

Next, we’ll change the call to onCreate. This is the method that gets called whenever Android starts your application. In the code that Eclipse generated, onCreate sets the activity’s view to be R.layout.main. It’s that line of code that tells Android to decode our layout XML document and display it to the user.

The Resource Object

In Android, R is a special object that is automatically generated to allow access to your project’s resources (layouts, strings, menus, icons…) from within the code. Each resource is given an id. In the layout file above, these are the @+id XML attributes. We’ll use those attributes to connect the Buttons and TextViews in our layout to the code:

# /src/com/example/brewclock/
public class BrewClockActivity extends Activity ... public void onCreate(Bundle savedInstanceState) super.onCreate(savedInstanceState); setContentView(R.layout.main); // Connect interface elements to properties brewAddTime = (Button) findViewById(; brewDecreaseTime = (Button) findViewById(; startBrew = (Button) findViewById(; brewCountLabel = (TextView) findViewById(; brewTimeLabel = (TextView) findViewById(; 

Listening For Events

In order to detect when the user taps one of our buttons, we need to implement a listener. You may be familiar with listeners or callbacks from other event-driven platforms, such as Javascript/jQuery events or Rails’ callbacks.

Android provides a similar mechanism by providing Listener interfaces, such as OnClickListener, that define methods to be triggered when an event occurs. Implementing the OnClickListener interface will notify your application when the user taps the screen, and on which button they tapped. You also need to tell each button about the ClickListener so that it knows which listener to notify:

# /src/com/example/brewclock/
// Be sure not to import
// `android.content.dialoginterface.OnClickListener`.
import android.view.View.OnClickListener; 
public class BrewClockActivity extends Activity
  implements OnClickListener ... public void onCreate(Bundle savedInstanceState) ... // Setup ClickListeners brewAddTime.setOnClickListener(this); brewDecreaseTime.setOnClickListener(this); startBrew.setOnClickListener(this); ... public void onClick(View v) // TODO: Add code to handle button taps 

Next we’ll add code that handles each of our button presses. We’ll also add four new properties to the Activity that will let the user set and track the brewing time, how many brews have been made, and whether the timer is currently running.

# /src/com/example/brewclock/
public class BrewClockActivity extends Activity
  implements OnClickListener ... protected int brewTime = 3; protected CountDownTimer brewCountDownTimer; protected int brewCount = 0; protected boolean isBrewing = false; ... public void onClick(View v) if(v == brewAddTime) setBrewTime(brewTime + 1); else if(v == brewDecreaseTime) setBrewTime(brewTime -1); else if(v == startBrew) if(isBrewing) stopBrew(); else startBrew(); 

Notice we’re using the CountDownTimer class provided by Android. This lets you easily create and start a simple countdown, and be notified at regular intervals whilst the countdown is running. You’ll use this in the startBrew method below.

The following methods are all model logic that handles setting the brew time, starting and stopping the brew and maintaining a count of brews made. We’ll also initialize the brewTime and brewCount properties in onCreate.

It would be good practice to move this code to a separate model class, but for simplicity we’ll add the code to our BrewClockActivity:

# /src/com/example/brewclock/
public class BrewClockActivity extends Activity
  implements OnClickListener ... public void onCreate(Bundle savedInstanceState) ... // Set the initial brew values setBrewCount(0); setBrewTime(3); public void setBrewTime(int minutes) if(isBrewing) return; brewTime = minutes; if(brewTime < 1) brewTime = 1; brewTimeLabel.setText(String.valueOf(brewTime) + "m"); public void setBrewCount(int count) brewCount = count; brewCountLabel.setText(String.valueOf(brewCount)); public void startBrew() // Create a new CountDownTimer to track the brew time brewCountDownTimer = new CountDownTimer(brewTime * 60 * 1000, 1000) @Override public void onTick(long millisUntilFinished) brewTimeLabel.setText(String.valueOf(millisUntilFinished / 1000) + "s"); @Override public void onFinish() isBrewing = false; setBrewCount(brewCount + 1); brewTimeLabel.setText("Brew Up!"); startBrew.setText("Start"); ; brewCountDownTimer.start(); startBrew.setText("Stop"); isBrewing = true; public void stopBrew() if(brewCountDownTimer != null) brewCountDownTimer.cancel(); isBrewing = false; startBrew.setText("Start"); ...

The only parts of this code specific to Android are setting the display labels using the setText method. In startBrew, we create and start a CountDownTimer to start counting down every second until a brew is finished. Notice that we define CountDownTimer’s listeners (onTick and onFinish) inline. onTick will be called every 1000 milliseconds (1 second) the timer counts down, whilst onFinish is called when the timer reaches zero.

Avoiding Hard-Coded Text in your Code

To keep this tutorial code simple, I’ve intentionally written label strings directly in the code (e.g. “Brew Up!”, “Start”, “Stop”). Generally, this isn’t good practice, as it makes finding and changing those strings harder in large projects.

Android provides a neat way to keep your text strings separate from code with the R object. R lets you define all your application’s strings in an xml file (res/values/strings.xml) which you can then access in code by reference. For example:

# /res/values/strings.xml
<string name="brew_up_label">Brew Up!</string>
# /res/com/example/brewclock/

Now if you wanted to change Brew Up! to something else, you would only need to change it once in the strings.xml file. Your application starts to span dozens of code files which keeps all your strings in one place and makes a lot of sense!

Trying BrewClock

With the code complete, it’s time to try out the application. Hit Run or Ctrl+F11 to start BrewClock in the emulator. All being well, you’ll see the interface set up and ready to time your tea brewing! Try setting different brew times, and pressing Start to watch the countdown.

Large image


In this short introduction to Android, you’ve installed the Android SDK and Eclipse Android Development Tools (ADT) plugin. You’ve set up an emulator, or virtual device that can test your applications. You’ve also built a working Android application which has highlighted a number of key concepts that you’ll use when developing your own Android applications.

Hopefully, this has whet your appetite for building mobile applications, and experimenting in this exciting field. Android offers a great way to start writing applications for a range of current and upcoming mobile devices. If you’ve built or are working on your own mobile app, be sure to let us know about it in the comments!

(ik), (vf)



Autodesk: Make Anything

How to Setup Eclipse for Android App Development

By icmonroe

in Technology Software




Introduction: How to Setup Eclipse for Android App Development

By icmonroe

Developing Android applications can be a fun and exciting experience. To get started creating Android applications, you need a proper development environment. This will allow you to use all the tools needed to create an app and ensure you work efficiently. I will show you how to setup a working environment using the Android SDK, Eclipse IDE, and ADT Plugin.

This Instructable assumes you have knowledge of what Android is and have a basic understanding of programming, although programming is not required.

First I will explain how to get and setup the Android SDK provided by Google. Then I will address the use of the Eclipse IDE for development. Finally, I will focus on the ADT (Android Development Tool) Plugin that integrates the Android SDK with Eclipse.

Approximate time required: 20 mins.

Requirements: Computer with 300 mb of free space.

Step 1: Obtain the Android SDK

  • We need to obtain the Android Software Development Kit. To do that we must first visit the SDK download site below.
  • Scroll to the bottom of the webpage and select the ‘Download the SDK Tools’ button.
  • This will open a file to be saved somewhere.

Step 2: Install the Android SDK

  • Open the file we just downloaded.
  • This will open an executable which will ask you about the installation process.
  • When you get to the install location screen, make sure you choose a location you remember (we will need it later).

Step 3: Open Android SDK Manager

We’ll select the most recent version along with the extra SDK tools so you can build applications for any Android version.

  • Open the folder that we installed the SDK into.
  • You’ll see a executable called ‘SDK Manager’. Open it.
  • You’ll see a window where you can select different versions of Android to develop for.

Step 4: Install Android Version and Extras for SDK

  • Select the ‘Tools’ and ‘Android 4.4.2 (API 19)’ check boxes.
  • If you would like to have extra Android tools you can choose them from the ‘Extras’ selection.
  • You will then be prompted to accept the Android conditions and then the SDK will install. Then installation may take a while depending on your internet connection. The Android SDK is now completely installed.

Step 5: Obtain Eclipse IDE

Eclipse is the tool we’ll be using to develop in. It is the most popular Android development environment and has officially supported tools from Google.

  • Download Eclipse from the website below.
  • Find the link for your operating system and 32/64 bit version.
  • Save the compressed download file.

Step 6: Run Eclipse for First Time

Eclipse does not require installation. It’s a folder with all the necessary files and settings. You can run it directly from the Eclipse folder. It’s recommended you put it in a safe place with other applications.

  • Extract the downloaded Eclipse file into a safe place where you can keep the program.
  • Open the extracted folder and open the ‘eclipse’ executable.

You should see a screen similar to the one attached if all went well.

Step 7: Add ADT Plugin Repository

The ADT (Android Development Tool) Plugin was made specifically for Eclipse to increase productivity and integration with your Android work environment. To use it, we first add the Eclipse plugin repository so it knows where to find it along with updates.

  • In the Eclipse application menu, go to ‘Help’ and then ‘Install New Software’.
  • Click on the ‘Add…’ button and you’ll see a window appear.
  • Give the repository a name like ‘ADT Repo’.
  • Give it the location
  • Click ‘OK’ button.

Step 8: Install ADT Plugin

Now that we have the plugin repo setup we need to install the plugin from it.

  • On the ‘Install Software’ screen, select the repo you just created from the ‘Work with’ selector.
  • Select the ‘Developer Tools’ option from the listed below options.
  • Click ‘Next’ and accept the agreements.
  • Click ‘Finish’ and let it install. It might take a while depending on your internet speed.

Step 9: Access ADT Plugin Preferences

You’ll most likely have to restart Eclipse after you install the ADT Plugin so do that before you continue.

  • Mac/Linux: After Eclipse has restarted, click ‘Eclipse’ in the application menu.
  • Windows: After Eclipse has restarted, click ‘Window’ in the application menu.
  • Then select ‘Preferences’.
  • In the Preferences window, select the Android tab on the left side and it’s corresponding drop down menu.

This is the ADT Preferences screen. It will allow you to change setting, remove the SDK and make editor preferences for your development.

Step 10: Setup ADT Plugin

  • Click ‘Browse’ on the right side of the screen.
  • Search for the folder in which you installed the Android SDK into and select it.
  • Hit the ‘Apply’ button on the Preferences screen.
  • You should see the Android version you installed early to show up if all went well.
  • If not, try reselecting the folder. (Make sure the folder contains the folders ‘build-tools’,’platform’,’extras’ and etc.
  • Hit the ‘OK’ button and restart Eclipse.

Step 11: Access ADT Android Virtual Device Manager

To test your application we need to add an Android Virtual Device if you don’t have a personal device.

In the application menu, select ‘Window’ and then ‘Android Virtual Device Manager’

Here you can create new ‘Devices’.

Step 12: Add ADT Virtual Device

  • Click the ‘New…’ button on the right side.
  • Give your device a name in ‘AVD Name’.
  • You want to check mark ‘Use Host GPU’
  • The other options are up to you and can be played with to figure out what works best.
  • When done, hit ‘OK’.

Step 13: Conclusion

You have now setup an environment ready to develop Android applications. We installed the Android SDK, Eclipse, and the ADT Plugin.

To create your first application, visit…


    Did you make this project? Share it with us!


    • All in One Arcade System

      All in One Arcade System

    • Make a 2 Sided, Desktop Infinity Mirror

      Make a 2 Sided, Desktop Infinity Mirror

    • IoT Split-flap Weather Forecast Powered by XOD

      IoT Split-flap Weather Forecast Powered by XOD

    • 3D CAM and CNC Class
      3D CAM and CNC Class

      3D CAM and CNC Class

    • Tiny Home Contest

      Tiny Home Contest

    • Water Contest

      Water Contest

    • Creative Misuse Contest

      Creative Misuse Contest

    49 Discussions

    Link not working .


    i am going well with all, please let me know which eclipse we have to use?

    Eclipse for Java IDE or any other? and how to download a plugin and install in Eclipse ?

    Thanks for the great tutorial I made it

    Pls someone should please help me, as i am stuck at step 10. My OK button is always inactive irrespective of the selected folder.

    The link you have provided for the download of Android SDK redirects
    to android studio download page
    . So here is the direct link to download
    the Android SDK installer for windows and its working perfectly fine:

    when i install the adt plug in it says “Cannot complete the install because of a conflicting dependency.

    Software being installed: Android Development Tools (”


    Simple and very helpful. Than you..

    Only problem it is is no where near 300MB. Closer to 3GB, and I only installed the packages for the current Android version.



    Update: 3GB without even having all of the necessary packages. I only went with this tutorial because of it’s claim to only need 300MB (I have very limited storage space). Yet, the overall size is over 5GB. I simply don’t have that space on my computer.

    Thanks, nice very helpful. 🙂

    Its very helpful, no doubt

    Thanks for sharing Nice post and very helpfull

    Thanks for sharing Nice post and very helpfull

    This is very
    informative post and i am waiting for this kinds of post. Thanks for providing such important information about an android app developers which is very useful for me. Thanks for providing such a good information.

    Hi, Just follow the steps in given link to setup eclipse.

    hi, i followed all the steps but this seems to be popping up :/




    Maybe you have to check your system, x86 or x64 then change your eclipse.

    That’s help me out sir 🙂

    I followed every step twice. The first time I followed the steps and got an error.

    [2016-03-01 15:28:42 – SDK Manager] Error: Error reading default devices

    [2016-03-01 15:28:43 – SDK Manager] Error: null

    [2016-03-01 15:28:43 – SDK Manager] Error: null

    [2016-03-01 15:28:43 – SDK Manager] Error: null

    I read through some of the comments and tried to uninstall everything and install it again. Now im getting the same error message. Please help.

    HEEELLLP :'(

    I cant install the developer tools
    ‘An error occurred while collecting items to be installed’