Android Programming Training

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
  • 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
  • Working with Web Services
  • Best Practices
  • How Sensors Work
  • Listening to Sensor Readings
  • Best Practices for Performance
  • Monitoring and Managing Internet Connectivity
  • Managing Active Connections
  • Managing WiFi
  • 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
  • Taking Picture
  • Rendering Previews
  • 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.
Pre-requisites :
  • Java Programming

Apply now at

Next Steps

Find Talent Gaps

Find Talent Gaps Understand your
Android Talent
Risks within
60 minutes.
Contact us today
for a free
Talent Gap Assessment.

Certify Your Skills

Find Talent Gaps Providence's Certification
Program helps
you develop,
practice and test the
technology skills required
to dazzle in the IT arena.

Already Providence Trained ?

You can always take the
fast track to certification.

Stay in Touch

we are Social geeks