Android is an open source platform for mobile computing. Applications are developed using familiar Java and Eclipse tools. This course teaches students the architecture, API and techniques to create robust, high performance and appealing applications for the Android devices. In this class, students will work with current version of Android. While many classes focus on the mobile device, this course also deals with the server side architecture. This makes the class ideal for enterprise class businesses.
This course is divided into two modules -
Introduction to Android Device Programming
Advanced Android Programming
Introductory module is designed to quickly get programers upto speed with writing apps for Android devices. In this Android course you will learn the basics of the Android platform and the application lifecycle. By the end of the class you will be able to write simple GUI applications, use built-in widgets and components, work with the database to store data locally, and much more.
The Advanced Android Programming module teaches students how to create custom advanced Android applications. The Focus of this Advanced Android training class is on learning how to create location-aware applications that use animations, work with the built-in camera, use sensors, create and use advanced content providers and manage Bluetooth, telephony and networking connectivity.
Duration : 56 Hrs | 28 Days | 4 Weeks
Program Contents
Introduction to Android
What is Android?
A Short History
Why Android is Different (and Important)
Advantages of Android
Disadvantages of Android
The Architecture of Android
Key Components Stack
The Kernel
Libraries
The Dalvik JVM
Application Framework
Applications
Native Android Applications
SDK Overview
Android SDK Features
Elements of Android SDK
Platforms
Tools
Versions
The Development Environment
What Do We Need?
Setting Up the SDK
Install Eclipse Plugin
Create a Virtual Device
Creating a Project
Running Your Application
Buttons of the Emulator
Run Configuration
Debugging an Application
Using Third Party JAR
Creating Reusable Library
Dalvik Debug Monitor Server (DDMS)
DDMS Tools in Eclipse
The Console Views
Developing for Multiple Android Versions
Application Fundamentals
Creating Your First Project
The Manifest File
Layout Resource
Running Your App on Emulator
Recapping The Basics
Packaging an Application
Application Reusability Architecture
Activity
Creating an Activity Class
Activity Lifecycle
Launching an Activity
Pausing and Stopping an Activity
Destroying an Activity
Saving State
The onCreate() Method
Registering an Activity
The Default Activity
Process Lifecycle
The Application Class
The Application Context
The Application Context
Services
Content Providers
Broadcast Receivers
Android System Overview
File System
Preferences
Notifications
Security Model
Android User Interface and GUI Programming
XML vs. Java UI
DIPs and SPs
Views and Layouts
Common UI Components
Handling User Events
The Fundamentals
View Hierarchy
Creating Views Programmatically
Creating View in XML Layout
More on XML Layout
Common Programming Tasks with Views
TextView and EditText
Button
CheckBox
RadioButton and RadioGroup
ToggleButton
ImageView
RatingBar
Layout Management
Background
LinearLayout
LinearLayout Orientation
fill_parent Example
Layout Gravity
Weight
TableLayout
Managing the Width
RelativeLayout
RelativeLayout Example
ScrollView
HorizontalScrollView
Resource Management and Localization
Introduction
Main Types of Resources
Defining Value Resources
Defining String Arrays
Creating Image Resource
Alternate Resource Folders
Alternate Folder Name Rules
How Android Finds Resources
Dealing with Screen Orientation
Orientation Change and Activity Lifecycle
Developing for Tablets
Basics of Localization
Testing for Localization
Loading Localized String from Code
Intents and Intent Filters
What is an Intent?
The android.content.Intent Class
Explicitly Specifying Component Name
Example
Implicit Target Component Specification
Intent Filters
Action Name
Category Name
Data Type Filter
Hint Matching Logic
Examples of Hint Matching
Default Component of an Application
Starting an Activity
Getting Output from Activity
Example of Launcher: ActivityA
Example of Launched: ActivityB
Pending Intent
Application Menu
Introduction
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
Showing Notification Messages
Introduction
Toast
Popping a Toast
Advanced Toast
Status Bar Notification
Advantages of Status Bar Notification
Steps to Create a Status Bar Notification
Posting the Notification
Using an Utility Method
Additional Notes
Using Dialogs
AlertDialog
Handling Button Click Events
ProgressDialog
Setting Progress Amount
Advanced GUI Development
Selection Components
Adapters
Complex UI Components
Building UI for Performance
Menus and Dialogs
Graphics
Animations
Spinner View
Creating a Spinner
Handling Item Selection Event
The ListView
Creating a ListView
Handling ListView Events
The Adapter Model
Adapter Class
Example Adapter
Using an Adapter
The ArrayAdapter Class
ViewFlipper
Tabbed UI Layout
Creating Tabbed UI
Defining the Tabbed Layout
Creating the Tabs with View Content
Add a Tab with Activity Content
WebView
ebView Methods
Data Storage
Data Storage Options
Data Privacy
Shared Preferences
Modifying Shared Preferences
Sharing
Android Techniques for Saving Data
Saving Simple Application Data
Creating and Saving Preferences
Retrieving Shared Preferences
Saving Activity State
Creating a Preferences Page
Saving and Loading Files
Sharing
Android Techniques for Saving Data
Creating and Saving Preferences
Saving Simple Application Data
Retrieving Shared Preferences
Saving Activity State
Saving and Loading Files
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 Files in External Storage
Example: Writing to External Storage
Shipping Files with the Application
Working with Raw Resource Files
Working with Asset Files
SQL Database Storage
Introducing SQLite
SQLiteOpenHelper and Creating a Database
Opening and Closing a Database
Working with Cursors, Inserts, Updates and Deletes
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
Network Programming
Introduction
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
Background Task Processing
Introduction
Introducing Services
Using Background Worker Threads
Introducing Notifications
Using Alarms
The Handler Framework
The Basic Approach
Creating a Handler
Posting a Message
Doing Background Work
AsyncTask
Doing the Work
Starting Work
Getting Result from the Task
Updating GUI From the Task
Ending the Task
What is Service
Why Use a Service?
Service for Background Work
Creating a Service
Example Service Class
Starting and Stopping a Service
Starting Long Running Work
Sending Control Messages to a Service
Usability Guidelines
Multimedia Programming
Introduction
Recording Audio
Playing Audio
Playing from Raw Resource
Playing from a File or Network Stream
Stopping and Cleanup
Video Playback
Playing Video
Multimedia Supported Audio Formats
Simple Media Playback
Supported Video Formats
Simple Video Playback
Testing Applications
Introduction
New Sources of Defects
Special Testing Considerations
Android Testing Framework
The Architecture
Creating a Test Project
Test Case Class for an Activity
Test Initialization
Writing a Test Case Method
Service Test Case Class
Running Test Cases
Useful Methods of an Activity Test Case Class
Additional Assertion Function
The TouchUtils Class
Developing and Testing on a Device
Stress Test Monkey
Why Automate Tests?
Instrumentation and Unit Testing
Third Party Testing Tools
Packaging and Distributing Applications
Introduction
Pricing Options
Getting the Application Ready
About Signing the Application
Exporting and Signing the Application
Going to Android Market
Doing Maintenance
Advanced Modules
Content Providers
Content Provider MIME Types
Searching for Content
Adding, Changing and Removing Content
Working with Content Files
Use of URL
The Structure of Data
MIME Type
Creating a Content Provider
Implement the query () Method
Implement the insert() Method
The update() and delete() Methods
Implement getType()
Registering a Provider
Writing a Data Consumer
Performing a Query
Why Content Providers
Where the Content Comes From
Implementing the API Supporting Content
Mapping and Location Based
Services
Using Location Based Services
Setting Up Your Emulator with Location
Based Services
Selecting a Location Provider
Finding Your Location
Using Proximity Alerts
Using the Geocoder
Creating MapBased Activities
Location Services
Working with the Location Manager
Working with Google Maps Extensions
Guidelines for Obtaining Current Location
Obtaining Current Location from an Activity or Service
Reading Location Data
Other Considerations
Proximity Alert
Geocoding
Using MapView
Setting up the Project
Showing MapView from an Activity
Services
Overview of Services in Android
Implementing a Service
Service Lifecycle
Bound vs. Unbound Services
Broadcast Receivers
What are Broadcast Receivers?
Implementing Broadcast Receiver
System Broadcasts and How to Use Them
Intent Filters
Role of Filters
Intent-Matching Rules
Filters in Your Manifest
Filters in Dynamic Broadcast Receivers
Networking
Working with Web Services
Best Practices
Sensors
How Sensors Work
Listening to Sensor Readings
Best Practices for Performance
WiFi
Monitoring and Managing Internet Connectivity
Managing Active Connections
Managing WiFi
Telephony
Making Calls
Monitoring Data Connectivity and Activity
Accessing Phone Properties and Status
Controlling the Phone
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
Camera
Taking Picture
Rendering Previews
Bluetooth
Controlling Local Bluetooth Device
Discovering and Bonding with Bluetooth Devices
Managing Bluetooth Connections
Communicating with Bluetooth
Automated Testing
Why Automate Tests?
Instrumentation and Unit Testing
Audience :
Developers and architects who will be developing applications for
Android devices.