:  +91 8099 133 133 (India)


:  +91 8099 133 133 (India)

Course Description

You’re a developer with plans to build Google Android apps. This Android programming training course covers everything you need to develop apps for Android devices. Work with Java and the Eclipse IDE, gain an understanding of how the OS works and the specifics required to build your Android app.

During the Android development training course you’ll develop different apps, providing a solid foundation for implementing your own development plans after the course.

  •  What will I learn?
        a. Using the Android SDK, Java, Eclipse and the Android tools.
        b. Work with Activities and Views.
        c. Understanding different saving mechanisms.
        d. Integrate apps with other phone features (Local Storage, Maps, GPS, internet, accelerometer...)

You'll have proficient developer skills with a good knowledge of a modern, object oriented language such as Java, C#, Python, Ruby or C++.

  • Programmer Requirements
    Android is typically programmed using Core Java that includes the OOPs concepts. Thus, some background in languages like C++, Java or C# will be extremely useful, but not mandatory.
  • What are the minimum requirements for learning Android Application Development in terms of Hardware, Software and Programming?
    The minimum requirements in terms of hardware, software, and programming skills to begin Android development are mentioned below:
  • Machine Requirements
    Android development tools run on all kinds of machine: Linux, Mac OS, or Microsoft Windows. Android pplication development may be performed on any of the following system types:
  • Operating Systems
    Windows XP (32-bit), Vista (32- or 64-bit), or Windows 7 (32- or 64-bit)
    Mac OS X 10.5.8 or later (x86 only)
    Linux (tested on Ubuntu Linux, Lucid Lynx)
    GNU C Library (glibc) 2.7 or later is required
    On Ubuntu Linux, version 8.04 or later is required
    64-bit distributions must be capable of running 32-bit applications
  • Software Requirements
    The software required for Android development is free and readily available on the Web:
  • The Java Development Kit (JDK)
    The Eclipse IDE (Java Developers version) with the Android plugin is not technically essential since everything it does can be done using the command line, but it simplifies so many things that we will consider it to be essential.
    The Android SDK and add-ons such as the Google Maps SDK
  • What are the steps to be followed to set up an Android Environment?
    Steps to follow to set up and Android Environment:
    Step1: Download an IDE (Integrated Development Environment) and install Eclipse
    Step2: Download and install the Java Runtime Environment (JRE)
    Step3: Download and install the Java Development Kit (JDK)
    Step4: Downloading the Android Developer Tools (ADT) Bundle
    Step5: Installing the ADT Bundle
Rating: 7.6/10- 74 reviews
Course Contents

Introduction to Android

  • Why develop applications for Android?
  • Intro to Android: An Open Platform for Mobile Development
  • The Native Android Applications
  • The features Android SDK provides for Application development
  • Understanding the Development Framework
        i. What comes in the box?
        ii. Understanding the Android Software Stack
        iii. The Dalvik Virtual Machine
        iv. Android Application Architecture
        v. Android Libraries

Getting Started

  • Developing for Android
        i. Downloading and installing the SDK
        ii. Developing with Eclipse
        iii. Using the Eclipse Plug-in
  • Creating your first Android Application
        i. Starting a New Android Project
        ii. Creating a Launch Configuration
        iii. Running and Debugging Your Android Applications
        iv. Understanding Hello World
  • Types of Android Applications
        i. Foreground Applications
        ii. Background Services and Intent Receivers
        iii. Intermittent Applications
        iv. Widgets
  • Design Considerations while Developing for Mobile Devices
        i. Hardware-Imposed Design Considerations
        ii. Considering the Users’ Environment
        iii. Developing Secure Applications
        iv. Ensuring a seamless User Experience


