# data[].attributes.attachment_link.description
Introduction Build Drawing and Animated Games Build Texting and Location-Aware Apps Build Quizzes and Informational Apps Define Procedures to Create New Blocks Build Apps with User-Generated Data Build Web-Enabled Apps

# data[].attributes.attachment_link.readable_text
Today we are going to make a game from scratch inspired by recently popular spike games. We will call it Oh My Spikes. Before we start, you may want to see how the final game will look like. This will help you follow the tutorial easily. Sorry for the noise and the quality of the video.

I am assuming you have some experience using App Inventor. If not, you should definitely do the very basic tutorial.

This is what we want to achieve-

1. You control a bird by tapping anywhere in the screen. When you tap, bird ascends; if you don't, bird starts to descend/fall.

2. Your objective is to lead the bird to left or right without bumping on any spikes. If you successfully take the bird to the left or to the right edge, you make a score. When that happens, bird goes to opposite direction. This continues until you hit a spike. Let's first design the interface. Download the barebone project that already has the UI layout but no blocks. Import it and take a look at the different components in place. You can change the look and feel however you want later. This is how mine looks like-

We have the following components in Screen1:

3. Another image sprite named PlaySprite to represent our play/retry button.

6. A Label component named ScoreLabel to display the score.

DB_SCORE_TAG : For saving and reading best score.

state - This holds the current state, either of the three states above.

isFalling - When player is not tapping, the bird starts to descend.

score - Current score in the game.

bestScore - Best score of the player.

headingLeft - Bird's direction on x-axis, either left or right.

temp - To use within a smaller scope. You can use local variables if you prefer.

isOnLeft - If the obstacles/spikes are currently at the left side on the canvas.

SPIKES_Y_POS - This variable holds a list of lists. We have 4 image sprites (obstacle spikes) that are placed on either side depending on the direction of the bird. If we want to place the spikes at left, we can use 0 as the x, if we want to the right, we can use canvas' width minus spike's width for x. Since our obstacles' x position is either to the left or to the right, all we need are values on y-axis. We created 10 locations for those sprites by placing them in various positions in design view with proper gaps in between, we then checked in the device if they look good enough. Then we copied Y values from design view to SPIKES_Y_POS variable. Since we have 4 obstacle sprites, we chose 4 values on y-axis, one for each sprite. This is why each list contains 4 items. First one is for Sprite 1, 2nd one is for Sprite 2, and so on. You can try and add more or even randomize. Rather than having a list of lists predefined, you can create an empty list and then later add items to that list instead. If you are wondering why some of them have -100, it's because we don't always want to show all 4 obstacle sprites. So we placed them off the screen. You can use -30 as each spike is 30 pixels in height. I chose -100 because for some reason it was more visible to my eyes to spot on Blocks window when I was testing. If you have never worked on lists, now is the time you go through the in-depth list tutorial.

Let's break these down. Screen gets initialized when the app is loaded and we to do the followings when it does-

1. We want our score label to be visible. So we set its visibility to true. You can do that in design view too.

2. When we first show the app, we do not show the bird. So it should not be enabled either. You can also do that in design view. I might have already done that in design view; but I don't like going back and forth to check, so redid it.

3. We do not want our clocks to do anything yet so we disabled them which you can also do in design view.

4. We want our canvas height to be the same as the device height minus the score label's height which is 30. We show the best score on the menu screen or how to play the game if the player haven't played our game yet.

5. We read the best score form TinyDB using the tag we defined before. If no best score, we get an empty text because we put nothing on the block " valueIfTagNotThere ". Obviously tag won't be there if we haven't saved any score yet.

6. If we find a best score, we show it. If not, we inform the player how to play this game. You can create a screen with detailed instructions if you prefer and show that instead.

7. Finally we call three procedures. SetupHeader procedure sets the location of the header in center in respect to x-axis and a little below from the top of the screen by using its height. If you are not sure about this simple math formula on getting the center of two points, google ' midpoint formula'. Header holds nothing but the name of the game which is an image sprite and doesn't move or interact. This is why in design view, we disabled that. After we setup its position, we made sure it's visible. SetupPlayButton procedure places the play button at the center of the screen. SetupGameVisibility procedure takes a boolean variable as a parameter. We named the variable visibility. If it is true, we show game components, otherwise we hide it. The reason we used not block from Logic drawer for setting the visibility of play button is because when game starts, we do not want to show the play button but the game items/components. When the game ends, we want to hide all game components except the play/retry button which is also the same when our game launches. That is why we call this procedure with a false argument from Screen1.Initialize, because we want to only show the menu screen's items, not the game screen's items. By the way I am always using "screen" even though there's only one screen ( Screen1). I am doing that to differentiate when only menu items (Play button, score label) are visible from game items. Now we have to define what happens when the player presses the play button.

We will discuss the 4 procedure calls in SetupGame later. Let's first explain what happens at the beginning. So game is about to start. We want to reset the value of score to 0. Then, we show the score which we just set to 0. We do that because previously the menu screen might have showed best score or a tutorial. We change the state to ready state meaning the game is waiting for player's first tap to start. We make sure our score label is visible and header is invisible. We want to place the obstacles randomly. We do not want to start the game with spikes at the left or right all the time, nor do we want to just alternate. So we pick a number between 1 and 2 inclusive. If system gives us 1, we set the isOnLeft to true, otherwise false. Now let's look at the 4 procedures.

In SetupTopBottomSpikes, we set the X values of both top and bottom sprites to the center on x-axis using simple midpoint formula. Since the SpikesUp should be at the top, we set its Y to 0; and for the other one, we set it to the height of the screen so it appears at the bottom. Remember in canvas, point (0, 0) is on top left of the canvas. In SetupPlacements, we make sure that bird's speed is 5. You will know why we had to in a bit. Then we determine where we should put all those 4 obstacle spikes in terms of y-axis. As we do have a list of predefined positions contained by SPIKES_Y_POS variable, we just need to pick one from the list. So we generate a number between 1 which is the index of the first item in the list and the size of the list which is 10 as we have 10 items/lists meaning we get a number between 1 and 10 inclusive. After that we get the list at index we just randomly got. We do not want to use the same set of blocks multiple times to get a list item, we instead created a procedure called GetListItem which we can easily use instead of using the same set of blocks and make it look too busy-

Since SPIKES_Y_POS is a list of lists, the value of the list is also a list. Now if we want the list that contains [-100, 140, 210, 365] which is at index 1 of the parent list, we should give GetListItem 1 as the parentIndex, and then if we want to get the number 210 which is at index 3 of the child list, we should give 3 as the childIndex. Then we check if we should place the obstacles at left using isOnLeft variable's value which we determined in SetupGame procedure.

