Your cart is empty.
Keep shopping
Teach on Udemy
Turn what you know into an opportunity and reach millions around the world.
Learn MoreAndroid Development for Newbies (8+ Hours of Content)
Rating: 4.3 out of 54.3(2,344 ratings)
160,551 students
Android Development for Newbies (8+ Hours of Content)
Learn everything that you need to know to develop Android applications for fun and profit.
Created byRagunath Jawahar
Last updated 6/2016
English
English [Auto],
What you'll learn
- You will learn to develop and distribute Android apps
Explore related topics
Course content
11 sections • 75 lectures • 8h 3m total length
- Course Introduction1:11
- Updated for Android Studio: Getting all you need3:41This video shows how to get the following softwares to begin developing apps for Android.
- Latest JDK for Windows / Mac / Linux
- Android Studio
- (Skip for Android Studio) Reorganizing Eclipse in 2-Minutes3:24This video shows you how to setup and organize your Eclipse IDE for Android development.
- Getting a brand new device - VIRTUALLY7:07This videos introduces you to the following concepts,
- Creating a new Android Virtual Device (AVD) using the AVD Manager
- Downloading other Android platforms using the Android SDK Manager
Things to Remember- The Android Virtual Device (AVD) can emulate devices with varying physical screen sizes, resolutions, hardware capabilities and different Android versions.
- You can have any number of AVDs.
- Use the Android SDK Manager to download various Android platforms.
- 2 More reasons to use Chrome1:56Instructions on how to download the following extensions for Chrome,
- Android SDK Reference Search
- Android Resource Navigator
- Setting up the PATH (Windows)1:49
- Setting up the PATH (Mac & Ubuntu)3:33
- Verifying your PATH1:26
- Genymotion - A Faster Emulator*4: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
- Objectives0:51Go ahead and read it ;)
- Traffic Lights Kickstart16:40Please 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,
- A demo of the application that we are going to build.
- How to import an Android project to your Eclipse workspace.
- Using the Graphical Layout Editor to create UI for your apps.
Things to Remember- Java code goes into the src folder.
- Images go into the res/drawable-xxxx folders.
- UI screen designs are XML documents that go into the res/layout folder.
- If you want to refer a view from Java or XML, it should have an id.
- Traffic Lights, turning them ON and OFF20:27This video is a continuation of the previous one. Here, we will be discussing about:
- Resource Identifiers
- Accessing various resources from Java
- Using click listeners to detect click events
Things to Remember- Drawables, layouts and view ids are resources.
- Every resource is referenced using a resource identifier.
- 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).
- The View.OnClickListener interface handles click events.
- Click listeners must be assigned to views using the View.setOnClickListener(View.OnClickListener) method.
- Drill - Traffic Lights0:56This drill tests your understanding of the OnClickListener.
- Introducing Views17:26In this session I will be talking about,
- Views and their general characteristics
- Over 2 dozens of different views in Android
- How to discover and manipulate properties of Views
Things to Remember
- Views have width, height and are rectangular
- Views handle events using event listeners
- The properties of views can be retrieved and manipulated using the appropriate getter and setter methods.
- Use the Eclipse auto-complete feature and the Android SDK Reference to inspect view properties.
- Drill - Simple Interest Calculator1:27This 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.
- SI Calculator.zip (Project Template for use with this drill)
- SI Calculator.pdf (Your instruction manual)
- Logging in Android11:02This lecture covers the following concepts,
- Why should we use logging?
- Using Logcat to view and filter logs from your Android application
Things to Remember- There are five levels of logging - verbose, debug, info, warn and error.
- You can filter and view log messages using Logcat based on application, log levels, tags and regular expressions.
- Using the Devices View in Eclipse3:37
- Troubleshooting - Gosh… My ADB is dead!2:58
- Device Deployment Groundwork1:52In this lecture, I demonstrate how to get your pre & post-honeycomb Android devices ready for debugging.
- Deploying to a Device0:28
- Skills Checklist
- NEW: Creating a New Android Project4:09
This video shows you how to create a new Android Project using Android Studio.
- NEW: Project Structure Explained10:31
Project structure of an Android Application Project created using Android Studio.
- Creating a New Android Project5:36This session shows you how to create a new Android project using Eclipse.
- Getting a grasp on the Project Folders6:07This video explains in detail about the Android project folders and their purposes.Things to Remember
- src contains all your Java source code.
- gen contains the R.java file and is managed by the Android build system and Eclipse.
- assets folder is like a read-only file system. Android does not generate resource ids for files placed inside this folder.
- bin contains compiled Java source and other compiled XML resources. It is managed by Eclipse and the Android build system.
- libs folder is the drop-in for all your jars.
- res folder contains Android project resources such as drawables, layouts, menus, strings, colors, etc.,
- Hallo, Salve, Bonjour with Strings9:03This video shows you how to,
- Create new string resources
- Access those resources from Java and XML
Things to Remember- String resources are placed inside the res/values/strings.xml file.
- Use R.string.resource_name to reference a string resource from your Java code.
- Use @string/resource_name to reference a string resource from your XML.
- Formatted String Resources7:26This video teaches you how to use,
- Formatted string resources
Things to Remember
- 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).
- Use the Resources.getString(int, Object…) or the Context.getString(int, Object…) method to retrieve your formatted string.
- Formatted string resources
- French fluency in your App8:27This lecture contains practical information on how to use string resources to add multiple language support to your application.
Things to Remember
- 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.
- You can get the two lettered ISO 639-1 codes from this link.
- The key is to use the same resource names for strings but give them different values, (i.e) the translated text.
- If your application does not contain translations for a specific locale the string values from your default res/values will be picked up.
- String Resources - FAQs1:27Here are some of the questions that might bug you while using string resources.
- What's a Context?4:43This video introduces to the Context and also lets you know about the things you can do using a Context.
Things to Remember
- Context allows you to
- Access resources
- Interact with other Android components by sending messages
- Gives your information about your app environment.
- Activity is an indirect subclass of the Context class.
- You can use your Activity instance whenever you encounter a Context parameter.
- Views use Context to access resources they need such as strings, drawables, dimensions, animation, etc.,
- Red, Blue, Green and Color7:10This video teaches you the following,
- Creating new color resources
- Accessing color resources from XML and Java
Things to Remember- Android uses the RGB color model to represent colors.
- Color resources are placed inside the res/values/colors.xml file.
- Use R.color.resource_name to reference color resources from Java.
- Use @color/resource_name to reference color resources from XML.
- To obtain a color resource from Java, use the Resources.getColor(R.color.resource_name) method.
- Bitmap Drawables5:46
Design graphics for different screen densities, place them in density-specific drawable folders, and reference bitmap drawables in XML or Java to display the correct launcher icon.
- Is that a flooring? - Using Tiled Bitmaps5:29You will learn how to use XML bitmaps for tiling.
Things to Remember
- Create your XML bitmaps inside the res/drawable folder.
- Use the android:src attribute to specify a drawable resource that you'd like to use.
- The android:tileMode="repeat" attribute is used to tile the bitmap both horizontally and vertically.
- Built-in Resources6:36
Learn to use built-in Android resources from layouts and Java. Switch between project and system resources and reference strings, drawables, colors, and styles with the Android resource prefix.
- TextView, Custom Fonts and HTML9:14
This video teaches you how to,
- Use custom fonts in your TextView
- Use HTML to format text for your TextView
Things to Remember- Copy your fonts into the assets project directory.
- Prefer True Type Fonts (TTFs)
- Use the Typeface.createFromAsset(AssetManager, String) method to create fonts from files that are located in the assets directory.
- Replace the HTML opening tag character < with the corresponding HTML entity < when you format your string with HTML. (e.g) Hello should be <b>Hello</b>
- The Html.fromHtml(String) method returns a styled text that you can use in your TextView.
- Using links with TextView5:38This video teaches you how to add links to your TextView.
Things to Remember
- Use the Auto Link property from your XML and use one of the following values - web, email, phone, map and all.
- 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.
- If you set the auto link property from Java, make sure to call the TextView.setText(CharSequence) method.
- A chat with ImageView5:51
Explore displaying images in Android using image view, drawables, and layout placement. Learn scale types such as center, fit, and fit XY to control image fit and cropping.
- Compound Drawables to the Rescue5:46Video introduces you to compound drawables.
Things to Remember
- Use the drawable left, drawable top, drawable right and drawable bottom properties from XML to set a compound drawable for your TextView.
- You can also achieve the same by calling the TextView.setCompoundDrawablesWithIntrinsicBounds(Drawable, Drawable, Drawable, Drawable) method from your Java code.
- Putting things 'Linear'ly in a 'Layout'5:22This video will teach you how to use the LinearLayout and its properties.
Things to Remember
- LinearLayout arranges it's child views either in a single row or a single column depending upon it's orientation.
- The orientation property can either be horizontal (single row) or vertical (single column).
- Use the gravity property to specify the alignment of the child views within the LinearLayout. You can use a combination of different gravity values.
- 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.
- Empty space is distributed vertically among the children when a weight property is specified in vertical orientation and horizontally in the horizontal orientation.
- RelativeLayout - 'Grand Master' of all Layouts5:59This video teaches you how to use a RelativeLayout.
Things to Remember
- RelativeLayout allows you to position Views relative to the layout itself.
- It also allows you to place Views relative to other Views already present in the layout.
- Organizing Views in TableLayout5:45
Learn to use the Android table layout to organize views by rows and columns, set the stretch columns property, and control item placement with layout_span and column indices.
- Scrolling UIs larger than Screen5:21Learn how to use a ScrollView.
Things to Remember
- A ScrollView can have only one child, it could be either a ViewGroup or a View.
- ScrollView can be nested inside other ViewGroups.
- If you have too much text to display, you can wrap your TextView inside a ScrollView.
- Nested Layouts4:18You'll learn how to nest ViewGroups to build complex layouts.
Things to Remember
- Layouts can be nested, that's all ;)
- CheckBoxes to keep your options open6:58You'll learn how to use a CheckBox.
Things to Remember
- To check the state of a CheckBox, call the CheckBox.isChecked() method.
- You can either use the OnClickListener or the OnCheckedChangedListener with a CheckBox.
- RadioButtons - Pick one, just one6:51Find out how to use a RadioButton.
Things to Remember
- RadioButtons should be placed inside a RadioGroup.
- The RadioGroup is a subclass of the LinearLayout, so you can use the orientation and weight properties.
- You can have multiple RadioGroups inside the same layout but, you can select only one RadioButton in each RadioGroup.
- You can use View.OnClickListener as well as an OnCheckedChangeListener with your RadioButton.
- RadioGroup.getCheckedRadioButtonId() returns the id of the checked RadioButton. If none is checked, then -1 is returned instead.
- Building your UI with XML8:27
- Width & Height Attributes5:29
- Using the Android SDK Reference9:38From this video, you will learn to use,
- The Android SDK Reference from the Android developer site
- Use the Android SDK Reference Search Chrome Extension
- Download and use the offline version of the Android SDK Reference
- Real Estate around your Views4:48Margin outside the view.Padding inside the view, surrounding the content.
- Customizing Widgets with State Drawables5:49
- 'Fancy' Favorite Button10:34
Master customizing a favorite button in Android by using a state list drawable for a star checkbox, covering unchecked, checked, pressed, and focused states to reflect user interaction.
- ImageButton and Backgrounds4:54
Create a stateful image button by building a selector with normal, enabled, and disabled states, remove its background with a transparent color, and control button interactivity programmatically.
- Myth Busted: Glossy Buttons and 9 Patches11:21
Customize android buttons by replacing default backgrounds with new images and apply a nine-patch drawable to control how the background stretches and where content appears.
- The Updated 9 Patch Tool*6: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.
- Tool Tips that show patch and padding information.
- 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.
- Presenting your data in a ListView6:43This video will teach you how to use a ListView.Things to Remember
- The ArrayAdapter can back an array or a List.
- If you want to display a text information in a single line use the android.R.layout.simple_list_item_1 layout resource.
- Set the adapter instance to your list using the ListView.setAdapter(ListAdapter) method.
- Transitioning to the ListActivity6:27This video will show you how to,
- Move to a ListActivity from an Activity
- Use an empty view with your ListActivity
Things to Remember
- If you use a ListView in your layout, consider using the ListActivity instead of the Activity.
- Give your ListView an in-build Android id, which is @android:id/list.
- You can also use an empty view, which could be any view with the built-in Android id @android:id/empty.
- The ListActivity automatically manages the empty view for you based on the number of items in your ListAdapter.
- Beautify your List #2 - Get it Working9:52Learn the quick way to create a Custom Adapter for your ListView.
Things to Remember
- Create a new layout for your list item.
- Create a custom adapter class extending the ArrayAdapter.
- Add an appropriate constructor, ArrayAdapter(Context, int, List) will do most of the time.
- You'll need an LayoutInflater instance to create view instances from your XML, to do that call the LayoutInflater.from(Context).
- Override the ArrayAdapter.getView(int, View, ViewGroup) method.
- Inflate your view using the LayoutInflater, get references to the views you are interested in by calling the View.findViewById(int) method.
- Get the data item for the list item position by calling the ArrayAdapter.getItem(int) method.
- Set the appropriate properties and return the view instance.
- Beautify your List #3 - Right way to do it12:43Custom adapters can be expensive if not done right. This video highlights the problems and gives you solutions to address those problems.
Things to Remember
- Use the 'recycled' convertView parameter to avoid creating unnecessary views.
- Make sure that your holder class is static, this will avoid memory leaks.
- Set your holder instance to the View using the View.setTag(Object) method.
- Retrieve your holder from the 'recycled' view by calling the View.getTag() method.
- Bring up that Context Menu7:56
- Adding Functionality to the Context Menu Items5:38
Learn to add functionality to context menu items in Android development by handling item selections via on context item selected and showing a toast with the book title and author.
- ListView Updates4:16
Update your list view by managing an adapter and dataset, add delete functionality, remove items by position, and call notifyDataSetChanged to refresh the list.
- Use a GridView, if you need a Grid13:07
Learn to display countries in a grid view with a custom adapter, binding country names and flags from drawable resources, and configuring columns and spacing.
- Let's raise a Toast7:34You'll learn how to raise a Toast from this video.
Things to Remember
- A Toast is a quick and unobtrusive way to display short messages to users.
- Create a Toast instance using the Toast.makeText(Context, CharSequence, int) method.
- Display the Toast to the user using the Toast.show() method.
- Toast.LENGTH_LONG keeps the Toast on the screen for 3.5 seconds.
- Toast.LENGTH_SHORT keeps the Toast on the screen for 2 seconds.
- Showing Dialogs8:37This video shows you have to create and show a dialog to the user.
Things to Remember
- Use an AlertDialog.Builder instance to start building dialogs.
- Your dialog can have Title, Message and Buttons (None, 1, 2 or 3 buttons).
- There are three types of buttons - Positive, Negative and Neutral.
- Use the Builder.setTitle(int) method to set a title for your dialog.
- You can set a message by calling the Builder.setMessage(int) method.
- You can add click listeners to the buttons when you set the button using the Builder.set*Button(CharSequence, DialogInterface.OnClickListener) method.
- If you don't want to listen for click events, you can pass a null argument to DialogInterface.OnClickListener parameter when setting a button.
- 'Stubborn' Modal Dialogs2:13Video demonstrates how to create a 'modal' dialog.
Things to Remember
- Call the Builder.setCancelable(true) method to make your dialog modal.
- List Dialog in Action10:19Learn to create a dialog that shows a list of items to select from.
Things to Remember
- Use the AlertDialog.Builder.setItems(CharSequence[], DialogInterface.OnClickListener) to set a list of items to your dialog.
- Vibrating your Phone9:11Video shows you how to use your device's vibrator.
Things to Remember
- You need to declare the android.permission.VIBRATE permission in the manifest to use the vibrator.
- Get an instance of the Vibrator by calling the Context.getSystemService(Context.VIBRATOR_SERVICE).
- To vibrate the device for a specific duration call the Vibrator.vibrate(long) method.
- To vibrate the device in a specific pattern call the Vibrator.vibrate(long[], int) method.
- To stop the device from vibrating, call the Vibrator.cancel() method.
- Also make sure that you call Vibrator.cancel() by overriding the onPause() method inside your Activity.
- Opening a Webpage3:56Video demonstrates how to use an intent to open a web URL.
Things to Remember
- Use the following action, Intent.ACTION_VIEW for your intent.
- Use the Uri.parse(String) method to create an URI from your URL.
- Call the Intent.setData(Uri) method on the intent instance to set the website URL.
- Finally, use the Context.startActivity(Intent) method to open the web browser pointing towards the desired URL.
- Making Phone Calls4:28Learn how to use an intent to make a phone call from your application.
Things to Remember
- Intent action to be used is Intent.ACTION_CALL.
- The URI's format is "tel:phone_number".
- You need to add the android.permission.CALL_PHONE permission to your manifest, or else a security exception will be thrown.
- How to send a SMS?4:28Learn how to send a SMS using an intent.
Things to Remember
- The intent action is Intent.ACTION_SENDTO.
- The URI should be of the following format "smsto:phone_number".
- To pre-populate the messaging app with content, use the "sms_body" extra.
- Sending Emails7:32Learn how to send an email using an intent.
Things to Remember
- Intent action to be used is Intent.ACTION_SEND.
- Set the type by calling the Intent.setType(String) method to set the MIME type, which is message/rfc822.
- For specifying the recipients' email addresses use a String[] containing an array of email IDs for the extra Intent.EXTRA_EMAIL.
- Use the Intent.EXTRA_SUBJECT to mention the subject of your email.
- The Intent.EXTRA_TEXT extra allows you to include the email body.
- 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.
- Wrap your Context.startActivity(Intent) call inside a try… catch block to avoid exceptions on devices that do not have an email client.
- How to check if an Intent is supported?6:51This lecture will teach you the RIGHT way to check if an intent is supported on the target device.
Things to Remember
- Get a PackageManager instance from the Context by calling the Context.getPackageManager() method.
- Query for the Activities that support an intent by using the PackageManager.queryIntentActivities(Intent, int) method.
- Use the PackageManager.MATCH_DEFAULT_ONLY named constant for the flags parameter.
- Starting Activities6:12This video shows you how to,
- Add new activities to your Android project.
- Start an Activity using an Intent.
Things to Remember- 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.
- 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.
- Use the Context.startActivity(Intent) method to start the target activity.
- Passing additional information as Extras8:30This lecture teaches you how to pass additional information to Activities using intents.
Things to Remember
- You can pass strings, integers, arrays, collections and POJOs implementing Parcelable or Serializable as extras.
- To put additional information into your intents, use the Intent.putExtra(String, *) set of methods.
- To retrieve an extra first get the intent that started your Activity using the Activity.getIntent() method.
- Now use the Intent.getExtras() method or the Intent.get*Extra() set of methods to retrieve your extra.
- Refer to this Android SDK Reference to inspect the list of put* and get* extras methods to have an elaborate idea.
- Writing and Reading Preferences9:57You will learn how to,
- Read from Preferences
- Write to Preferences
Things to Remember- Obtain an instance of your SharedPreferences using the PreferenceManager.getDefaultSharedPreferences(Context) method.
- Use the SharedPreferences.get*(String, *) set of methods to read a preference.
- In order to write to a preference you will need an instance of an Editor, which is available from SharedPreferences.edit() method.
- Put in new preferences using the Editor.put*(String, *) set of methods.
- And make sure that you call the Editor.commit() method to save your changes.
Requirements
- Desire to learn
- Basic Java skills
- A PC / Mac / Linux Box that can run Java, Eclipse and Android SDK
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!!
Who this course is for:
- Anyone with basic Java skills