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...)
- 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 SystemsWindows 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 requiredOn Ubuntu Linux, version 8.04 or later is required64-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 EclipseStep2: Download and install the Java Runtime Environment (JRE)Step3: Download and install the Java Development Kit (JDK)Step4: Downloading the Android Developer Tools (ADT) BundleStep5: Installing the ADT Bundle
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 Stackiii. The Dalvik Virtual Machineiv. Android Application Architecturev. Android Libraries
Getting Started
- Developing for Android
i. Downloading and installing the SDKii. Developing with Eclipseiii. Using the Eclipse Plug-in
- Creating your first Android Application
i. Starting a New Android Projectii. Creating a Launch Configurationiii. Running and Debugging Your Android Applicationsiv. Understanding Hello World
- Types of Android Applications
i. Foreground Applicationsii. Background Services and Intent Receiversiii. Intermittent Applicationsiv. Widgets
- Design Considerations while Developing for Mobile Devices
i. Hardware-Imposed Design Considerationsii. Considering the Users’ Environmentiii. Developing Secure Applicationsiv. 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 Resourcesi.Creating Simple Valuesii.Styles and Themesiii.Drawablesiv.Layoutsv.Animationsvi.Menusb.Using Resourcesi.Using Resources in Codeii.Referencing Resources within Resourcesiii.Using System Resourcesiv.Referring to Styles in the Current Themec.Creating Resources for Different Languages and Hardwared.Runtime Configuration Changes
- Introducing the Android Application Class
a.Extending and Using the Application Classb.Overriding the Application Life Cycle Events
- A Closer Look at Android Activities
a.Creating an Activityb.The Activity Life Cyclei.Activity Stacksii.Activity Statesiii. Monitoring State Changesc.Understanding Activity Lifetimesd.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 Layoutsb.Optimizing Layouts
- Creating New Views
a.Modifying Existing Viewsi.Customizing Your To-Do Listb.Creating Compound Controlsc.Creating Custom Viewsi.Creating a New Visual Interface
ii.Handling User Interaction Events
iii.Creating a Compass View Exampled.Using Custom Controls - Drawable Resources
a.Color Drawable, Shape Drawable, Gradient Drawableb.Composite Drawablesi.Transformative, Layer, State List, Level List Drawablesc.NinePatch Drawable
- Resolution and Density Independence
a.The Resource Framework and Resolution Independencei.Resource Qualifiers for Screen Size and Pixel Densityii.Specifying Supported Screen Sizesb.Best Practices for Resolution Independencei.Relative Layouts and Density-Independent Pixelsii.Using Scalable Graphics Assetsiii.Provide Optimized Resources for Different Screensc.Testingi.Emulator Skinsii.Testing for Custom Resolutions and Screen Sizes
- Creating and Using Menus
a. Introducing the Android Menu Systemb. Defining an Activity Menuc. Menu Item Optionsd. Dynamically Updating Menu Itemse. Handling Menu Selectionsf. Submenus and Context Menusg. Creating Submenush. Using Context Menusi. Defining Menus in XML
Intents, Broadcast Receivers, Adapters and The Intrnet
- Introducing Intents
a.Using Intents to Launch Activitiesi.Explicitly Starting New Activitiesii.Implicit Intents and Late Runtime Bindingiii.Returning Results from Activitiesiv.Native Android Actionsb.Using Intent Filters to Service Implicit Intentsi.How Android Resolves Intent Filtersii.Finding and Using the Launch Intent Within an Activityiii.Passing on Responsibilityiv.Select a Contact Examplec.Using Intent Filters for Plug-Ins and Extensibilityi.Supplying Anonymous Actions to Applicationsiii.Incorporating Anonymous Actions in Your Activity’s Menud.Introducing Linkifyi.The Native Linkify Link Typesii.Creating Custom Link Stringsiii.Using the Match Filteriv. Using the Transform Filtere.Using Intents to Broadcast Eventsi.Broadcasting Events with Intentsii. Listening for Broadcasts with Broadcast Receiversiii.Broadcasting Sticky and Ordered Intentsiv.Native Android Broadcast Actions
- Introducing Pending Intents
- Introducing Adapters
a.Introducing Some Native Adaptersb.Customizing the Array Adapterc.Using Adapters for Data Bindingd.Customizing the To-Do List Array Adaptere.Using the Simple Cursor Adapter
- Using Internet Resources
a.Connecting to an Internet Resourceb. Using Internet Resources
- Introducing Dialogs
a.Introducing the Dialog Classesi.The Alert Dialog Classii.Specialist Input Dialogsb.Using Activities as Dialogsc.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 XMLi.Native Preference Controlsii.Using Intents to Import System Preference Screensb.Introducing the Preference Activityc.Finding and Using Preference Screen Shared Preferencesd.Introducing Shared Preference Change Listeners
- Creating a Standard Preference Activity for the Earthquake Viewer
- Saving Activity State
a.Saving and Restoring Instance Stateb.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 Databasesb.Introducing Content Providers
- Introducing SQLite
- Cursors and Content Values
- Working with SQLite Databases
a.Introducing the SQLiteOpenHelperb.Opening and Creating Databases without SQLiteHelperc.Android Database Design Considerationsd.Querying a Databasee.Extracting Results from a Cursorf. Adding, Updating, and Removing Rowsg.Saving Your To-Do List
- Creating a New Content Provider
a.Exposing Access to the Data Sourceb.Registering Your Provider
- Using Content Providers
a.Introducing Content Resolversb.Querying for Contentc.Adding, Updating, and Deleting Contentd.Accessing Files in Content Providers
- Creating and Using an Earthquake Content Provider
a.Creating the Content Providerb.Using the Provider
- Native Android Content Providers
a.Using the Media Store Providerb.Using the Contacts Provideri.Introducing the Contacts Contract Content Providerii.Reading Contact Detailsiii.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 Providersb.Finding Location Providers Using Criteria
- Finding Your Location
a.‘Where Am I?’ Exampleb.Tracking Movementc.Updating Your Location in ‘Where Am I?’
- Using Proximity Alerts
- Using the Geocoder
a.Reverse Geocodingb.Forward Geocodingc.Geocoding ‘Where Am I?’
- Creating Map-Based Activities
a.Introducing Map View and Map Activityb.Getting Your Maps API Keyi.Getting Your Development/Debugging MD5 Fingerprintii.Getting your Production/Release MD5 Fingerprintc.Creating a Map-Based Activityd.Configuring and Using Map Viewse.Using the Map Controllerf.Mapping ‘Where Am I?’g.Creating and Using Overlaysi.Creating New Overlaysii.Introducing Projectionsiii.Drawing on the Overlay Canvasiv.Handling Map Tap Eventsv.Adding and Removing Overlaysvi.Annotating ‘Where Am I?’h.Introducing My Location Overlayi.Introducing Itemized Overlays and Overlay Itemsj.Pinning Views to the Map and Map Positions
- Mapping Earthquakes Example
Working in the Background
- Introducing Services
a.Creating and Controlling Servicesi.Creating a Serviceii.Registering a Service in the Manifestiii.Self-Terminating a Serviceiv.Starting, Controlling, and Interacting with a Servicev.An Earthquake Monitoring Service Exampleb.Binding Activities to Servicesc.Prioritizing Background Services
- Using Background Threads
a.Using AsyncTask to Run Asynchronous Tasksi.Creating a New Asynchronous Taskii.Running an Asynchronous Taskb.Moving the Earthquake Service to a Background Thread Using AsyncTaskc.Manual Thread Creation and GUI Thread Synchronizationi.Creating a New Threadii.Using the Handler for Performing GUI Operations
- Let’s Make a Toast
a.Customizing Toastsb.Using Toasts in Worker Threads
- Introducing Notifications
a.Introducing the Notification Managerb.Creating Notificationsi.Creating a Notification and Configuring the Status Bar Iconii.Configuring the Extended Status Notification Displayc.Triggering Notificationsd.Adding Notifications and Toasts to the Earthquake Monitore.Advanced Notification Techniquesi.Using the Defaultsii.Making Soundsiii.Vibrating the Phoneiv.Flashing the Lightsf.Ongoing and Insistent Notifications
- Using Alarms
a.Setting Repeating Alarmsb.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 Layoutsb.Defining Your Widget Settingsc.Creating Your Widget Intent Receiver and Adding It to the Application Manifestd.Introducing Remote Views and the App Widget Manageri.Creating Remote Views and Using the App Widget Manager to Apply Themii.Using a Remote View within the App Widget Provider’s onUpdate Handleriii.Using Remote Views to Modify UIiv.Making Your Widgets Interactivef. Refreshing Your Widgetsi.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 Foldersi.Live Folder Content Providersii.Live Folder Activityb.Creating an Earthquake Live Folder
- Adding Search to Your Applications and the Quick Search Box
a.Adding Search to Your Applicationi.Creating a Search Activityii.Responding to Search Queries from a Content Providerb.Surfacing Search Results to the Quick Search Boxc. Adding Search to the Earthquake Example
- Creating Live Wallpaper
a.Creating a Live Wallpaper Definition Resourceb.Creating a Wallpaper Servicec.Creating a Wallpaper Service Engine
Audio, Video and Using the Camera
- Playing Audio and Video
a.Introducing the Media Playerb.Preparing Audio for Playbacki.Packaging Audio as an Application Resourceii.Initializing Audio Content for Playbackc.Preparing for Video Playbacki.Playing Video Using the Video Viewii.Setting up a Surface for Video Playbackiii.Initializing Video Content for Playbackd.Controlling Playbacke.Managing Media Playback Output
- Recording Audio and Video
a.Using Intents to Record Videob.Using the Media Recorderi.Configuring and Controlling Video Recordingii.Previewing Video Recording
- Using the Camera and Taking Pictures
a.Using Intents to Take Picturesb.Controlling the Camera and Taking Picturesi.Controlling and Monitoring Camera Settings and Image Optionsii.Monitoring Auto Focusiii.Using the Camera Previewiv.Taking a Picturec.Reading and Writing JPEG EXIF Image Details
- Adding New Media to the Media Store
a.Using the Media Scannerb.Inserting Media into the Media Store
- Raw Audio Manipulation
a.Recording Sound with Audio Recordb.Playing Sound with Audio Track
- Speech Recognition
Telephony and SMS
- Telephony
a.Launching the Dialer to Initiate Phone Callsb.Replacing the Native Dialerc.Accessing Phone and Network Properties and Statusi.Reading Phone Device Detailsii.Reading Data Connection and Transfer StateiiiReading Network Detailsiv.Reading SIM Detailsd.Monitoring Changes in Phone State, Phone Activity, and Data Connectionsi.Monitoring Incoming Phone Callsii.Tracking Cell Location Changesiii.Tracking Service Changesiv.Monitoring Data Connectivity and Activity
- Introducing SMS and MMS
a.Using SMS and MMS in Your Applicationb.Sending SMS and MMS from Your Application Using Intents and the Native Clientc.Sending SMS Messages Manuallyi.Sending Text Messagesii.Tracking and Confirming SMS Message Deliveryiii.Conforming to the Maximum SMS Message Sizeiv.Sending Data Messagesd.Listening for Incoming SMS Messagesi.Simulating Incoming SMS Messages in the Emulatorii.Handling Data SMS Messagese.Emergency Responder SMS Examplef.Automating the Emergency Responder
Bluetooth, Networks and WI-FI
- Using Bluetooth
a.Accessing the Local Bluetooth Device Adapterb.Managing Bluetooth Properties and Statec.Being Discoverable and Remote Device Discoveryi.Managing Device Discoverabilityii.Discovering Remote Devicesd.Bluetooth Communicationsi.Opening a Bluetooth Server Socket Listenerii.Selecting Remote Bluetooth Devices for Communicationsiii.Opening a Client Bluetooth Socket Connectioniv.Transmitting Data Using Bluetooth Socketse.Bluetooth Data Transfer Example
- Managing Network Connectivity
a.Introducing the Connectivity Managerb.Reading User Preferences for Background Data Transferc.Monitoring Network Detailsd.Finding and Configuring Network Preferences and Controlling Hardware Radiose.Monitoring Network Connectivity
- Managing Your Wi-Fi
a.Monitoring Wi-Fi Connectivityb.Monitoring Active Connection Detailsc.Scanning for Hotspotsd.Managing Wi-Fi Configurationse.Creating Wi-Fi Network Configurations
Sensors
- Using Sensors and the Sensor Manager
a.Introducing Sensorsi.Supported Android Sensorsii.Finding Sensorsiii.Using Sensors
- Interpreting Sensor Values
- Using the Compass, Accelerometer, and Orientation Sensors
a.Introducing Accelerometersb.Detecting Acceleration Changesc.Creating a G-Forceometerd.Determining Your Orientationi.Determining Orientation Using the Orientation Sensorii.Calculating Orientation Using the Accelerometer and Magnetic Field Sensorsiii.Remapping the Orientation Reference Framee.Creating a Compass and Artificial Horizon
Advanced Android Development
- Paranoid Android
a.Linux Kernel Securityb.Introducing Permissionsc. Declaring and Enforcing Permissionsd.Enforcing Permissions for Broadcast Intents
- Using Wake Locks
- Introducing Android Text to Speech
- Using AIDL to Support IPC for Services
a.Implementing an AIDL Interfaceb.Passing Class Objects as Parcelablesi.Creating the AIDL Service Definitionc.Implementing and Exposing the IPC Interface
- Using Internet Services
- Building Rich User Interfaces
a.Working with Animationsi.Introducing Tweened Animationsii.Creating Tweened Animationsiii.Applying Tweened Animationsiv.Using Animation Listenersv.Animated Sliding User Interface Examplevi.Animating Layouts and View Groupsvii.Creating and Using Frame-by-Frame Animationsb.Advanced Canvas Drawingi.What Can You Draw?ii.Getting the Most from Your Paintiii.Improving Paint Quality with Anti-Aliasingiv.Canvas Drawing Best Practicev.Advanced Compass Face Examplevi.Bringing Map Overlays to Lifec.Introducing the Surface Viewi.When Should You Use a Surface View?ii.Creating a New Surface Viewiii.Creating 3D Controls with a Surface Viewd.Creating Interactive Controlsi.Using the Touch Screenii.Using the Device Keys, Buttons, and D-Padiii.Using the On Key Listeneriv.Using the Trackball