Now you might be wondering why are we changing the value of isOnLeft again to opposite. It's because SetupGame is called only once when user starts a game but this SetupPlacements will be used each time when the player bounces off an edge. If player bounces off the left edge, we need to put the obstacles at right and vice versa. After that we also change the heading to the opposite of bird's current direction at x-axis. Heading set to 0 makes the bird move rightward. Also we set the image that matches the bird's direction. Since we set isOnLeft to false meaning bird should be moving rightward, we set their X to right edge (canvas width) minus their width. We put an extra pixel (+1) because I kind of find the appearance better that way. You do not have to add that 1.

The name of the image " SpikeLeft.png " may confuse you but tiny spikes on that image is pointing to the left so it should be used when obstacles are placed on the right side. On the else portion, we do exactly the opposite.

Heading 180 makes the bird move leftward. We set obstacles' X to -1 but you can set it to 0. I like it that way. The very same reason why I added 1 when placing them at right.

After calling SetupPlacements, we call SetUpBirdPosition in SetupGame procedure. In SetupBirdPosition, depending on the heading we set in the SetupPlacements, we change where the bird should be initially placed when game is in ready state which is actually the opposite side of where we placed the obstacle spikes. You can use the heading property of the bird if you prefer rather than using another variable ( headingLeft) as I did. But you have to do a comparison and see if it's 0 (rightward) or 180 (leftward).

We are in ready state. The bird is supposed to flap continuously, but what exactly makes it flap? If you recall, in PlaySprite.Touched event, we enabled the ContinuousFlapClock. In design view, we set this clock's timer interval to 300 milliseconds. So, once it's enabled, after every 300 milliseconds, App Inventor will invoke this clock's Timer event automatically. And this is what we do when it's triggered-

We simply call another procedure that we defined named ChangeImage. This procedure needs to know the direction of the bird. This is why we enable ContinuousFlapClock after we call SetupGame. If ChangeImage procedure sees headingLeft is set to true, it then checks if current image is BirdLeftOne.png, if so it changes it to BirdLeftTwo.png to make the bird appear to be flapping. If it's the second image, it changes it to the first one. It does the opposite if the headingLeft is false. Now, we are waiting for player to tap to start playing. How do we start the game and control after it starts? Well, we do it whenever there's a touch on the canvas. App Inventor calls Screen1.Initialize at the beginning of an app launch, the same way it listens to any touch on a canvas through GameCanvas.Touched event whenever player touches the canvas.

We only care about a user touch when our game is in either ready or game state. When in ready state and user taps for the first time, we change the state to game state. We stop continuous flapping of the bird by disabling that clock. We enable yClock. We will see in a bit what it does. We also enable the bird so it can now move to a direction depending on its current heading. Whenever there's a touch, we make the bird jump meaning we change its Y value. For moving along x-axis, we did set bird's heading; and in design view we also set the speed to be 5. In JumpBird procedure, we play the flap sound. We set isFalling to false since we are jumping, not falling. We change the image like we explained for continuous flapping. We enable both MoveClock and FlapClock.

If you recall what I mentioned about the clocks we have at the beginning of this tutorial, you know MoveClock controls how long the bird can fly up when the player taps the screen. When MoveClock is fired, we stop flying up and set isFalling to true so the bird will descend. In FlapClock's Timer event, we change the current bird's image and disable the timer as we do not want it to flap continuously. What makes the bird actually move up or down? Answer is yClock. Again, yClock is to control bird's location on y-axis which has an interval set to 0. So, when it's enabled, it fires continuously and does this-

If our bird should fall, we increase its Y value since a Canvas' (0, 0) position is at top left. If the Y is equal to the height of the canvas, the bird will be at the bottom. We do the opposite if we are going up. You might be wondering why didn't we enable/disable yClock in JumpBird procedure instead. It's because when we are in game state, we do not intend to disable yClock. The bird is constantly moving either up or down. Also JumpBird procedure as its name implies should not make the bird fall too. We are close. The bird jumps when player taps and falls if player doesn't tap. Now we need to handle what happens when our bird reaches the left or right edge.

Whenever the bird reaches left or right edge, player makes a score. So we play score sound. We call SetupPlacements to place 4 spike obstacles on the other side. We explained what this procedure does a while ago. We add 1 to the score and update score label to display the new score. Unfortunately we have to make its cuteness die if it bumps on any of the 6 spikes (top, bottom, and 4 obstacles spikes). In order to do that we need to check if it's colliding with any of them-

We will see EndGameState procedure in a bit. For now just think, it's the end of the game. If bird collides with either top or bottom spike, we make the bird die right away. For the obstacle spikes, we give a little leverage. We call isDead procedure. If bird collides with any of the four obstacles, we check first if it is moving left and not too far (less than middle of the screen), and then we see if it crossed the obstacle half way through, if it did, we let it live. After it is half way through and then collides with any other above or below, we don't kill it either. We increased its speed to hit edge faster so it doesn't keep colliding. This is why we had to reset the speed to 5 in SetupPlacements procedure. We do the similar thing for the right edge. IsDead returns true if we need to end the game, otherwise returns false.

If you are still with me and didn't skip any part of this tutorial, I bet you really are going to make something awesome someday. Did you realize we just made a game? I applaud your efforts getting this far.

If you want me to make more tutorials like this, support me by downloading and rating our Games.

Download the project OhMySpikes.aia, import, and try on a device.

# data[].attributes.attachment_link.title
Oh My Spikes - Create a game from scratch using App Inventor

# data[].attributes.attachment_link.description
Today we are going to make a game from scratch inspired by recently popular spike games. We will call it Oh My Spikes. Before we start, you may want to see how the final game will look like. This will help you follow the tutorial easily.

# data[].attributes.attachment_link.title
Colored Dots for App Inventor 2 | Explore MIT App Inventor

# data[].attributes.attachment_link.description
This tutorial shows how to create apps that have multiple screens. In App Inventor, you can have a screen open a second screen. Later, the second screen can return to the screen that opened it. You can have as many screens as you like, but each screen closes by returning to the screen that opened it.

# data[].attributes.attachment_link.title
QuizMe for App Inventor 2 | Explore MIT App Inventor

# data[].attributes.attachment_link.description
This tutorial assumes you are familiar with the basics of App Inventor -- using the Component Designer to build a user interface, and using the Blocks Editor to specify event-handlers. If you are not familiar with the basics, try stepping through some of the basic tutorials before continuing.

