• Real Time Signals India


Updated: Jan 9, 2018

Android is a mobile operating system developed by Google, based on a modified version of the Linux kernel and other open source software and designed primarily for touchscreen mobile devices such as smartphones and tablets.



 Abstract Classes

 Interfaces

 Introducing Collection

 Playing with Objects

 ArrayList

 LinkedList

 TreeSet

 HashSet

 TreeMap

 HashMap

 Understanding MYSQL

 SQL Commands


 A Little Background

 The Not-So-Distant Past

 Living in the Future

 What Android Isn’t

 Android: An Open Platform for Mobile Development

 Native Android Applications

 Android SDK Features

 Access to Hardware, Including Camera, GPS, and Sensors

 Data Transfers Using Wi-Fi, Bluetooth, and NFC

 Maps, Geo-coding, and Location-Based Services

 Background Services

 SQLite Database for Data Storage and Retrieval

 Shared Data and Inter-Application Communication

 Using Widgets and Live Wallpaper to Enhance the Home Screen

 Extensive Media Support and D/D Graphics

 Cloud to Device Messaging

 Optimized Memory and Process Management

 Introducing the Open Handset Alliance

 What Does Android Run On?

 Why Develop for Mobile?

 Why Develop for Android?

 Factors Driving Android’s Adoption

 What Android Has That Other Platforms Don’t Have

 The Changing Mobile Development Landscape

 Introducing the Development Framework

 What Comes in the Box

 Understanding the Android Software Stack

 Android Application Architecture

 Android Libraries


 Developing for Android

 What You Need to Begin

 Downloading and Installing the Android SDK

 Downloading and Installing Updates to the SDK

 Developing with Eclipse

 Using the Android Developer Tools Plug-In for Eclipse

 Using the Support Package

 Creating Your First Android Application

 Creating a New Android Project

 Creating an Android Virtual Device

 Creating Launch Configurations

 Running and Debugging Your Android Application

 Understanding Hello World

 Types of Android Applications

 Foreground Applications

 Background Applications

 Intermittent Applications

 Widgets and Live Wallpapers

 Developing for Mobile and Embedded Devices

 Hardware-Imposed Design Considerations

 Be Efficient

 Expect Limited Capacity

 Design for Different Screens

 Expect Low Speeds, High Latency

 At What Cost?

 Considering the User’s Environment

 Developing for Android

 Being Fast and Efficient

 Being Responsive

 Ensuring Data Freshness

 Developing Secure Applications

 Ensuring a Seamless User Experience

 Providing Accessibility

 Android Development Tools

 The Android Virtual Device Manager

 Android SDK Manager


 What Makes an Android Application?

 Introducing the Application Manifest File

 A Closer Look at the Application Manifest

 Using the Manifest Editor

 Externalizing Resources

 Creating Resources

 Simple Values

 Styles and Themes

 Drawables

 Layouts

 Animations

 Menus

 Using Resources

 Using Resources in Code

 Referencing Resources Within Resources

 Using System Resources

 Referring to Styles in the Current Theme

 Creating Resources for Different Languages and Hardware

 Runtime Configuration Changes

 The Android Application Lifecycle

 Understanding an Application’s Priority and Its Process’ States

 Introducing the Android Application Class

 Extending and Using the Application Class

 Overriding the Application Lifecycle Events

 A Closer Look at Android Activities

 Creating Activities

 The Activity Lifecycle

 Activity Stacks

 Activity States

 Monitoring State Changes

 Understanding Activity Lifetimes

 Android Activity Classes


 Fundamental Android UI Design

 Android User Interface Fundamentals

 Assigning User Interfaces to Activities

 Introducing Layouts

 Defining Layouts

 Using Layouts to Create Device Independent User Interfaces

 Using a Linear Layout

 Using a Relative Layout

 Using a Grid Layout

 Optimizing Layouts

 Redundant Layout Containers Are Redundant

 Avoid Using Excessive Views

 Using Lint to Analyze Your Layouts

 To-Do List Example

 Introducing Fragments

 Creating New Fragments

 The Fragment Lifecycle

 Fragment-Specific Lifecycle Events

 Fragment States

 Introducing the Fragment Manager

 Adding Fragments to Activities

 Using Fragment Transactions

 Adding, Removing, and Replacing Fragments

 Using the Fragment Manager to Find Fragments

 Populating Dynamic Activity Layouts with Fragments

 Fragments and the Back Stack

 Animating Fragment Transactions

 Interfacing Between Fragments and Activities

 Fragments Without User Interfaces

 Android Fragment Classes

 Using Fragments for Your To-Do List

 The Android Widget Toolbox

 Creating New Views

 Modifying Existing Views

 Customizing Your To-Do List

 Creating Compound Controls

 Creating Simple Compound Controls Using Layouts

 Creating Custom Views

 Creating a New Visual Interface

 Handling User Interaction Events

 Supporting Accessibility in Custom Views

 Creating a Compass View Example

 Using Custom Controls

 Introducing Adapters

 Introducing Some Native Adapters

 Customizing the Array Adapter

 Using Adapters to Bind Data to a View

 Customizing the To-Do List Array Adapter


 Introducing Intents

 Using Intents to Launch Activities

 Explicitly Starting New Activities

 Implicit Intents and Late Runtime Binding

 Determining If an Intent Will Resolve

 Returning Results from Activities

 Native Android Actions

 Introducing Linkify

 Native Linkify Link Types

 Creating Custom Link Strings

 Using the Match Filter

 Using the Transform Filter

 Using Intents to Broadcast Events

 Broadcasting Events with Intents

 Listening for Broadcasts with Broadcast Receivers

 Broadcasting Ordered Intents

 Broadcasting Sticky Intents

 Introducing the Local Broadcast Manager

 Introducing Pending Intents

 Creating Intent Filters and Broadcast Receivers

 Using Intent Filters to Service Implicit Intents

 How Android Resolves Intent Filters

 Finding and Using Intents Received Within an Activity

 Passing on Responsibility

 Selecting a Contact Example

 Using Intent Filters for Plug-Ins and Extensibility

 Supplying Anonymous Actions to Applications

 Discovering New Actions from Third-Party Intent Receivers

 Incorporating Anonymous Actions as Menu Items

 Listening for Native Broadcast Intents

 Monitoring Device State Changes Using Broadcast Intents

 Listening for Battery Changes

 Listening for Connectivity Changes

 Listening for Docking Changes

 Managing Manifest Receivers at Run Time


 Downloading and Parsing Internet Resources

 Connecting to an Internet Resource

 Parsing XML Using the XML Pull Parser

 Creating an Earthquake Viewer

 Using the Download Manager

 Downloading Files

 Customizing Download Manager Notifications

 Specifying a Download Location

 Cancelling and Removing Downloads

 Querying the Download Manager

 Using Internet Services

 Connecting to Google App Engine


 Saving Simple Application Data

 Creating and Saving Shared Preferences

 Retrieving Shared Preferences

 Creating a Settings Activity for the Earthquake Viewer

 Introducing the Preference Framework and the

 Preference Activity

 Defining a Preference Screen Layout in XML

 Native Preference Controls

 Using Intents to Import System Preferences into Preference Screens

 Introducing the Preference Fragment

 Defining the Preference Fragment Hierarchy

 Using Preference Headers

 Introducing the Preference Activity

 Backward Compatibility and Preference Screens

 Finding and Using the Shared Preferences Set by Preference Screens

 Introducing On Shared Preference Change Listeners

 Creating a Standard Preference Activity for the Earthquake Viewer

 Persisting the Application Instance State

 Saving Activity State Using Shared Preferences

 Saving and Restoring Activity Instance State

 Using the Lifecycle Handlers

 Saving and Restoring Fragment Instance State

 Using the Lifecycle Handlers

 Including Static Files as Resources

 Working with the File System

 File-Management Tools

 Using Application-Specifi c Folders to Store Files

 Creating Private Application Files

 Using the Application File Cache

 Storing Publicly Readable Files


 Introducing Android Databases

 SQLite Databases

 Content Providers

 Introducing SQLite

 Content Values and Cursors

 Working with SQLite Databases

 Introducing the SQLiteOpenHelper

 Opening and Creating Databases Without the SQLite Open Helper

 Android Database Design Considerations

 Querying a Database

 Extracting Values from a Cursor

 Adding, Updating, and Removing Rows

 Inserting Rows

 Updating Rows

 Deleting Rows

 Creating Content Providers

 Registering Content Providers

 Publishing Your Content Provider’s URI Address

 Creating the Content Provider’s Database

 Implementing Content Provider Queries

 Content Provider Transactions

 Storing Files in a Content Provider

 A Skeleton Content Provider Implementation

 Using Content Providers

 Introducing the Content Resolver

 Querying Content Providers

 Querying for Content Asynchronously Using the Cursor Loader

 Introducing Loaders

 Using the Cursor Loader

 Adding, Deleting, and Updating Content

 Inserting Content

 Deleting Content

 Updating Content

 Accessing Files Stored in Content Providers

 Creating a To-Do List Database and Content Provider

 Adding Search to Your Application

 Making Your Content Provider Searchable

 Creating a Search Activity for Your Application

 Making Your Search Activity the Default Search Provider

 for Your Application

 Performing a Search and Displaying the Results

 Using the Search View Widget

 Supporting Search Suggestions from a Content Provider

 Surfacing Search Results in the Quick Search Box

 Creating a Searchable Earthquake Content Provider

 Creating the Content Provider

 Using the Earthquake Provider

 Searching the Earthquake Provider

 Native Android Content Providers

 Using the Media Store Content Provider & Using the Contacts Contract

