Android Development for Newbies (8+ Hours of Content)

Learn everything that you need to know to develop Android applications for fun and profit.
4.0 (826 ratings)
Instead of using a simple lifetime average, Udemy calculates a
course's star rating by considering a number of different factors
such as the number of ratings, the age of ratings, and the
likelihood of fraudulent ratings.
75,892 students enrolled
Free
Start Learning Now
  • Lectures 75
  • Length 8 hours
  • Skill Level Beginner Level
  • Languages English
  • Includes Lifetime access
    30 day money back guarantee!
    Available on iOS and Android
    Certificate of Completion
Wishlisted Wishlist

How taking a course works

Discover

Find online courses made by experts from around the world.

Learn

Take your courses with you and learn anywhere, anytime.

Master

Learn and practice real-world skills and achieve your goals.

About This Course

Published 6/2013 English

Course Description

** ONLY FREE ANDROID COURSE WITH 8+ HOURS OF CONTENT **

There goes a chinese proverb - "Tell me, I'll forget. Show me, I'll remember. Involve me, I'll understand."

The highest degree of learning takes place with your involvement. And this course is designed to do exactly that. This course introduces you to the basics of Android development. You will need some Java fundamentals to get started. If you are not sure about the difference between an abstract class and an interface you might have to refresh your Java concepts before proceeding.

Also, if you are new to Java I recommend John Purcell's Java Course, in order to acquire the minimal Java programming skills required to step into Android development.

I've also got you some companion code which you can download from the appropriate lectures. You'll be working on the source code along with me, so that you could get a good grasp on the concepts you will eventually be introduced to. At the end of this course you'll be able to write and deploy AWESOME!! apps to Google Play.

How is this course designed?

  • Comprehensive - Contains lessons and exercises that enable you to develop real-world Android applications.
  • Simple & Sequential - To keep complexity at bay, the course introduces you to independent concepts initially and then reveals more of the complex stuff.
  • Focused towards Results - This is the same course that we use internally at our mobile app startup, to train new talents.
  • Hands-on Sessions - I guide you through sessions building apps and writing code snippets clearly explaining every line of code.
  • Drills - Easy-to-moderate beginner level exercises in which you get the opportunity to practice what you've learnt and verify the same.
  • Elaborate Videos - Learn Android concepts in a thorough manner, I've made sure that all WHYs and HOWs you need to know are covered.

Since this course is for beginners, I highly recommend you to take this course sequentially. You can pick on random videos, but remember - the complexity increases down the road so it is imperative that you take them one by one.

What makes me qualified?

  • Started out as an indie Android developer in 2009 and have programmed for Android since the Cupcake days (Android 1.5).
  • Developed more than 100 Android apps till date, including games and other apps that use the Android NDK.
  • Contributed open-source libraries for Android that improve developer productivity, notable ones are Android Saripaar, Simple Section Adapter, and Instant Adapter.
  • Bootstrapped a startup and currently have 9 developers working on Android and iOS.
  • Training people since 2005 ;)

What are you waiting for? Gear up and lets have some fun!!

What are the requirements?

  • Desire to learn
  • Basic Java skills
  • A PC / Mac / Linux Box that can run Java, Eclipse and Android SDK

What am I going to get from this course?

  • You will learn to develop and distribute Android apps

What is the target audience?

  • Anyone with basic Java skills

What you get with this course?

Not for you? No problem.
30 day money back guarantee.

Forever yours.
Lifetime access.

Learn on the go.
Desktop, iOS and Android.

Get rewarded.
Certificate of completion.

Curriculum

Section 1: Gearing Up
Course Introduction
01:11
03:41

This video shows how to get the following softwares to begin developing apps for Android.
  1. Latest JDK for Windows / Mac / Linux
  2. Android Studio
03:24
This video shows you how to setup and organize your Eclipse IDE for Android development.
07:07
This videos introduces you to the following concepts,

  1. Creating a new Android Virtual Device (AVD) using the AVD Manager
  2. Downloading other Android platforms using the Android SDK Manager