# data[].attributes.attachment_link.description
Learn how to create a No Texting While Driving App for Android with App Inventor 2.

# data[].attributes.attachment_link.description
Learn how to create a No Texting While Driving App for Android with App Inventor 2.

# data[].attributes.attachment_link.description
Learn how to create a No Texting While Driving App for Android with App Inventor 2.

# data[].attributes.attachment_link.description
Learn how to create a No Texting While Driving App for Android with App Inventor 2.

# data[].attributes.attachment_link.description
Learn how to create a No Texting While Driving App for Android with App Inventor 2.

# data[].attributes.attachment_link.description
Learn how to create a No Texting While Driving App for Android with App Inventor 2.

# data[].attributes.attachment_link.description
Learn how to create a No Texting While Driving App for Android with App Inventor 2.

# data[].attributes.attachment_link.title
Space Invaders | Explore MIT App Inventor

# data[].attributes.attachment_link.description
By building the Space Invaders App you will get practice with using Clock components and Timers, using Animation components such as Image Sprites and the Canvas, setting visibility, and detecting collisions in App Inventor. You'll program an application that has a shooter ship whose goal is to shoot all the flying saucers on the screen.

# data[].attributes.attachment_link.title
Mini Golf: Fling, TouchUp, TouchDown Gestures for App Inventor 2 | Explore MIT App Inventor

# data[].attributes.attachment_link.description
We'll build this app in stages, adding a little bit of the game at a time. Log into App Inventor and start a new project. Name it "MiniGolf". When the Design window opens notice that App Inventor automatically names the screen "Screen1", but you can set the Title of the screen, which will show up in the top bar of the app.

# data[].attributes.attachment_link.title
VideoWall for App Inventor 2 | Explore MIT App Inventor

# data[].attributes.attachment_link.description
The finished VideoWall app will display a wall of three videos that can be expanded to their true size and then shrunk back down again. The app will also allow you to display the videos in fullscreen.

# data[].attributes.attachment_link.title
Get the Gold for App Inventor 2 | Explore MIT App Inventor

# data[].attributes.attachment_link.description
App Inventor detects collisions by checking for an intersection between the bounding rectangles of each ImageSprite. We call this rectangle-based collision detection. As you can see in the image below, sprites with circular or polygon shape will appear to collide because of the rectangular bounds around them when they might not actually be colliding.

# data[].attributes.attachment_link.title
Mole Mash 2 with Sprite Layering for App Inventor 2 | Explore MIT App Inventor

# data[].attributes.attachment_link.description
In order to highlight new App Inventor features - the Advanced tab and Sprite Z-layering - this app takes a different approach than the original Mole Mash tutorial, which you do not need to have completed in order to do this one.

# data[].attributes.body
http://tbolttube.northmontschools.com/videos.php?watch=603

# data[].attributes.attachment_link.description
Learn how to create the Digital Doodle app for Android using App Inventor 2.

# data[].attributes.body
http://tbolttube.northmontschools.com/videos.php?watch=602

# data[].attributes.attachment_link.description
Learn how to create a ball bounce game app for the Android using App Inventor 2.

# data[].attributes.body
http://tbolttube.northmontschools.com/videos.php?watch=601

# data[].attributes.attachment_link.description
Create the Talk To Me Android App with App Inventor 2.

# data[].attributes.body
http://tbolttube.northmontschools.com/videos.php?watch=600

# data[].attributes.attachment_link.description
Create the Talk To Me Android App with App Inventor 2.

# data[].attributes.body
http://tbolttube.northmontschools.com/videos.php?watch=598

# data[].attributes.attachment_link.description
Learn how to create a paint application for Android devices with App Inventor II.

# data[].attributes.body
http://tbolttube.northmontschools.com/videos.php?watch=599

# data[].attributes.attachment_link.description
Video tutorial for creating a paint application with App Inventor 2.

# data[].attributes.body
http://tbolttube.northmontschools.com/videos.php?watch=597

# data[].attributes.attachment_link.description
Learn how to create a paint application for Android devices with App Inventor II.

# data[].attributes.body
http://tbolttube.northmontschools.com/videos.php?watch=596

# data[].attributes.attachment_link.description
Learn how to create a paint application for Android devices with App Inventor II.

# data[].attributes.body
http://tbolttube.northmontschools.com/videos.php?watch=595

# data[].attributes.attachment_link.description
Learn how to create a paint application for Android devices with App Inventor II.

# data[].attributes.body
CANNOT BE USED AS THE FINAL PROJECT

# data[].attributes.attachment_link.title
Romero Blueprints_ GameHUD_ Timer and Custom Event

# data[].attributes.attachment_link.title
How can I create a timer that counts up and stops when reaching end of level_ - UE4 AnswerHub

# data[].attributes.attachment_link.title
Keep score with Blueprints - UE4 AnswerHub

# data[].attributes.attachment_link.title
how to create a scoring system with blueprints_ - UE4 AnswerHub

# data[].attributes.attachment_link.title
How can I implement a scoring system in Blueprints_ - UE4 AnswerHub

# data[].attributes.attachment_link.description
Tutorial video #7 for creating an endless runner game with the Unreal Engine 4.

# data[].attributes.attachment_link.description
Tutorial video #6 for creating an endless runner game with Unreal Engine 4.

# data[].attributes.attachment_link.description
Tutorial video #5 for creating an endless runner game with the Unreal Engine 4.

# data[].attributes.attachment_link.description
Tutorial video #4 for endless runner game on the Unreal Engine 4.

# data[].attributes.attachment_link.description
Video tutorial #3 for creating an endless runner game with the Unreal Engine 4.

# data[].attributes.headline
Video 2: Spawning the Course (Endless Runner)

# data[].attributes.subject
Video 2: Spawning the Course (Endless Runner)

# data[].attributes.attachment_link.description
Video #2 for creating an endless runner game on Unreal 4 Engine.

# data[].attributes.headline
Video 1: Intro and Player Control (Endless Runner)

# data[].attributes.subject
Video 1: Intro and Player Control (Endless Runner)

# data[].attributes.attachment_link.description
Tutorial video #1 for creating an endless runner game on Unreal 4 Engine.

# data[].attributes.attachment_link.description
Read about cloud with Eoin. I've also a fondness for maps and geo-stuff.

# data[].attributes.attachment_link.description
How to read files from a text file in MatLab (similar to FreeMat).

# data[].attributes.attachment_link.title
Introduction to Input and Printf Functions of FreeMat