Content Provider

 Introducing the Contacts Contract Content Provider

 Reading Contact Details

 Creating and Picking Contacts Using Intents

 Modifying and Augmenting Contact Details Directly

 Using the Calendar Content Provider

 Querying the Calendar

 Creating and Editing Calendar Entries Using Intents

 Modifying Calendar Entries Directly


 Introducing Services

 Creating and Controlling Services

 Creating Services

 Executing a Service and Controlling Its Restart Behavior

 Starting and Stopping Services

 Self-Terminating Services

 Binding Services to Activities

 An Earthquake-Monitoring Service Example

 Creating Foreground Services

 Using Background Threads

 Using AsyncTask to Run Asynchronous Tasks

 Creating New Asynchronous Tasks

 Running Asynchronous Tasks

 Introducing the Intent Service

 Introducing Loaders

 Manual Thread Creation and GUI Thread Synchronization

 Using Alarms

 Creating, Setting, and Canceling Alarms

 Setting Repeating Alarms

 Using Repeating Alarms to Schedule Network Refreshes

 Using the Intent Service to Simplify the Earthquake

 Update Service


 Introducing the Action Bar

 Customizing the Action Bar

 Modifying the Icon and Title Text

 Customizing the Background

 Enabling the Split Action Bar Mode

 Customizing the Action Bar to Control Application Navigation Behavior

 Configuring Action Bar Icon Navigation Behavior

 Using Navigation Tabs

 Using Drop-Down Lists for Navigation

 Using Custom Navigation Views

 Introducing Action Bar Actions

 Adding an Action Bar to the Earthquake Monitor

 Creating and Using Menus and Action Bar Action Items

 Introducing the Android Menu System

 Creating a Menu

 Specifying Action Bar Actions

 Menu Item Options

 Adding Action Views and Action Providers

 Adding Menu Items from Fragments

 Defi ning Menu Hierarchies in XML

 Updating Menu Items Dynamically

 Handling Menu Selections

 Introducing Submenus and Context Menus

 Creating Submenus

 Using Context Menus and Popup Menus

 Refreshing the Earthquake Monitor

 Going Full Screen

 Introducing Dialogs

 Creating a Dialog

 Using the Alert Dialog Class

 Using Specialized Input Dialogs

 Managing and Displaying Dialogs Using Dialog Fragments

 Managing and Displaying Dialogs Using Activity Event Handlers

 Using Activities as Dialogs

 Let’s Make a Toast

 Customizing Toasts

 Using Toasts in Worker Threads

 Introducing Notifications

 Introducing the Notification Manager

 Creating Notifications

 Creating a Notification and Configuring the Status Bar Display

 Using the Default Notification Sounds, Lights, and Vibrations

 Making Sounds

 Vibrating the Device

 Flashing the Lights

 Using the Notification Builder

 Setting and Customizing the Notification Tray UI

 Using the Standard Notification UI

 Creating a Custom Notification UI

 Customizing the Ticker View

 Configuring Ongoing and Insistent Notifications

 Triggering, Updating, and Canceling Notifications

 Adding Notifications and Dialogs to the Earthquake Monitor


 Designing for Every Screen Size and Density

 Resolution Independence

 Using Density-Independent Pixels

 Resource Qualifiers for Pixel Density

 Supporting and Optimizing for Different Screen Sizes

 Creating Scalable Layouts

 Optimizing Layouts for Different Screen Types

 Specifying Supported Screen Sizes

 Creating Scalable Graphics Assets

 Color Drawables

 Shape Drawables

 Gradient Drawables

 NinePatch Drawables

 Creating Optimized, Adaptive, and Dynamic Designs

 Testing, Testing, Testing

 Using Emulator Skins

 Testing for Custom Resolutions and Screen Sizes

 Ensuring Accessibility

 Supporting Navigation Without a Touch Screen

 Providing a Textual Description of Each View

 Introducing Android Text-to-Speech

 Using Speech Recognition

 Using Speech Recognition for Voice Input

 Using Speech Recognition for Search

 Controlling Device Vibration

 Working with Animations

 Tweened View Animations

 Creating Tweened View Animations

 Applying Tweened Animations

 Using Animation Listeners

 Animating Layouts and View Groups

 Creating and Using Frame-by-Frame Animations

 Interpolated Property Animations

 Creating Property Animations

 Creating Property Animation Sets

 Using Animation Listeners

 Enhancing Your Views

 Advanced Canvas Drawing

 What Can You Draw?

 Getting the Most from Your Paint

 Improving Paint Quality with Anti-Aliasing

 Canvas Drawing Best Practice

 Advanced Compass Face Example

 Hardware Acceleration

 Managing Hardware Acceleration Use in Your Applications

 Checking If Hardware Acceleration Is Enabled

 Introducing the Surface View

 When to Use a Surface View

 Creating Surface Views

 Creating D Views with a Surface View

 Creating Interactive Controls

 Using the Touch Screen

 Using the Device Keys, Buttons, and D-Pad

 Using the On Key Listener

 Using the Trackball

 Advanced Drawable Resources

 Composite Drawables

 Transformative Drawables

 Layer Drawables

 State List Drawables

 Level List Drawables

 Copy, Paste, and the Clipboard

 Copying Data to the Clipboard

 Pasting Clipboard Data


 Using Sensors and the Sensor Manager

 Supported Android Sensors

 Introducing Virtual Sensors

 Finding Sensors

 Monitoring Sensors

 Interpreting Sensor Values

 Monitoring a Device’s Movement and Orientation

 Determining the Natural Orientation of a Device

 Introducing Accelerometers

 Detecting Acceleration Changes

 Creating a Gravitational Force Meter

 Determining a Device’s Orientation

 Understanding the Standard Reference Frame

 Calculating Orientation Using the Accelerometer and

 Magnetic Field Sensors

 Remapping the Orientation Reference Frame

 Determining Orientation Using the Deprecated Orientation Sensor

 Creating a Compass and Artifi cial Horizon

 Introducing the Gyroscope Sensor

 Introducing the Environmental Sensors

 Using the Barometer Sensor

 Creating a Weather Station


 Using Location-Based Services

 Using the Emulator with Location-Based Services

 Updating Locations in Emulator Location Providers

 Configuring the Emulator to Test Location-Based Services

 Selecting a Location Provider

 Finding Location Providers

 Finding Location Providers by Specifying Criteria

 Determining Location Provider Capabilities

 Finding Your Current Location

 Location Privacy

 Finding the Last Known Location

 Where Am I Example

 Refreshing the Current Location

 Tracking Your Location in Where Am I

 Requesting a Single Location Update

 Best Practice for Location Updates

 Monitoring Location Provider Status and Availability

 Using Proximity Alerts

 Using the Geocoder

 Reverse Geocoding

 Forward Geo-coding

 Geo-coding Where Am I

 Creating Map-Based Activities

 Introducing Map View and Map Activity

 Getting Your Maps API Key

 Getting Your Development/Debugging MD Fingerprint

 Getting your Production/Release MD Fingerprint

 Creating a Map-Based Activity

 Maps and Fragments

 Configuring and Using Map Views

 Using the Map Controller

 Mapping Where Am I

 Creating and Using Overlays

 Creating New Overlays

 Introducing Projections

 Drawing on the Overlay Canvas

 Handling Map Tap Events

 Adding and Removing Overlays

 Annotating Where Am I

 Introducing My Location Overlay

 Introducing Itemized Overlays and Overlay Items

 Pinning Views to the Map and Map Positions

 Mapping Earthquakes Example


 Introducing Home Screen Widgets

 Creating App Widgets

 Creating the Widget XML Layout Resource

 Widget Design Guidelines

 Supported Widget Views and Layouts

 Defi ning Your Widget Settings

 Creating Your Widget Intent Receiver and Adding It to the

 Application Manifest

 Introducing the App Widget Manager and Remote Views

 Creating and Manipulating Remote Views

 Applying Remote Views to Running App Widgets

 Using Remote Views to Add Widget Interactivity

 Refreshing Your Widgets

 Using the Minimum Update Rate

 Using Intents

 Using Alarms

 Creating and Using a Widget Confi guration Activity

 Creating an Earthquake Widget

 Introducing Collection View Widgets

 Creating Collection View Widget Layouts

 Creating the Remote Views Service

 Creating a Remote Views Factory

 Populating Collection View Widgets Using a Remote Views Service

 Adding Interactivity to the Items Within a Collection View Widget

 Binding Collection View Widgets to Content Providers

 Refreshing Your Collection View Widgets

 Creating an Earthquake Collection View Widget

 Introducing Live Folders

 Creating Live Folders

 The Live Folder Content Provider

 The Live Folder Activity

 Creating an Earthquake Live Folder

 Surfacing Application Search Results Using the Quick Search Box

 Surfacing Search Results to the Quick Search Box

 Adding the Earthquake Example Search Results to the Quick Search Box

 Creating Live Wallpaper

 Creating a Live Wallpaper

 Definition Resource Creating a Wallpaper Service