Creating Applications and Activities

  • What Makes an Android Application?
  • Introducing the Application Manifest
  • Using the Manifest Editor
  • The Android Application Life Cycle
  • Understanding Application Priority and Process States
  • Externalizing Resources
        a. Creating Resources
            i.Creating Simple Values
            ii.Styles and Themes
        b.Using Resources
            i.Using Resources in Code
            ii.Referencing Resources within Resources
            iii.Using System Resources
            iv.Referring to Styles in the Current Theme
        c.Creating Resources for Different Languages and Hardware
        d.Runtime Configuration Changes
  • Introducing the Android Application Class
        a.Extending and Using the Application Class
        b.Overriding the Application Life Cycle Events
  • A Closer Look at Android Activities
       a.Creating an Activity
       b.The Activity Life Cycle
            i.Activity Stacks
            ii.Activity States
            iii. Monitoring State Changes
       c.Understanding Activity Lifetimes
       d.Android Activity Classes


Creating User Interfaces

  • Fundamental Android UI Design
  • Introducing Views
  • Creating Activity User Interfaces with Views
  • The Android Widget Toolbox
  • Introducing Layouts
        a.Using Layouts
        b.Optimizing Layouts
  • Creating New Views
        a.Modifying Existing Views
            i.Customizing Your To-Do List
        b.Creating Compound Controls
        c.Creating Custom Views
            i.Creating a New Visual Interface
            ii.Handling User Interaction Events 
            iii.Creating a Compass View Example
        d.Using Custom Controls
  • Drawable Resources
        a.Color Drawable, Shape Drawable, Gradient Drawable
        b.Composite Drawables
            i.Transformative, Layer, State List, Level List Drawables
        c.NinePatch Drawable
  • Resolution and Density Independence
        a.The Resource Framework and Resolution Independence
            i.Resource Qualifiers for Screen Size and Pixel Density
            ii.Specifying Supported Screen Sizes
        b.Best Practices for Resolution Independence
            i.Relative Layouts and Density-Independent Pixels
            ii.Using Scalable Graphics Assets
            iii.Provide Optimized Resources for Different Screens
            i.Emulator Skins
            ii.Testing for Custom Resolutions and Screen Sizes
  • Creating and Using Menus
        a. Introducing the Android Menu System
        b. Defining an Activity Menu
        c. Menu Item Options
        d. Dynamically Updating Menu Items
        e. Handling Menu Selections
        f. Submenus and Context Menus
        g. Creating Submenus
        h. Using Context Menus
        i. Defining Menus in XML


Intents, Broadcast Receivers, Adapters and The Intrnet

  • Introducing Intents
        a.Using Intents to Launch Activities
            i.Explicitly Starting New Activities
            ii.Implicit Intents and Late Runtime Binding
            iii.Returning Results from Activities
            iv.Native Android Actions
        b.Using Intent Filters to Service Implicit Intents
            i.How Android Resolves Intent Filters
            ii.Finding and Using the Launch Intent Within an Activity
            iii.Passing on Responsibility
            iv.Select a Contact Example
        c.Using Intent Filters for Plug-Ins and Extensibility
            i.Supplying Anonymous Actions to Applicationsi
            ii.Incorporating Anonymous Actions in Your Activity’s Menu
        d.Introducing Linkify
            i.The Native Linkify Link Types
            ii.Creating Custom Link Strings
            iii.Using the Match Filter
            iv. Using the Transform Filter
        e.Using Intents to Broadcast Events
            i.Broadcasting Events with Intents
            ii. Listening for Broadcasts with Broadcast Receivers
            iii.Broadcasting Sticky and Ordered Intents
            iv.Native Android Broadcast Actions
  • Introducing Pending Intents
  • Introducing Adapters
        a.Introducing Some Native Adapters
        b.Customizing the Array Adapter
        c.Using Adapters for Data Binding
        d.Customizing the To-Do List Array Adapter
        e.Using the Simple Cursor Adapter
  • Using Internet Resources
        a.Connecting to an Internet Resource
        b. Using Internet Resources
  • Introducing Dialogs
        a.Introducing the Dialog Classes
            i.The Alert Dialog Class
            ii.Specialist Input Dialogs
        b.Using Activities as Dialogs
        c.Managing and Displaying Dialogs
  • Creating an Earthquake Viewer