# data[].attributes.body
Will open as a text file. Copy and paste into FreeMat Editor to be able to execute code.

# data[].attributes.body
Will open as a text file. Copy and paste into FreeMat Editor to be able to execute code.

# data[].attributes.attachment_link.description
Scratch is a free programming language and online community where you can create your own interactive stories, games, and animations.

# data[].attributes.attachment_link.description
The Synthesis ToolKit is a set of C++ classes. In order to go beyond the simple example programs we provide, it is necessary to know some basics about programming in C and C++. STK's "target audience" includes people who:

# data[].attributes.body
Need a Udemy account (free)

# data[].attributes.attachment_link.readable_text
Update Note: This beginning Android developmen tutorial is now up to date with the latest version of Android Studio. Updates by Megha Bambra. Original tutorial by Matt Luedke. Previous updates by Darryl Bayliss.

Clearly there's a demand for Android app development since there are over one billion active devices around the globe. To say that it's an exciting platform and space to make apps for is an understatement.

Getting Started

There aren't any prerequisites for this beginning Android development tutorial, other than a willing mind and a Mac - you can certainly develop for Android on PC, but these instructions are tooled for Mac-based developers.

You'll learn how to set up all the tools you need and will walk away as an Android developer-in-training. Here's what you'll do in this beginning Android development tutorial:

1. Download and install Android Studio.

2. Set up testing for your app on devices and emulators.

3. Create a simple "Hello World!" Android app that prints to your device's or emulator's screen.

4. Import a sample project into Android Studio.

Installing Android Studio

One of the most important parts of getting started with any new platform is setting up your environment, and it's no different with Android.

It's important to take your time and follow each step methodically. Even if you follow the steps perfectly, you may have to troubleshoot a small issue or few. Your system configuration or product versions can make for unexpected results.

With all of this in mind, let's quickly check that you have the Java Development Kit (JDK) installed. To check, you'll use trusty old Terminal.

Note: You'll learn the essential steps for this tutorial in the next few paragraphs, but if you'd like to deepen your knowledge of Terminal, you'll find a good introductory tutorial about it in this blog from teamtreehouse.com.

In a nutshell, using Terminal is kind of like looking under your car's hood. It's how you really get to know the machine face-to-face, without any complex graphical interface to interfere.

You can find the Terminal app quite easily on a Mac: open Launchpad and type terminal into the search at the top of the screen and select Terminal when it shows up.

Once you have the Terminal open, type in java -version. You should see some output that mentions a version number, like below.

If that's not what you see, then you don't have the JDK installed. Terminal might tell you -bash: java: command not found, or it could say No Java runtime present, requesting install. and trigger a pop up that will lead you down the yellow brick road...to Oracle's website.

You can either click More Info... or head over to Oracle to download the JDK from Oracle.

Install the JDK if needed, and once you're done, head over to the Android Studio page and click the Download Android Studio button.

Google constantly updates this page, so the version you see may very well be newer than the screenshot above. Once you click the button, you'll see a request to agree to the terms and conditions.

After reading these carefully (everybody takes the time to fully read these, right?) accept and click the blue button underneath titled Download Android Studio. Once the download is complete, you can install Android Studio similar to how you install any other program.

The download page will redirect to a page that contains installation instructions for OS X, Windows and Linux Operating Systems. If the instructions don't appear, then you can view them here.

Once installation wraps itself up, go ahead and launch Android Studio!

The setup wizard will greet you the first time it loads.

Click Next to move to the Install Type screen. This whole process will probably take several minutes.

Check the box for Standard and click Next.

On the Verify Settings window, you'll have an opportunity to confirm your setup. Click Finish to start downloading the SDK components. Once everything downloads, click Finish.

After a few minutes, you'll have the welcome screen, which serves as your gateway to building all things Android.

Even though you just downloaded it, it's possible that it's not the latest version. Check whether any updates are available by clicking check for updates at the bottom of the welcome screen. If an update is available, a window like the screenshot below will appear. Select Update Now and let it do its thing.

The Android SDK Manager

Each version of Android has its own SDK (Software Development Kit) that enables you to create applications for the Android platform. Since you just went through the setup wizard, you'll already have the latest version of the SDK available to you.

Installing a New SDK

However, it's useful to know how to install additional versions of the SDK so that you can develop for all supported versions of Android.

SDKs also allow you to create AVDs (Android Virtual Devices) that are customized to your personal configuration for the purpose of testing your app.

From the Android Studio welcome screen, click Configure.

The menu will slide across and present the Configure menu. Select the SDK Manager option.

Once it launches, you'll see a window like the one below:

The first tab of this window, SDK Platforms, lists the Android SDK platform available for download.

Enable the Show Package Details option to see individual SDK components, such as the platform itself and the sources pertaining to the API level like system image. Take note of the checkbox next to the SDK platform; it will be pre-selected if an update is available.

By default, the SDK Manager installs the latest packages and tools. Select the SDKs as shown in the screenshot above. If you wish to install other SDKs, just select them for installation.

The SDK Tools tab lists developer tools and documentation along with the latest versions. Similar to the first tab, checking the Show Package Details will display available version of SDK tools.

The first three components in this list, for example, are Android SDK Build Tools, Android SDK Tools and Android SDK Platform-Tools. Each contains components that are designed to assist in the development of Android and work across multiple SDKs. Go with the default selection on this tab.

The SDK Update Sites tab displays the update sites for Android SDK tools and add-ons. You're not limited to what's listed because you can add other sites that host their own Android SDK add-ons, and then download them from those sites.

For the purpose of setting up correctly, select the options that are checked in the screenshot above. Click Apply at the bottom if it's active. You'll be presented with a confirmation dialog for the chosen packages; accept and continue. Click OK to close out the window.

The window will disappear and the SDK Manager will download and install the selected items. Once it's done, click Finish. You'll be directed back to the SDK Manager window where clicking OK will take you back to the Welcome to Android Studio.

Now the fun begins!

Creating Your First Project

Android Studio has a nice little step-by-step tool to help you create your project. Click Start a new Android Studio Project from the Welcome to Android Studio screen:

Note: If you currently have an Android Studio project open and can't see the welcome screen, select File\New Project from the menu to create a new project.

Identify Your Project

Android Studio will present you with a project creation screen:

Enter OMG Android in Application name as shown above. Feel free to put your own name in the Company Domain text field. As you type, you'll notice the Package Name automatically changes to create a reverse domain style name based on your entries.

The Package Name is used to uniquely identify your app so that any work performed by a device is always properly attributed to the source, thus preventing confusion between apps.