Things to Remember
  1. The Android Virtual Device (AVD) can emulate devices with varying physical screen sizes, resolutions, hardware capabilities and different Android versions.
  2. You can have any number of AVDs.
  3. Use the Android SDK Manager to download various Android platforms.

01:56
Instructions on how to download the following extensions for Chrome,

  1. Android SDK Reference Search
  2. Android Resource Navigator

Setting up the PATH (Windows)
01:49
Setting up the PATH (Mac & Ubuntu)
03:33
Verifying your PATH
01:26
04:02

If you are stuck with default Android emulator on a slower PC or a Mac, you need a faster emulator because slower ones bring down your productivity. If you don't have a device and are looking for a faster emulator, you should give Genymotion a shot :)

Links from the video

Section 2: Traffic Lights and Event Listeners
Article
Go ahead and read it ;)
16:40

Please download the companion code attached along with this lecture. It is a zip file that contains the starter 'Traffic Lights' Android project.

This lecture covers the following,

  1. A demo of the application that we are going to build.
  2. How to import an Android project to your Eclipse workspace.
  3. Using the Graphical Layout Editor to create UI for your apps.
Things to Remember
  1. Java code goes into the src folder.
  2. Images go into the res/drawable-xxxx folders.
  3. UI screen designs are XML documents that go into the res/layout folder.
  4. If you want to refer a view from Java or XML, it should have an id.
20:27
This video is a continuation of the previous one. Here, we will be discussing about:

  1. Resource Identifiers
  2. Accessing various resources from Java
  3. Using click listeners to detect click events
Things to Remember
  1. Drawables, layouts and view ids are resources.
  2. Every resource is referenced using a resource identifier.
  3. To access resources from Java code, we use the resource identifiers defined in the R.java source file. Examples are R.layout.traffic_lights (layout resource), R.drawable.red_on (drawable resource), R.id.green_light (id resource).
  4. The View.OnClickListener interface handles click events.
  5. Click listeners must be assigned to views using the View.setOnClickListener(View.OnClickListener) method.
Article
This drill tests your understanding of the OnClickListener.
17:26
In this session I will be talking about,

  1. Views and their general characteristics
  2. Over 2 dozens of different views in Android
  3. How to discover and manipulate properties of Views

Things to Remember

  1. Views have width, height and are rectangular
  2. Views handle events using event listeners
  3. The properties of views can be retrieved and manipulated using the appropriate getter and setter methods.
  4. Use the Eclipse auto-complete feature and the Android SDK Reference to inspect view properties.

01:27
This is a drill in which you will be building a 'Simple Interest Calculator' app. After you watch the video please download the following to get started.

  1. SI Calculator.zip (Project Template for use with this drill)
  2. SI Calculator.pdf (Your instruction manual)

11:02
This lecture covers the following concepts,

  1. Why should we use logging?
  2. Using Logcat to view and filter logs from your Android application
Things to Remember
  1. There are five levels of logging - verbose, debug, info, warn and error.
  2. You can filter and view log messages using Logcat based on application, log levels, tags and regular expressions.

Using the Devices View in Eclipse
03:37
Troubleshooting - Gosh… My ADB is dead!
02:58
01:52
In this lecture, I demonstrate how to get your pre & post-honeycomb Android devices ready for debugging.
Deploying to a Device
Article
7 questions
Section 3: NEW: Working with Android Studio
04:09

This video shows you how to create a new Android Project using Android Studio.

10:31

Project structure of an Android Application Project created using Android Studio.

Section 4: Working with Eclipse ADT / ADT Bundle
05:36
This session shows you how to create a new Android project using Eclipse.
06:07
This video explains in detail about the Android project folders and their purposes. 
Things to Remember
  1. src contains all your Java source code.
  2. gen contains the R.java file and is managed by the Android build system and Eclipse.
  3. assets folder is like a read-only file system. Android does not generate resource ids for files placed inside this folder.
  4. bin contains compiled Java source and other compiled XML resources. It is managed by Eclipse and the Android build system.
  5. libs folder is the drop-in for all your jars.
  6. res folder contains Android project resources such as drawables, layouts, menus, strings, colors, etc.,