Files, Saving State and Preferences

  • Saving Simple Application Data
  • Creating and Saving Preferences
  • Retrieving Shared Preferences
  • Creating a Settings Activity for the Earthquake Viewer
  • Introducing the Preference Activity and Preferences Framework
        a.Defining a Preference Screen Layout in XML
            i.Native Preference Controls
            ii.Using Intents to Import System Preference Screens
        b.Introducing the Preference Activity
        c.Finding and Using Preference Screen Shared Preferences
        d.Introducing Shared Preference Change Listeners
  • Creating a Standard Preference Activity for the Earthquake Viewer
  • Saving Activity State
        a.Saving and Restoring Instance State
        b.Saving the To-Do List Activity State
  • Saving and Loading Files
  • Including Static Files as Resources
  • File Management Tools


Database and Conent Providers

  • Introducing Android Databases
        a.Introducing SQLite Databases
        b.Introducing Content Providers
  • Introducing SQLite
  • Cursors and Content Values
  • Working with SQLite Databases
        a.Introducing the SQLiteOpenHelper
        b.Opening and Creating Databases without SQLiteHelper
        c.Android Database Design Considerations
        d.Querying a Database
        e.Extracting Results from a Cursor
        f. Adding, Updating, and Removing Rows
        g.Saving Your To-Do List
  • Creating a New Content Provider
        a.Exposing Access to the Data Source
        b.Registering Your Provider
  • Using Content Providers
        a.Introducing Content Resolvers
        b.Querying for Content
        c.Adding, Updating, and Deleting Content
        d.Accessing Files in Content Providers
  • Creating and Using an Earthquake Content Provider
        a.Creating the Content Provider
        b.Using the Provider
  • Native Android Content Providers
        a.Using the Media Store Provider
        b.Using the Contacts Provider
            i.Introducing the Contacts Contract Content Provider
            ii.Reading Contact Details
            iii.Modifying and Augmenting Contact Details


Maps, Geocoding and Location-Based Servvices

  • Using Location-Based Services
  • Configuring the Emulator to Test Location-Based Services
  • Updating Locations in Emulator Location Providers
  • Selecting a Location Provider
        a.Finding the Available Providers
        b.Finding Location Providers Using Criteria
  • Finding Your Location
        a.‘Where Am I?’ Example
        b.Tracking Movement
        c.Updating Your Location in ‘Where Am I?’
  • Using Proximity Alerts
  • Using the Geocoder
        a.Reverse Geocoding
        b.Forward Geocoding
        c.Geocoding ‘Where Am I?’
  • Creating Map-Based Activities
        a.Introducing Map View and Map Activity
        b.Getting Your Maps API Key
            i.Getting Your Development/Debugging MD5 Fingerprint
            ii.Getting your Production/Release MD5 Fingerprint
        c.Creating a Map-Based Activity
        d.Configuring and Using Map Views
        e.Using the Map Controller
        f.Mapping ‘Where Am I?’
        g.Creating and Using Overlays
            i.Creating New Overlays
            ii.Introducing Projections
            iii.Drawing on the Overlay Canvas
            iv.Handling Map Tap Events
            v.Adding and Removing Overlays
            vi.Annotating ‘Where Am I?’
        h.Introducing My Location Overlay 
        i.Introducing Itemized Overlays and Overlay Items 
        j.Pinning Views to the Map and Map Positions
  • Mapping Earthquakes Example