You can set the Project location to any location on your hard drive - keep the default if you don't have a preference. Click Next at the bottom of the window.

Choose an SDK

The next screen is the Target Android Devices window. This is where you select device types and operating systems to target.

The Minimum SDK drop-down menu sets the minimum version of Android required to run your app. The newer the SDK, the more features you'll have at your disposal; however, newer SDKs support fewer devices.

Selecting this value is simply a matter of balancing the capabilities you want and the devices you want to support. This is where developing for Android can get a little tricky.

If you really want to get into the details of what Minimum SDK version is best for your App, let Android Studio help you out.

As you change the Minimum SDK in the drop down menu, the percentage in the text underneath reflects what percentage of devices currently run that version of Android.

Click Help me choose underneath the drop down list to learn more about each SDK's set of features.

For more information on API versions and their uses, check out the Android Dashboards, which are updated every few days.

For now, you just want an App that works on an Android Phone, and that is what you'll see by default, alongside the default Minimum SDK. For this project, select SDK of API 16: Android 4.1 (Jelly Bean).

Set the Default Activity

After you choose the SDK, you choose a default for your app.

Think of an activity as a window within your app that displays content with which the user can interact. An activity can take up the entire screen or it could be a simple pop-up.

Your options on this particular template range from a blank activity with an Action Bar right up to an Activity with an embedded .

You'll make a lot of activities as you develop apps, so get to know them and know them well.

Select the Blank Activity option and click Next.

To speed this part up a little bit you'll use the pre-populated default values, but what is actually done with these values?

Activity Name: This gives your activity a name to refer to in code. A .java class will be created and will use the contents of this text field to give the class a name, which will ultimately be the name you use to refer to this activity in your code.

Layout Name: You're going to define your activity in Java, but the layout it shows to the user is defined in a special sort of Android XML. You'll learn how to read and edit those files shortly.

Click Finish.

Android Studio takes this as a cue to go do a bunch of behind-the-scenes operations and create your project. As it shoots out descriptions of what it's doing, you may notice it says something like this:

You see your project name, which is familiar. But then there is this Gradle word, and then a mention of Maven in the URL.

The benefit of having a modern IDE like Android Studio is that it handles a lot for you. But, as you're learning how to use the software, it's good to have a general sense of what it's doing for you.

Gradle
Gradle is a relatively new build tool that's easy to use, and if you investigate further, you'll find it contains advanced options. It takes your Java code, XML layouts and the latest Android build tools to create the app package file, also known as an APK file.

You can customize your configurations to have development or production versions of the app that behave differently, or you can add dependencies for third-party libraries.

Maven
Maven is another project build tool, and it can also refer to the Maven Central repository of java libraries.

It's absurdly easy to use Gradle and Maven Central in concert with Android Studio to incorporate all sorts of functionality from the Android development community. If you're familiar with iOS, then know that these give you cool developer superpowers much as CocoaPods does.

After a brief moment, Android Studio will finish building your project. The project is pretty empty, of course, but it has everything it needs set up so that it can be launched on an Android device or emulator. You'll be dropped off in this spot:

And that's all it takes to create a Hello World project on Android Studio! Now to dress it up and work through building and running this project on an emulator.

Running on an Emulator

You've got Android Studio and you've created an app. So how do you run it?

Android Studio comes with the ability to set up a software-based Android device on your computer and run apps on it, browse websites, debug and everything you would expect from a simulator. This capability is known as the Android Emulator.

You can set up multiple emulators and set the screen size and platform version for each to whatever you like. Good thing, too. You'd need a whole room dedicated to storing devices for testing because there are so many out there - okay, maybe that's an exaggeration, but you get the idea. :]

If you ran through the setup wizard earlier using the standard installation, then you'll already have an emulator set up and ready for you. Android Studio makes use of some useful software developed by Intel to ensure your emulator runs quickly.

Up until recently, your computer would have to emulate everything an Android device would try to do, right down to its hardware, which runs an ARM-based processor. Most computers make use of x86-based processors, meaning your computer would have to do computationally intense tasks that take a significant amount of time just to test your app.

You still have the option to create an emulator that is as close to an actual device as you can, but be aware that the initial load times can drag a bit and have put off many an Android developer from using the emulator at all.

With all of that being said...let's set up an emulator anyway, because you do need to know how!

Creating an Emulator

Click AVD Manager. It's a button near the right side of the toolbar that shows an Android popping its head up next to a device with a purple display:

Once AVD Manager opens, you'll probably see the default emulator and a few details about it, notably what type of emulator it is, what API it's using, and what CPU instruction set it uses.

Alternatively, if the default device hasn't been created for you, you'll just see an option to create a new device. Either way, work through the process of creating a new AVD so you know how to do it. Click Create Virtual Device... in the bottom left to begin configuring a new virtual device.

The first decision you need to make is what type of device. The Category list on the left shows all the types of devices you can emulate. In the middle, you see a list of specific devices. Take a moment to explore.

For now, you just want to emulate a phone-sized device, but if you wanted to emulate an Android Wear watch or an Android TV then you have options to do so here.

Select Nexus S in the list of devices available to you from the phone category and click Next.

Now you're at the step where you decide what version of Android the virtual device will run. You'll already have one or two available to you thanks to the setup wizard, so lets use one of them.

Select Lollipop and make sure the one selected has the value x86 in the API column so the emulator runs as fast as possible on your x86 computer.

Click Next once you're done to advance to the final screen.

Note: If you can't click Next, then you probably need to download some archives. Go back to your selection and click Download. When it's done, you'll be able to move forward.

The last screen lets you confirm your choices and gives options to configure some other properties such as device name, startup orientation and RAM size. For now, use the defaults and click Finish.

Close the AVD Manager to go back to Android Studio's main view. Now that you've configured everything, click the Run button.

A new window will appear, asking you to choose the device you wish to test your App on. You currently have no devices running, so select the Nexus S you just created.

Ensure the Launch Emulator radio button is checked and that your AVD is selected in the drop down menu then click OK.

Note: If you get an error that says This AVD's configuration is missing a kernel file!!, check to make sure that you don't have the ANDROID_SDK_ROOT environment variable set from a previous installation of the Android SDK. See this thread on Stack Overflow for more troubleshooting tips.

In the event that it doesn't work the first time or takes several minutes for the emulator to fire up correctly, don't worry, that's not entirely unexpected. Stick with it. Once it's ready, you should see something like this:

Whoa. You just made your first Android app.

Running on a Device