Section 5: Resources at your disposal
09:03
This video shows you how to,

  1. Create new string resources
  2. Access those resources from Java and XML
Things to Remember
  1. String resources are placed inside the res/values/strings.xml file.
  2. Use R.string.resource_name to reference a string resource from your Java code.
  3. Use @string/resource_name to reference a string resource from your XML.

07:26
This video teaches you how to use,
  1. Formatted string resources

Things to Remember

  1. On older ADT versions, if you have more than one format specifier use the formatted="false" attribute in your string resource definition (strings.xml file).
  2. Use the Resources.getString(int, Object…) or the Context.getString(int, Object…) method to retrieve your formatted string.
08:27
This lecture contains practical information on how to use string resources to add multiple language support to your application.

Things to Remember

  1. Create a values-language_iso_code folder under your res folder. (e.g.) res/values-hi for Hindi support, res/values-es for Spanish support.
  2. You can get the two lettered ISO 639-1 codes from this link.
  3. The key is to use the same resource names for strings but give them different values, (i.e) the translated text.
  4. If your application does not contain translations for a specific locale the string values from your default res/values will be picked up.

Article
Here are some of the questions that might bug you while using string resources.
04:43
This video introduces to the Context and also lets you know about the things you can do using a Context.


Things to Remember

  1. Context allows you to
    1. Access resources
    2. Interact with other Android components by sending messages
    3. Gives your information about your app environment.
  2. Activity is an indirect subclass of the Context class.
  3. You can use your Activity instance whenever you encounter a Context parameter.
  4. Views use Context to access resources they need such as strings, drawables, dimensions, animation, etc.,

07:10
This video teaches you the following,

  1. Creating new color resources
  2. Accessing color resources from XML and Java
Things to Remember
  1. Android uses the RGB color model to represent colors.
  2. Color resources are placed inside the res/values/colors.xml file.
  3. Use R.color.resource_name to reference color resources from Java.
  4. Use @color/resource_name to reference color resources from XML.
  5. To obtain a color resource from Java, use the Resources.getColor(R.color.resource_name) method.

Bitmap Drawables
05:46
05:29
You will learn how to use XML bitmaps for tiling.


Things to Remember

  1. Create your XML bitmaps inside the res/drawable folder.
  2. Use the android:src attribute to specify a drawable resource that you'd like to use.
  3. The android:tileMode="repeat" attribute is used to tile the bitmap both horizontally and vertically.

Built-in Resources
06:36
Section 6: NEW: Java 7 & Android
Section 7: Eye Candy
09:14

This video teaches you how to,

  1. Use custom fonts in your TextView
  2. Use HTML to format text for your TextView
Things to Remember
  1. Copy your fonts into the assets project directory.
  2. Prefer True Type Fonts (TTFs)
  3. Use the Typeface.createFromAsset(AssetManager, String) method to create fonts from files that are located in the assets directory.
  4. Replace the HTML opening tag character < with the corresponding HTML entity &lt; when you format your string with HTML. (e.g) Hello should be &lt;b>Hello&lt;/b>
  5. The Html.fromHtml(String) method returns a styled text that you can use in your TextView.
05:38
This video teaches you how to add links to your TextView. 

Things to Remember

  1. Use the Auto Link property from your XML and use one of the following values - web, email, phone, map and all.
  2. To set the property from Java use TextView.setAutoLinkMask(int) method to specify a linkify method. The int parameters takes constant values from the Linkify class.
  3. If you set the auto link property from Java, make sure to call the TextView.setText(CharSequence) method.
A chat with ImageView
05:51
05:46
Video introduces you to compound drawables.


Things to Remember

  1. Use the drawable left, drawable top, drawable right and drawable bottom properties from XML to set a compound drawable for your TextView.
  2. You can also achieve the same by calling the TextView.setCompoundDrawablesWithIntrinsicBounds(Drawable, Drawable, Drawable, Drawable) method from your Java code.

