Programming for Android Using Android Studio

Course#: BSMD1142 - Also available as a public course - Course Fee £ 1495

About this Course

Course Type Course Code Duration
Mobile Development BSMD1142 5 Days

Android is an open source platform for mobile computing. Applications are developed using the official Android development tool, Android Studio. This Android training course teaches students the architecture, API and techniques to create robust, high performance and appealing applications for the Android devices. While many classes focus on the mobile device, this Android development training course also deals with the server side architecture. This makes this Android development training course ideal for enterprise class businesses.

Why Attend this Course?

After taking this Android training course, students will be able to build robust and high performance applications for the enterprises.

What Makes this Course Stand Apart?

This is a highly interactive Hands on courses with the options of the Accelerator Plus1 Workshop.

Lot of demos, practical exercises and samples. Very strong presentation skill of the trainer. Good balance between theory and practice application.

What you will Learn?

Upon completion of this course, you will be able to:

The architecture of Android OS.
Using the Eclipse based development environment.
GUI development.
Supporting multiple languages.
Accessing data from files, network and SQL database.
Audio and video playback.
Automated testing of your applications.
Selling your applications in Android market.


Developers and architects who will be developing applications for Android devices.


To succeed fully in this course, students should be able to:

Program Java applications – or have attended our Programming in Java course.

Course Outline

Chapter 1. Introduction to Android

What is Android?
A Short History
Advantages of Android
Disadvantages of Android
Android Version Distribution
Android Market Share

Chapter 2. The Development Environment

What Do We Need?
Setting Up the SDK
Setting Up the SDK – Bundle Install
Setting Up the SDK – Manual Install
Android Studio
Studio Welcome Dialog
Android Studio Projects
Android Studio Interface
Visual Designer
Gradle Build System
Modifying Android Project Settings
Virtualization and Android Studio
Create a Virtual Device
Creating a Project
Running Your Application
Run Configuration
Debugging an Application
Developing for Multiple Android Versions
Migrating to Android Studio from Eclipse

Chapter 3. The Architecture of Android

Key Components Stack
The Kernel
The Android Runtime JVM
Application Framework
Support Libraries

Chapter 4. Application Fundamentals

Recapping The Basics
Packaging an Application
Application Reusability Architecture
The Manifest File
Creating an Activity Class
Activity Lifecycle
Launching an Activity
Pausing and Stopping an Activity
Destroying an Activity
Activity Destruction Under Resource Shortage
Saving State
Creating Views
Registering an Activity
The Default Activity
Process Lifecycle
The Application Class
The Application Context

Chapter 5. Basic GUI Programming

The Fundamentals
View Hierarchy
Creating Views Programmatically
Creating View in XML Layout
More on XML Layout
Common Programming Tasks with Views
TextView and EditText
Multi-Line Text
Ellipsize Long Text
RadioButton and RadioGroup

Chapter 6. Layout Management

LinearLayout Orientation
match_parent (fill_parent) Example
Layout Gravity
Managing the Width
RelativeLayout Example

Chapter 7. Resource Management and Localization

Main Types of Resources
Defining Value Resources
Defining String Arrays
Creating Image Resource
Alternate Resource Folders
Alternate Folder Name Rules
Eclipse Tools for Android XML Files
How Android Finds Resources
Dealing with Screen Orientation
Orientation Change and Activity Lifecycle
Fix Orientation
Developing for Tablets
Basics of Localization
Testing for Localization
Loading Localized String from Code

Chapter 8. Intents and Intent Filters

What is an Intent?
The android.content.Intent Class
Explicitly Specifying Component’s Class
Example: An Activity Launching Another Activity
Implicit Target Component Specification
Intent Filters
Data Type Filter
Action Name
Category Name
Hint Matching Logic
Example Hint Matching
Default Component of an Application
Starting an Activity
Getting Output from Activity
Example of Launcher: ActivityA
Example of Launched: ActivityB
Pending Intent

Chapter 9. Fragments and Supporting Different Screens

The Problem
Screen Density
Screen Size
Size Qualifiers in Android 3.2
Supporting Multiple Screens
Declaring Screen Support in Manifest
Screen Compatibility Mode
Providing Alternate Resources
Scaling Images
Providing Alternate Layout for Large Devices
Fragment Example
Creating a Fragment
Adding a Fragment to an Activity
Managing Fragments
Detecting Fragments From Activities
Communicating With an Activity
Using Fragment Callback Interface
Fragment State
Supporting Fragments on Older Devices
Putting It All Together
Testing on Multiple Screens

Chapter 10. Application Menu

Defining Menu Items
Menu XML File
Option Menu
Populating Menu Items from Resource
Manipulating Menu Items
Handling Menu Item Click Event
Context Menu
Showing a Context Menu
Handling Context Menu Item Click

Chapter 11. Showing Notification Messages

Popping a Toast
Controlling Toast Position With Gravity
Custom Toast View
Status Bar Notification
Normal Notification View
Advantages of Status Bar Notification
Steps to Create a Status Bar Notification
Posting the Notification
Using a Utility Method
Notification IDs
Notification Defaults and Flags
Notification.Builder Class
Using Dialogs
Handling Button Click Events
Setting Progress Amount

Chapter 12. Menus With Action Bar

Action Bar Overview
Enabling the Action Bar
Using an Existing Menu Definition
Adding Action Items
Handling Clicks on Action Items
Split Action Bar
Up Navigation
Using Action Views
Drop-down Navigation

Chapter 13. Advanced GUI Development