Working in the Background

  • Introducing Services
        a.Creating and Controlling Services
            i.Creating a Service
            ii.Registering a Service in the Manifest
            iii.Self-Terminating a Service
            iv.Starting, Controlling, and Interacting with a Service
            v.An Earthquake Monitoring Service Example
        b.Binding Activities to Services
        c.Prioritizing Background Services
  • Using Background Threads
        a.Using AsyncTask to Run Asynchronous Tasks
            i.Creating a New Asynchronous Task
            ii.Running an Asynchronous Task
        b.Moving the Earthquake Service to a Background Thread Using AsyncTask
        c.Manual Thread Creation and GUI Thread Synchronization
            i.Creating a New Thread
            ii.Using the Handler for Performing GUI Operations
  • Let’s Make a Toast
        a.Customizing Toasts
        b.Using Toasts in Worker Threads
  • Introducing Notifications
        a.Introducing the Notification Manager
        b.Creating Notifications
            i.Creating a Notification and Configuring the Status Bar Icon
            ii.Configuring the Extended Status Notification Display
        c.Triggering Notifications
        d.Adding Notifications and Toasts to the Earthquake Monitor
        e.Advanced Notification Techniques
            i.Using the Defaults
            ii.Making Sounds
            iii.Vibrating the Phone
            iv.Flashing the Lights
        f.Ongoing and Insistent Notifications
  • Using Alarms
        a.Setting Repeating Alarms
        b.Using Repeating Alarms to Update Earthquakes


Invading the Phone-Top

  • Introducing Home-Screen Widgets
  • Creating App Widgets 
        a.Creating the Widget Layout 
            i.Widget Design Guidelines 
            ii.Supported Widget Views and Layouts
        b.Defining Your Widget Settings
        c.Creating Your Widget Intent Receiver and Adding It to the Application Manifest
        d.Introducing Remote Views and the App Widget Manager
            i.Creating Remote Views and Using the App Widget Manager to Apply Them
            ii.Using a Remote View within the App Widget Provider’s onUpdate Handler
            iii.Using Remote Views to Modify UI
            iv.Making Your Widgets Interactive   
        f. Refreshing Your Widgets 
            i.Using the Minimum Update Rate 
            ii.Listening for Intents 
            iii.Using Alarms 
        g.Creating and Using a Widget Configuration Activity
  • Creating an Earthquake Widget
  • Introducing Live Folders
        a.Creating Live Folders
            i.Live Folder Content Providers
            ii.Live Folder Activity
        b.Creating an Earthquake Live Folder
  • Adding Search to Your Applications and the Quick Search Box
        a.Adding Search to Your Application
            i.Creating a Search Activity
            ii.Responding to Search Queries from a Content Provider
        b.Surfacing Search Results to the Quick Search Box
        c. Adding Search to the Earthquake Example
  • Creating Live Wallpaper
        a.Creating a Live Wallpaper Definition Resource
        b.Creating a Wallpaper Service
        c.Creating a Wallpaper Service Engine


Audio, Video and Using the Camera

  • Playing Audio and Video
        a.Introducing the Media Player
        b.Preparing Audio for Playback
            i.Packaging Audio as an Application Resource
            ii.Initializing Audio Content for Playback
        c.Preparing for Video Playback
            i.Playing Video Using the Video View
            ii.Setting up a Surface for Video Playback
            iii.Initializing Video Content for Playback
        d.Controlling Playback
        e.Managing Media Playback Output
  • Recording Audio and Video
        a.Using Intents to Record Video
        b.Using the Media Recorder
            i.Configuring and Controlling Video Recording
            ii.Previewing Video Recording
  • Using the Camera and Taking Pictures
        a.Using Intents to Take Pictures
        b.Controlling the Camera and Taking Pictures
            i.Controlling and Monitoring Camera Settings and Image Options
            ii.Monitoring Auto Focus
            iii.Using the Camera Preview
            iv.Taking a Picture
        c.Reading and Writing JPEG EXIF Image Details
  • Adding New Media to the Media Store
        a.Using the Media Scanner
        b.Inserting Media into the Media Store
  • Raw Audio Manipulation
        a.Recording Sound with Audio Record
        b.Playing Sound with Audio Track
  • Speech Recognition