05:22
This video will teach you how to use the LinearLayout and its properties.


Things to Remember

  1. LinearLayout arranges it's child views either in a single row or a single column depending upon it's orientation.
  2. The orientation property can either be horizontal (single row) or vertical (single column).
  3. Use the gravity property to specify the alignment of the child views within the LinearLayout. You can use a combination of different gravity values.
  4. The child view's weight property decides how the free space is distributed among the children. It is a floating point value and can take up any value.
  5. Empty space is distributed vertically among the children when a weight property is specified in vertical orientation and horizontally in the horizontal orientation.

05:59
This video teaches you how to use a RelativeLayout.


Things to Remember

  1. RelativeLayout allows you to position Views relative to the layout itself.
  2. It also allows you to place Views relative to other Views already present in the layout.

Organizing Views in TableLayout
05:45
05:21
Learn how to use a ScrollView.


Things to Remember

  1. A ScrollView can have only one child, it could be either a ViewGroup or a View.
  2. ScrollView can be nested inside other ViewGroups.
  3. If you have too much text to display, you can wrap your TextView inside a ScrollView.

04:18
You'll learn how to nest ViewGroups to build complex layouts.


Things to Remember

  1. Layouts can be nested, that's all ;)

06:58
You'll learn how to use a CheckBox.


Things to Remember

  1. To check the state of a CheckBox, call the CheckBox.isChecked() method.
  2. You can either use the OnClickListener or the OnCheckedChangedListener with a CheckBox.

06:51
Find out how to use a RadioButton.


Things to Remember

  1. RadioButtons should be placed inside a RadioGroup.
  2. The RadioGroup is a subclass of the LinearLayout, so you can use the orientation and weight properties.
  3. You can have multiple RadioGroups inside the same layout but, you can select only one RadioButton in each RadioGroup.
  4. You can use View.OnClickListener as well as an OnCheckedChangeListener with your RadioButton.
  5. RadioGroup.getCheckedRadioButtonId() returns the id of the checked RadioButton. If none is checked, then -1 is returned instead.

Building your UI with XML
08:27
Width & Height Attributes
05:29
09:38
From this video, you will learn to use,

  1. The Android SDK Reference from the Android developer site
  2. Use the Android SDK Reference Search Chrome Extension
  3. Download and use the offline version of the Android SDK Reference

Section 8: Sugar for your Eye Candy
04:48
Margin outside the view.
Padding inside the view, surrounding the content.
Customizing Widgets with State Drawables
05:49
'Fancy' Favorite Button
10:34
ImageButton and Backgrounds
04:54
Myth Busted: Glossy Buttons and 9 Patches
11:21
06:42

This video shows you how to handle complex images using the 9 Patch tool. It also reveals two new features in the updated tool.

  1. Tool Tips that show patch and padding information.
  2. Guides used for applying patches and padding.

The supplementary file is a part of the touch50px UI Kit by www.angelostudio.net and is licensed under the CC Attribution 3.0 Unported license.

06:43
This video will teach you how to use a ListView.
Things to Remember

  1. The ArrayAdapter can back an array or a List.
  2. If you want to display a text information in a single line use the android.R.layout.simple_list_item_1 layout resource.
  3. Set the adapter instance to your list using the ListView.setAdapter(ListAdapter) method.

06:27
This video will show you how to,
  1. Move to a ListActivity from an Activity
  2. Use an empty view with your ListActivity

Things to Remember

  1. If you use a ListView in your layout, consider using the ListActivity instead of the Activity.
  2. Give your ListView an in-build Android id, which is @android:id/list.
  3. You can also use an empty view, which could be any view with the built-in Android id @android:id/empty.
  4. The ListActivity automatically manages the empty view for you based on the number of items in your ListAdapter.

09:52
Learn the quick way to create a Custom Adapter for your ListView.