If you have an Android device and want to run your app on it, follow the animated GIF on the right. It demonstrates how to enable developer mode on your device.

Here are the step-by-step instructions to enable Developer Mode on an Android device:

1. Go to Settings on your device.

2. Scroll all the way down and select About phone.

3. Scroll to Build number and tap in multiple times. You'll see a toast come up that states "You're n steps away from becoming a developer". Keep tapping and it will change to "You're now a developer!" once it's enabled.

4. Go back to Settings screen and scroll all the way to the bottom. You'll now see Developer Options enabled.

5. Select Developer Options. Next, turn on the USB debugging switch under the Debugging section.

6. Connect your device to your computer via USB.

7. You'll now be prompted to confirm this option via a dialog that states Allow USB debugging? - click OK.

8. Next, you'll be asked to register your computer's RSA key fingerprint. If this is a trusted machine, then check the Always allow from this computer option.

Now that you've configured your device, click the Run button.

Next, you'll get a prompt from the Device Chooser dialog. The device you enabled the developer mode should now appear in this dialog. Select it and click OK.

Ahh...isn't it rewarding to see the app on your device? Go ahead and show it off to your friends. :]

Importing an Existing Project

During your Android app-making journey, you'll find times where you need to import existing projects. The steps below will guide you through how to import a project:

1. Download this project so you have a test subject.

2. Once downloaded, unzip the contents and place them somewhere easy to get to.

3. In Android Studio, go to File/New/Import Project....

4. A window labeled Select Eclipse or Gradle Project will appear. Select the unzipped project from Step 1 and click OK.

5. After Android Studio finishes importing, you'll be dropped off on the screen below. Select the Project tab on the left panel as indicated in the screenshot below.

6. You'll now see all the necessary files of the imported project in the project explorer.

It's build and run time! Click the run button in the toolbar and select either the emulator or device you've already set up.

Where to Go From Here?

You've covered a lot of ground in this beginning Android development tutorial: from downloading and installing Android Studio, through creating your first "Hello World!" app, to deploying it on a physical device!

Keep reading for the next part of the series, where you'll take a tour of Android Studio.

In the meantime, here are some extra tips to help you get up to speed with Android:

Follow Android - like any language or framework, Android's development community is a strong asset and supplier of endless reference. It's never too soon or too late to start checking out Google I/O videos, following the Android Developers blog or watching DevBytes videos.

If you're using Eclipse for Android development and want to transition to Android Studio, Android team has put together a helpful guide to help you make the jump from Eclipse to Android Studio.

The Android robot is reproduced or modified from work created and shared by Google and used according to terms described in the Creative Commons 3.0 Attribution License.
I hope you enjoyed this beginning Android development tutorial - you've successfully installed Android Studio and are now ready to take on the world of Android development. If you have any questions or comments, please join the discussion in the comments below.

# data[].attributes.attachment_link.title
Beginning Android Development Part One: Installing Android Studio

# data[].attributes.attachment_link.description
Update Note: This beginning Android developmen tutorial is now up to date with the latest version of Android Studio. Updates by Megha Bambra. Original tutorial by Matt Luedke. Previous updates by Darryl Bayliss. Clearly there's a demand for Android app development since there are over one billion active devices around the globe.

# data[].attributes.attachment_link.readable_text
Google's Android Studio was recently released at Version 2.2 and there are big changes that make it even easier to create your first Android app. You can get started in a few minutes and by the end of this chapter, fully revised for 2.2, have your first working Android application.

There is a newer version of this chapter for Android Studio 2.3
Getting Started With Android Studio 2.3
NEW
Android Programming In Java:
Starting With an App
Third Edition
Covers Android Studio 3 and Constraint Layout.
Is now available as
Buy from:
USA and World Amazon.com
Canada Amazon.ca
UK Amazon.co.uk
France Amazon.fr
Germany Amazon.de
Spain Amazon.es
Italy Amazon.it
Japan Amazon.jp
Brazil Amazon.com.br
Mexico Amazon.com.mx

These articles are in the process of being updated to 3rd edition.

1. Getting Started With Android Studio 3

2. The Activity And The UI

3. Building The UI and a Calculator App

4. Android Events

5. Basic Controls

6. Layout Containers

7. The ConstraintLayout
Guidelines and Barriers

1. UI Graphics A Deep Dive

2. Menus & The Action Bar

3. Menus, Context & Popup

4. Resources

5. Beginning Bitmap Graphics

6. Staying Alive! Lifecycle & State

7. Spinners

8. Pickers

9. ListView And Adapters

Earlier versions

2nd edition drafts:

1. Getting Started With Android Studio 2

2. The Activity And The UI

3. Building The UI and a Calculator App

4. Android Events

5. Basic Controls

6. Layout Containers - Updated Version in Print Book

7. The ConstraintLayout - New In 2ed

8. UI Graphics A Deep Dive

9. Menus & The Action Bar

10. Menus, Context & Popup

11. Resources - Updated Version In Print Book

12. Beginning Bitmap Graphics

13. Staying Alive! Lifecycle & State -Updated Version In Print Book

14. Spinners

15. Pickers

16. ListView And Adapters

Custom Projects In Android Studio
If you are interested in creating custom template also see:

Android represents a big potential market. It is also the most open of the "big" phone platforms.

All the tools you need to create an Android App are free. You don't need to pay anything to create, and even distribute, your Android Apps. If you want to sell them using a well known marketplace there may something to pay - there is a one-time fee of $25 to register for Google Play - but you don't have to use any particular distribution method.

All that stands between you and your Android app is your imagination and programming ability. I can't do much to improve your imagination, but I can help with the programming side of things.

In this book I will show you the fundamentals of Android programming. Not the tips and tricks, but how to think about what is going on. You'll be introduced to the general principles that will make it possible for you to master anything that you encounter that is new in the future.

What do you need to know to get started?

You need to be able to program in a modern object-oriented language. Java would be best as it is the language used to create Android apps but C#, C++, VB or anything similar are close enough in spirit to Java for you to be able to cope.

You might well need to look things up about the specifics of particular features of Java, but most of the time it should be obvious or obvious with the help of a few comments.

It isn't necessary to be an expert programmer because for a lot of Android programming you are simply using the features and facilities provided. That is, a lot of Android programming is just a matter of following the rules.

However, if you hope to produce something unique and useful you will at some point have to add something of your own - and here creativity and skill are required. So you might not need to be an expert programmer to get started, but you need to become one by the time you create your amazing app.

Fortunately practice is a good teacher and so learning to make the most of Android Studio will actually help you learn to code.

Getting Started