Spinner View
Creating a Spinner
Handling Item Selection Event
The ListView
Creating a ListView
Handling ListView Events
The Adapter Model
Custom Adapter Class
Example Adapter
Using an Adapter
Using a Custom Row Layout
Tabbed UI Layout
Configuring Action Bar for Tabs
The ActionBar.TabListener Interface
ViewPager Layout
Linking ViewPager and PagerAdapter
Linking Tabs and ViewPager Pages
WebView Methods

Chapter 14. Network Programming

Communication Using HTTP Protocol
Creating a HttpClient Object
Making a GET Request
Making a POST Request
Setting Timeout
Using Basic Authentication
Using Custom Authentication
XML Parsing Options
Setting Up XML Pull Parser
The Main Loop
Example XML Document
Example Parsing Code
Checking Network Status

Chapter 15. Background Task Processing

The Handler Framework
The Basic Approach
Creating a Handler
Posting a Message
Doing Background Work
Callback Methods of AsyncTask
Doing the Work
Starting Work
Getting Result from the Task
Updating GUI From the Task
Ending the Task
Implementing a Loader
Use LoaderManager to Initialize Loader
Implement LoaderCallbacks

Chapter 16. Data Storage

Data Storage Options
Data Privacy
Shared Preferences
Modifying Shared Preferences
Shared Preferences Example
Default Preferences
Editing Preferences
Example: Editing Preferences
Internal Storage
Example: Write to Internal Storage
Example: Read from Internal Storage
Private Directory
Cache Directory
Example: Writing to Cache File
External Storage
Checking State of External Storage
Working with Private External Storage
Example: Writing to External Storage
Shared External Storage
Shipping Files with the Application
Working with Raw Resource Files
Working with Asset Files

Chapter 17. Content Provider

Use of URL
The Structure of Data
Creating a Content Provider
Implement the query() Method
Example query() Method
Implement the insert() Method
Example insert() Method
The update() and delete() Methods
Implement getType()
Registering a Provider
Writing a Data Consumer
Performing a Query
Example Query by a Consumer
Example: Inserting Record

Chapter 18. SQL Database Storage

Opening a Database Connection
Transaction Management
A Pattern for Connection and Transaction Handling
Creating Schema
Compiled SQL Statement
Inserting Data
Updating Data
Deleting Data
Fetching Data
Example Queries
Iterating Over a Cursor
Reading Column Values from Cursor
A Complete Example
Cursor Management
Binding Cursor to ListView
Custom Data Binding
Handling Item Click Event
Refreshing the ListView
Schema Creation Issues
Example Helper Class
Using the Helper Class

Chapter 19. Multimedia Programming

Recording Audio
Start Recording Audio
Stop Recording
Playing Audio
Playing from Raw Resource
Playing from a File or Network Stream
Stopping and Cleanup
Video Playback
Playing Video

Chapter 20. Background Services

What is a Service?
Creating a Service
Example Service Class
Starting and Stopping a Service
Starting Long Running Work
Sending Control Messages to a Service
Using IntentService
Usability Guidelines

Chapter 21. Broadcast Receiver

Developing a Broadcast Receiver Component
Registering a Receiver
Broadcasting a Custom Intent
Sticky Event Broadcasting

Chapter 22. Location Based Services

Guidelines for Obtaining Current Location
Obtaining Current Location from an Activity or Service
Reading Location Data
Other Considerations
Proximity Alert
Example Geocoding and Reverse Geocoding
Using MapView
Setting up the Project
Showing MapView from an Activity

Chapter 23. Android Telephony API

Common Uses of Telephony API
Making a Phone Call
Sending SMS Message
Call and Service State
Monitoring Call and Service State
Register the Listener
Getting Detail Phone Information

Chapter 24. Testing Applications

New Sources of Defects
Special Testing Considerations
Android Testing Framework
The Architecture
Testing in Android Studio Projects
Test Results in Android Studio
Test Case Class for an Activity
Test Case Initialization
Writing a Test Case Method
Service Test Case Class
Useful Methods of an Activity Test Case Class
Additional Assertion Function
The TouchUtils Class
Developing and Testing on a Device
Stress Test Monkey
Third Party Testing Tools

Chapter 25. Packaging and Distributing Applications

Pricing Options
Getting the Application Ready
About Signing the Application
Exporting and Signing the Application
Going to Google Play
Doing Maintenance

Chapter 26. What’s New in Android Lollipop (5.0)

Overview of Android Lollipop
Material Design
Notification Changes
Android Lollipop and Enterprise Users
“Document Centric” Applications
Job Scheduling
Android TV and Wearables
Android Studio
Other Miscellaneous Changes

Lab Exercises

Lab 1. Setting up the Development Environment
Lab 2. Developing a Simple Application
Lab 3. Basic UI Development
Lab 4. Basics of Activity and Process Lifecycle
Lab 5. Using Simple Views
Lab 6. Layout Management
Lab 7. Resource Management
Lab 8. Localization
Lab 9. Using Intent to Launch Activities
Lab 10. Using Fragments
Lab 11. Working With Application Menu
Lab 12. Showing Notification Messages
Lab 13. Convert Menu for Action Bar
Lab 14. Custom ListView Adapter
Lab 15. Using a Spinner
Lab 16. Tabbed Interface
Lab 17. Network Programming
Lab 18. Performing Background Work
Lab 19. Using Loaders for Background Work
Lab 20. Working With File Storage
Lab 21. Caching Network Data on Disk
Lab 22. Content Provider and Consumer
Lab 23. Development Using SQLite Database
Lab 24. Play Audio Files
Lab 25. Develop a Simple Service
Lab 26. Developing Broadcast Receiver
Lab 27. Location Based Application
Lab 28. Using the Telephony API
Lab 29. Unit Testing an Application
Lab 30. Packaging and Installing Application


Start typing and press Enter to search