Things to Remember

  1. Create a new layout for your list item.
  2. Create a custom adapter class extending the ArrayAdapter.
  3. Add an appropriate constructor, ArrayAdapter(Context, int, List) will do most of the time.
  4. You'll need an LayoutInflater instance to create view instances from your XML, to do that call the LayoutInflater.from(Context).
  5. Override the ArrayAdapter.getView(int, View, ViewGroup) method.
  6. Inflate your view using the LayoutInflater, get references to the views you are interested in by calling the View.findViewById(int) method.
  7. Get the data item for the list item position by calling the ArrayAdapter.getItem(int) method.
  8. Set the appropriate properties and return the view instance.

12:43
Custom adapters can be expensive if not done right. This video highlights the problems and gives you solutions to address those problems.

Things to Remember

  1. Use the 'recycled' convertView parameter to avoid creating unnecessary views.
  2. Make sure that your holder class is static, this will avoid memory leaks.
  3. Set your holder instance to the View using the View.setTag(Object) method.
  4. Retrieve your holder from the 'recycled' view by calling the View.getTag() method.

Bring up that Context Menu
07:56
Adding Functionality to the Context Menu Items
05:38
ListView Updates
04:16
Use a GridView, if you need a Grid
13:07
Section 9: Alerting Users
07:34
You'll learn how to raise a Toast from this video.


Things to Remember

  1. A Toast is a quick and unobtrusive way to display short messages to users.
  2. Create a Toast instance using the Toast.makeText(Context, CharSequence, int) method.
  3. Display the Toast to the user using the Toast.show() method.
  4. Toast.LENGTH_LONG keeps the Toast on the screen for 3.5 seconds.
  5. Toast.LENGTH_SHORT keeps the Toast on the screen for 2 seconds.

08:37
This video shows you have to create and show a dialog to the user.


Things to Remember

  1. Use an AlertDialog.Builder instance to start building dialogs.
  2. Your dialog can have Title, Message and Buttons (None, 1, 2 or 3 buttons).
  3. There are three types of buttons - Positive, Negative and Neutral.
  4. Use the Builder.setTitle(int) method to set a title for your dialog.
  5. You can set a message by calling the Builder.setMessage(int) method.
  6. You can add click listeners to the buttons when you set the button using the Builder.set*Button(CharSequence, DialogInterface.OnClickListener) method.
  7. If you don't want to listen for click events, you can pass a null argument to DialogInterface.OnClickListener parameter when setting a button.

02:13
Video demonstrates how to create a 'modal' dialog.


Things to Remember

  1. Call the Builder.setCancelable(true) method to make your dialog modal.

10:19
Learn to create a dialog that shows a list of items to select from.


Things to Remember

  1. Use the AlertDialog.Builder.setItems(CharSequence[], DialogInterface.OnClickListener) to set a list of items to your dialog.

09:11
Video shows you how to use your device's vibrator.


Things to Remember

  1. You need to declare the android.permission.VIBRATE permission in the manifest to use the vibrator.
  2. Get an instance of the Vibrator by calling the Context.getSystemService(Context.VIBRATOR_SERVICE).
  3. To vibrate the device for a specific duration call the Vibrator.vibrate(long) method.
  4. To vibrate the device in a specific pattern call the Vibrator.vibrate(long[], int) method.
  5. To stop the device from vibrating, call the Vibrator.cancel() method.
  6. Also make sure that you call Vibrator.cancel() by overriding the onPause() method inside your Activity.

Section 10: Get me some popcorn, please
03:56
Video demonstrates how to use an intent to open a web URL.


Things to Remember

  1. Use the following action, Intent.ACTION_VIEW for your intent.
  2. Use the Uri.parse(String) method to create an URI from your URL.
  3. Call the Intent.setData(Uri) method on the intent instance to set the website URL.
  4. Finally, use the Context.startActivity(Intent) method to open the web browser pointing towards the desired URL.

04:28
Learn how to use an intent to make a phone call from your application.


Things to Remember

  1. Intent action to be used is Intent.ACTION_CALL.
  2. The URI's format is "tel:phone_number".
  3. You need to add the android.permission.CALL_PHONE permission to your manifest, or else a security exception will be thrown.