This is a really good time to get started with Android because Google has released version 2.2 of Android Studio which is an easy to use Android IDE - Integrated Development Environment.

Before this you had to use the Eclipse IDE and setup the SDK and other pieces of software needed. This wasn't difficult but Android Studio makes it easy and it makes programming Android easy. Put simply it is the way of the future and so worth your investment in learning it.

With the release of Android Studio Google has stopped work on the Eclipse add-in and this means that Android Studio really is the only way to develop apps from now on.

I'm not going to spend a lot of time explaining how to install Android Studio in a step-by-step way - the Android website does a good job and it is more likely to be up-to-date. It is worth, however, going over the basic principles.

First make sure you have the latest Java JDK installed, at least JDK 6.

If you don't have Java installed visit: Java Download. Once you have Java, setting up Android Studio is easy:

Download the Android Studio package from Android Studio Home page.
Windows:
Install Android Studio which also installs all of the Android SDK and tools you will need.
Mac OS X:

1. Launch the downloaded EXE file, android-studio-bundle-<version>.exe.

2. Follow the setup wizard to install Android Studio.

Linux:

1. Open the downloaded DMG file, android-studio-bundle-<version>.dmg.

2. Drag and drop Android Studio into the Applications folder.

1. Unpack the downloaded ZIP file, android-studio-bundle-<version>.tgz, into an appropriate location for your applications.

2. To launch Android Studio, navigate to the android-studio/bin/ directory in a terminal and execute studio.sh. You may want to add android-studio/bin/ to your PATH environmental variable so that you can start Android Studio from any directory.

Accept any defaults that the setup program offers you - unless you have a good reason not to. It installs not only Android Studio, but the SDK and the virtual device system that lets you test your application.

Note: Currently 2.2 is in preview and has to be manually installed. Download the compressed file and uncompress it to a folder of your choice. You will find the executable in the bin subfolder.

On some Windows systems, the launcher script does not find where Java is installed and you will find that you can't run the newly installed Android Studio. It appears to start and then just vanishes.

If you encounter this problem, you need to set an environment variable indicating the correct location of the Java JDK.
Start menu > Computer > System Properties >
Advanced System Properties.
Select:
Advanced tab > Environment Variables,
add new system variable
Then open:

and setup JAVA_HOME that points to your JDK folder, for example C:\Program Files\Java\jdk1.7.0_21.

In most cases Android Studio just installs with no problem.

Now you should be able to run Android Studio. If not the most likely cause of the problem is the JDK and so re-installation is a best first option.

# data[].attributes.attachment_link.title
Android Adventures - Getting Started With Android Studio 2

# data[].attributes.attachment_link.description
Google's Android Studio was recently released at Version 2.2 and there are big changes that make it even easier to create your first Android app. You can get started in a few minutes and by the end of this chapter, fully revised for 2.2, have your first working Android application.

# data[].attributes.attachment_link.description
Tutorials, How-To Guides and More. Learn about mobile phone development, hacking, flashing, rooting and many other topics!

# data[].attributes.attachment_link.title
Google Code Archive - Long-term storage for Google Code Project Hosting.

# data[].attributes.attachment_link.title
Download Android Studio and SDK Tools | Android Studio

# data[].attributes.attachment_link.description
Download the official Android IDE and developer tools to build apps for Android phones, tablets, wearables, TVs, and more.

# data[].attributes.attachment_link.title
Google Code Archive - Long-term storage for Google Code Project Hosting.

# data[].attributes.attachment_link.readable_text
Android Studio is a fairly new IDE (Integrated Development Environment) made available for free by Google to Android developers. Android Studio is based on IntelliJ IDEA, an IDE that also offers a good Android development environment. In this tutorial, I'll show you how to create a new Android project and take advantage of the features that Android Studio has to offer.

When you're just getting started with Android Studio, it can be very helpful to use an Android app template. You can find over a thousand of them for sale on Envato Market:

Android app templates for sale on Envato Market

1. Project Setup

Before you start exploring Android Studio, you'll first need to download and install it. Note that you need to have JDK 6 or higher installed. If you're on Windows, launch the .exe file and follow the steps of the setup wizard. If you're running OS X, mount the disk image by double-clicking it and drag Android Studio to your Applications folder.

If you've successfully completed the above steps, then your development environment should be set up correctly. You're now ready to create your first Android application using Android Studio. When you launch Android Studio for the first time, you should be presented with a welcome screen, offering you a number of choices to get you started.

In this tutorial, we're going to choose the New Project option. However, you can choose Import Project if you'd like to import a project from, for example, Eclipse, into Android Studio. Android Studio will convert the Eclipse project to an Android Studio project, adding the necessary configuration files for you.

If you select Open Project from the list of options, you can open projects created with either Android Studio or IntelliJ IDEA. By choosing Check out from Version Control, you can check out a copy of a project that's under version control. This is a great way to quickly get up to speed with an existing project.

To get us started, choose New Project from the list of options. This will show you a list of options to configure your new project. In this tutorial, we're going to create a simple application to show you some of Android Studio's most important features. I'm sure you agree that there's no better name for our project than HelloWorld.

As you can see in the above screenshot, I've named my application HelloWorld and set the module name to HelloWorld. If you're unfamiliar with IntelliJ IDEA, you may be wondering what a module is. A module is a discrete unit of functionality that can be compiled, run, tested, and debugged independently. Modules contain source code, build scripts, and everything else required for their specific task.

When creating a new project, you can also set the package name of the project. By default, Android Studio sets the last element of the project's package name to the name of the module, but you can change it to whatever you want.

The other settings are the project's location on your machine, the minimum and target SDK, the SDK your project will be compiled with, and the project's theme. You can also tell Android Studio to create an Activity class and a custom launch icon for you, and whether the project supports GridLayout, Fragments, a Navigation Drawer, or an Action Bar.

We won't create a custom icon for this application so you can uncheck the checkbox labeled Create custom launch icon. Click Next to continue setting up your project.

Because we checked the checkbox Create activity in the previous step, you are asked to configure the Activity class Android Studio will create for you.

Since we'll be starting with a blank Activity class, you can click Next to proceed to the next step in the setup process in which you're asked to name the Activity class, the main layout, and the fragment layout. You can also set the navigation type, which we'll leave at None for this project. Take a look at the next screenshot to see what your settings should look like.

After clicking Finish, you'll be presented with Android Studio's user interface with the project explorer on the left and the workspace on the right. With your project set up in Android Studio, it's time to explore some of the key features of Android Studio.

2. Android Virtual Devices