Creating a Wallpaper Service Engine


 Playing Audio and Video

 Introducing the Media Player

 Preparing Audio for Playback

 Initializing Audio Content for Playback

 Preparing Video for Playback

 Playing Video Using the Video View

 Creating a Surface for Video Playback

 Controlling Media Player Playback

 Managing Media Playback Output

 Responding to the Volume Controls

 Responding to the Media Playback Controls

 Requesting and Managing Audio Focus

 Pausing Playback When the Output Changes

 Introducing the Remote Control Client

 Manipulating Raw Audio

 Recording Sound with Audio Record

 Playing Sound with Audio Track

 Creating a Sound Pool

 Using Audio Eff ects

 Using the Camera for Taking Pictures

 Using Intents to Take Pictures

 Controlling the Camera Directly

 Camera Properties

 Camera Settings and Image Parameters

 Controlling Auto Focus, Focus Areas, and Metering Areas

 Using the Camera Preview

 Detecting Faces and Facial Features

 Taking a Picture

 Reading and Writing JPEG EXIF Image Details

 Recording Video

 Using Intents to Record Video

 Using the Media Recorder to Record Video

 Configuring the Video Recorder

 Previewing the Video Stream

 Controlling the Recording

 Creating a Time-Lapse Video

 Using Media Eff ects

 Adding Media to the Media Store

 Inserting Media Using the Media Scanner

 Inserting Media Manually


 Using Bluetooth

 Managing the Local Bluetooth Device Adapter

 Being Discoverable and Remote Device Discovery

 Managing Device Discoverability

 Discovering Remote Devices

 Bluetooth Communications

 Opening a Bluetooth Server Socket Listener

 Selecting Remote Bluetooth Devices for Communications

 Opening a Client Bluetooth Socket Connection

 Transmitting Data Using Bluetooth Sockets

 Managing Network and Internet Connectivity

 Introducing the Connectivity Manager

 Supporting User Preferences for Background Data Transfers

 Finding and Monitoring Network Connectivity

 Managing Wi-Fi

 Monitoring Wi-Fi Connectivity

 Monitoring Active Wi-Fi Connection Details

 Scanning for Hotspots

 Managing Wi-Fi Configurations

 Creating Wi-Fi Network Configurations

 Transferring Data Using Wi-Fi Direct

 Initializing the Wi-Fi Direct Framework

 Enabling Wi-Fi Direct and Monitoring Its Status

 Discovering Peers

 Connecting with Peers

 Transferring Data Between Peers

 Using the Foreground Dispatch System

 Introducing Android Beam

 Creating Android Beam Messages

 Assigning the Android Beam Payload

 Receiving Android Beam Messages


 Hardware Support for Telephone

 Marking Telephony as a Required Hardware Feature

 Checking for Telephony Hardware

 Using Telephony

 Initiating Phone Calls