04:28
Learn how to send a SMS using an intent.


Things to Remember

  1. The intent action is Intent.ACTION_SENDTO.
  2. The URI should be of the following format "smsto:phone_number".
  3. To pre-populate the messaging app with content, use the "sms_body" extra.

07:32
Learn how to send an email using an intent.


Things to Remember

  1. Intent action to be used is Intent.ACTION_SEND.
  2. Set the type by calling the Intent.setType(String) method to set the MIME type, which is message/rfc822.
  3. For specifying the recipients' email addresses use a String[] containing an array of email IDs for the extra Intent.EXTRA_EMAIL.
  4. Use the Intent.EXTRA_SUBJECT to mention the subject of your email.
  5. The Intent.EXTRA_TEXT extra allows you to include the email body.
  6. You can use the Intent.EXTRA_CC and Intent.EXTRA_BCC to specify the list of email addresses for recipients who you want to CC or BCC the email.
  7. Wrap your Context.startActivity(Intent) call inside a try… catch block to avoid exceptions on devices that do not have an email client.

06:51
This lecture will teach you the RIGHT way to check if an intent is supported on the target device.


Things to Remember

  1. Get a PackageManager instance from the Context by calling the Context.getPackageManager() method.
  2. Query for the Activities that support an intent by using the PackageManager.queryIntentActivities(Intent, int) method.
  3. Use the PackageManager.MATCH_DEFAULT_ONLY named constant for the flags parameter.

06:12
This video shows you how to,

  1. Add new activities to your Android project.
  2. Start an Activity using an Intent.
Things to Remember
  1. To add a new Activity in Eclipse, right click on the source package and select New > Other, from the New dialog, select Android > Android Activity, navigate through the wizard to create a new Android Activity.
  2. Create a new intent using the Intent(Context, Class) constructor, where the Class parameter receives the class instance of the Activity you want to start.
  3. Use the Context.startActivity(Intent) method to start the target activity.

08:30
This lecture teaches you how to pass additional information to Activities using intents.


Things to Remember

  1. You can pass strings, integers, arrays, collections and POJOs implementing Parcelable or Serializable as extras.
  2. To put additional information into your intents, use the Intent.putExtra(String, *) set of methods.
  3. To retrieve an extra first get the intent that started your Activity using the Activity.getIntent() method.
  4. Now use the Intent.getExtras() method or the Intent.get*Extra() set of methods to retrieve your extra.
  5. Refer to this Android SDK Reference to inspect the list of put* and get* extras methods to have an elaborate idea.

Section 11: Preferring Ice Tea to Cold Coffee
09:57
You will learn how to,

  1. Read from Preferences
  2. Write to Preferences
Things to Remember
  1. Obtain an instance of your SharedPreferences using the PreferenceManager.getDefaultSharedPreferences(Context) method.
  2. Use the SharedPreferences.get*(String, *) set of methods to read a preference.
  3. In order to write to a preference you will need an instance of an Editor, which is available from SharedPreferences.edit() method.
  4. Put in new preferences using the Editor.put*(String, *) set of methods.
  5. And make sure that you call the Editor.commit() method to save your changes.

Section 12: Conclusion
What next?
03:31

Students Who Viewed This Course Also Viewed

  • Loading
  • Loading
  • Loading

Instructor Biography

Ragunath Jawahar, Android Enthusiast and Entrepreneur

Ragunath Jawahar has been programming since he was 14. He perceives programming as a beautiful blend of art and science. Jawahar began programming in Java since 2008 and has mastered the language ever since. He strongly believes, practices and preaches object-oriented principles, design patterns and distributed version control systems. He has been working on a number of Java frameworks and began Android programming in 2010. Jawahar has been developing apps starting from Cupcake and is committed to develop apps for Android. He believes in open-source software and has authored a number of open-source libraries that significantly improve productivity for Android Developers. You can check them from his Github page.

Ready to start learning?
Start Learning Now