An Android Virtual Device or AVD is an emulator configuration, allowing you to model an Android device. This makes running and testing applications on a wide range of devices much easier. With an Android Virtual Device, you can specify the hardware and software the Android Emulator needs to emulate.

The preferred way to create an Android Virtual Device is through the AVD Manager, which you can access in Android Studio by selecting Android > AVD Manager from the Tools menu.

If you're development environment is set up correctly, the Android Virtual Device Manager should look similar to the screenshot below.

To create a new AVD, click New... on the right, give the AVD a name, and configure the virtual device as shown below. Click OK to create your first AVD.

To use your newly created AVD, select it from the list in the AVD manager, and click Start... on the right. If your AVD is set up correctly, the Android Emulator should launch as shown in the screenshot below.

With the Android Emulator up and running, it's time to launch your application by selecting Run 'helloworld' from the Run menu. That's how easy it is to run an application in the Android Emulator.

3. Live Layout

Android Studio's live layout feature lets you preview your application's user interface without the need to run it on a device or the emulator. The live layout feature is a powerful tool that will literally save you hours. Viewing your application's user interface is much faster using live layouts.

To work with live layouts, double-click the XML layout file and select the Text tab at the bottom of the workspace. Select the Preview tab on the right of the workspace to preview the current layout. Any changes you make to the XML layout will be reflected in the preview on the right. Take a look at the screenshot below to get a better idea of this neat feature.

There are a number of other advantages of the live layout feature that are worth pointing out. You can, for example, create a variation of the XML layout you're currently working on by selecting an option from the first menu in the Preview pane. You can, for example, create separate views for portrait and landscape and Android Studio will create the necessary folders and files for you.

The second menu in the Preview pane lets you change the size of the device shown in the Preview pane. The third menu lets you change the orientation of the device shown in the Preview pane, which makes it easy to see how a layout looks in different orientations and using different themes.

The fourth menu in the Preview pane gives you easy access to the Activity or fragment in which the layout is used. The Preview pane also lets you change the language used in the live layout to make it easy to preview a layout in different languages. The rightmost menu lets you change the API version.

The Preview pane also includes controls to zoom in on the layout, refresh the Preview pane, or take a screenshot.

4. Templates

Android Studio provides developers with a number of templates to speed up development. These templates automatically create an Activity and the necessary XML files. You can use these templates to create a basic Android application, which you can then run on a device or in the emulator.

With Android Studio, you can create a template when you create a new Activity. Right-click on the package name in the project navigator on the left, select New from the menu, and choose Activity from the list of options. Android Studio then shows you a list of templates, such as Blank Activity, Fullscreen Activity, and Tabbed Activity.

You can also select Image Asset from the menu, which will launch a wizard that guides you through the creation process. Let me show you how to create a new Activity based on the Login Activity template. Select the Login Activity option from the list of Activity templates to fire up the wizard.

As you can see in the above screenshot, I've named the Activity LoginActivity, set the Layout Name to activity_login, given the Activity a title of Sign In. The checkbox labeled Include Google+ sign in is checked by default. Uncheck it since we won't be using this feature in our example.

You can optionally set the Hierarchical Parent of the new Activity. This will let you navigate back if you tap the device's back button. We will leave this field empty. After clicking Finish, Android Studio creates the necessary files and folders for you. If all went well, you should see a new Activity and Layout in your project.

The next step is to set up the new Activity in the manifest file so it's used as the main Activity when the application launches. As you can see in manifest file below, the LoginActivity class has its own activity node.

<application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name="com.tuts.HelloWorld.MainActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <activity
            android:name="com.tuts.HelloWorld.LoginActivity"
            android:label="@string/title_activity_login"
            android:windowSoftInputMode="adjustResize|stateVisible" >
        </activity>
    </application>

To make your application launch the LoginActivity you created, remove the activity node for the LoginActivity class and replace com.tuts.HelloWorld.MainActivity
with com.tuts.HelloWorld.LoginActivity. The result is that the application will now use the LoginActivity class as its main Activity.

<application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name="za.co.helloworld.LoginActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

When you build and run your application in the emulator, you should see a screen similar to the one shown below. This means that we've successfully replaced the blank Activity class with the newly created LoginActivity class.

5. Lint Tools

Testing your code is one thing, but it's equally important to apply best practices when writing code. This will improve performance and the overall stability of your application. It's also much easier to maintain a properly structured project.

Android Studio's includes Android Lint, a static analyzer that analyzes your project's source code. It can detect potential bugs and other problems in your code that are the compiler may overlook.

The below screenshot, for example, tells us that the LinearLayout in this layout is of no use. The nice thing about Android Lint is that it gives you a reason for the warning or error, which makes it easier to fix or resolve.

It's good practice to run Android Studio's lint tool from time to time to check your project for potential problems. The lint tool will even tell you if you have duplicate images or translations.

To run the lint tool, select Inspect Code... from the Analyze menu in Android Studio to start the process. When Android Studio has finished inspect your project, it will present you with the results at the bottom of the window. Note that in addition to Android Lint, Android Studio performs a number of other checks as well. Simply double-click an issue to navigate to the file in which the problem is located.

6. Rich Layout Editor

Android Studio has a rich layout editor in which you can drag and drop user interface components. You can also preview layouts on multiple screen configurations as we saw earlier in this tutorial.

The rich layout editor is very straightforward to use. We first need a layout to work with. Navigate to the layout folder in your project's res folder, right-click the layout folder, and select New > Layout resource file from the menu that appears.

Give the new layout a name, set its root element, and click OK. Android Studio will automatically open the layout in the editor on the right.

At the bottom of the editor, you should see two tabs, Design and Text. Clicking the Text tab brings up the editor, allowing you to make changes to the currently selected layout.

Clicking the Design tab brings up another editor that shows you a preview of the layout. To add a widget to the layout, drag it from the list of widgets on the left to the layout on the right. It's that simple.

Conclusion

In this tutorial, we've taken a brief look at some of the key features of Android Studio. It is very similar to IntelliJ IDEA, but it contains a number of important enhancements that make Android development easier, faster, and more enjoyable.

If you want to speed things up even more, try using an Android app template from Envato Market, or working with a freelance Android developer on Envato Studio.

# data[].attributes.attachment_link.description
Android Studio is a fairly new IDE (Integrated Development Environment) made available for free by Google to Android developers. Android Studio is based on IntelliJ IDEA, an IDE that also offers a good Android development environment. In this tutorial, I'll show you how to create a new Android project and take advantage of the features that Android Studio has to offer.