Telephony and SMS

  • Telephony
        a.Launching the Dialer to Initiate Phone Calls
        b.Replacing the Native Dialer
        c.Accessing Phone and Network Properties and Status
            i.Reading Phone Device Details
            ii.Reading Data Connection and Transfer State
            iiiReading Network Details
            iv.Reading SIM Details
        d.Monitoring Changes in Phone State, Phone Activity, and Data Connections
            i.Monitoring Incoming Phone Calls
            ii.Tracking Cell Location Changes
            iii.Tracking Service Changes
            iv.Monitoring Data Connectivity and Activity
  • Introducing SMS and MMS
        a.Using SMS and MMS in Your Application
        b.Sending SMS and MMS from Your Application Using Intents and the Native Client
        c.Sending SMS Messages Manually
            i.Sending Text Messages
            ii.Tracking and Confirming SMS Message Delivery
            iii.Conforming to the Maximum SMS Message Size
            iv.Sending Data Messages
        d.Listening for Incoming SMS Messages
            i.Simulating Incoming SMS Messages in the Emulator
            ii.Handling Data SMS Messages
        e.Emergency Responder SMS Example
        f.Automating the Emergency Responder


Bluetooth, Networks and WI-FI

  • Using Bluetooth
        a.Accessing the Local Bluetooth Device Adapter
        b.Managing Bluetooth Properties and State
        c.Being Discoverable and Remote Device Discovery
            i.Managing Device Discoverability
            ii.Discovering Remote Devices
        d.Bluetooth Communications
            i.Opening a Bluetooth Server Socket Listener
            ii.Selecting Remote Bluetooth Devices for Communications
            iii.Opening a Client Bluetooth Socket Connection
            iv.Transmitting Data Using Bluetooth Sockets
        e.Bluetooth Data Transfer Example
  • Managing Network Connectivity
        a.Introducing the Connectivity Manager
        b.Reading User Preferences for Background Data Transfer
        c.Monitoring Network Details
        d.Finding and Configuring Network Preferences and Controlling Hardware Radios
        e.Monitoring Network Connectivity
  • Managing Your Wi-Fi
        a.Monitoring Wi-Fi Connectivity
        b.Monitoring Active Connection Details
        c.Scanning for Hotspots
        d.Managing Wi-Fi Configurations
        e.Creating Wi-Fi Network Configurations



  • Using Sensors and the Sensor Manager
        a.Introducing Sensors
            i.Supported Android Sensors
            ii.Finding Sensors
            iii.Using Sensors
  • Interpreting Sensor Values
  • Using the Compass, Accelerometer, and Orientation Sensors
        a.Introducing Accelerometers
        b.Detecting Acceleration Changes
        c.Creating a G-Forceometer
        d.Determining Your Orientation
            i.Determining Orientation Using the Orientation Sensor
            ii.Calculating Orientation Using the Accelerometer and Magnetic Field Sensors
            iii.Remapping the Orientation Reference Frame
        e.Creating a Compass and Artificial Horizon


Advanced Android Development

  • Paranoid Android
        a.Linux Kernel Security
        b.Introducing Permissions
        c. Declaring and Enforcing Permissions
        d.Enforcing Permissions for Broadcast Intents
  • Using Wake Locks
  • Introducing Android Text to Speech
  • Using AIDL to Support IPC for Services
        a.Implementing an AIDL Interface
        b.Passing Class Objects as Parcelables
            i.Creating the AIDL Service Definition
        c.Implementing and Exposing the IPC Interface
  • Using Internet Services
  • Building Rich User Interfaces
        a.Working with Animations
            i.Introducing Tweened Animations
            ii.Creating Tweened Animations
            iii.Applying Tweened Animations
            iv.Using Animation Listeners
            v.Animated Sliding User Interface Example
            vi.Animating Layouts and View Groups
            vii.Creating and Using Frame-by-Frame Animations
        b.Advanced Canvas Drawing
            i.What Can You Draw?
            ii.Getting the Most from Your Paint
            iii.Improving Paint Quality with Anti-Aliasing
            iv.Canvas Drawing Best Practice
            v.Advanced Compass Face Example
            vi.Bringing Map Overlays to Life
        c.Introducing the Surface View
            i.When Should You Use a Surface View?
            ii.Creating a New Surface View
            iii.Creating 3D Controls with a Surface View
        d.Creating Interactive Controls
            i.Using the Touch Screen
            ii.Using the Device Keys, Buttons, and D-Pad
            iii.Using the On Key Listener
            iv.Using the Trackball
Write a Review