Home > services > computer

Course (10-1) Android Application Development

zoom

pre 1 of 1 next

Location: New York - Map

Date posted: June 21, 2013

Price: Please contact

Ad ID: 91872

Views: 19

Reply by email

close X

1. The Big Picture
- 1.1. Benefits and Drawbacks of Smartphone Programming
- 1.2. What Androids Are Made Of
- 1.3. Stuff at Your Disposal
2. How to Get Started
- 2.1. Step 1: Set Up Java
- 2.2. Install the JDK
- 2.3. Learn Java
- 2.4. Step 2: Install the Android SDK
- 2.5. Install the Base Tools
- 2.6. Install the SDKs and Add-ons
- 2.7. Step 3: Install the ADT for Eclipse
- 2.8. Step 4: Install Apache Ant
- 2.9. Step 5: Set Up the Emulator
- 2.6. Step 6: Set Up the Device
  - 2.6.1. Windows
  - 2.6.2. Mac OS X and Linux
3. Your First Android Project
- 3.1. Step 1: Create the New Project
  - 3.1.1. Eclipse
  - 3.1.2. Command Line
- 3.2. Step 2: Build, Install, and Run the Application in Your Emulator or Device
  - 3.2.1. Eclipse
  - 3.2.2. Command Line
4. Examining Your First Project
- 4.1. Project Structure
- 4.2. Root Contents
- 4.3. The Sweat Off Your Brow
- 4.4. And Now, the Rest of the Story
- 4.5. What You Get Out of It
- 4.6. Inside Your Manifest
- 4.7. In the Beginning, There Was the Root, and It Was Good
- 4.8. An Application for Your Application
5. A Bit About Eclipse
- 5.1. What the ADT Gives You
- 5.2. Coping with Eclipse
- 5.3. How to Import a Non-Eclipse Project
- 5.4. How to Get to DDMS
- 5.5. How to Create an Emulator
- 5.6. How to Run a Project
- 5.7. How Not to Run Your Project
- 5.8. Alternative IDEs
6. Enhancing Your First Project
- 6.1. Supporting Multiple Screen Sizes
- 6.2. Specifying Versions
7. Rewriting Your First Project
- 7.1. The Activity
- 7.2. Dissecting the Activity
- 7.3. Building and Running the Activity
8. Using XML-Based Layouts
- 8.1. What Is an XML-Based Layout?
- 8.2. Why Use XML-Based Layouts?
- 8.3. OK, So What Does It Look Like?
- 8.4. What’s with the @ Signs?
- 8.5. And How Do We Attach These to the Java?
- 8.6. The Rest of the Story
9. Employing Basic Widgets
- 9.1. Assigning Labels
- 9.2. Button, Button, Who’s Got the Button?
- 9.3. Fleeting Images
- 9.4. Fields of Green…or Other Colors
- 9.5. Just Another Box to Check
- 9.6. Throw the Switch, Igor
- 9.7. Turn Up the Radio
- 9.8. It’s Quite a View
- 9.9. Padding
- 9.10. Other Useful Properties
- 9.11. Useful Methods
- 9.12. Colors
10. Working with Containers
- 10.1. Thinking Linearly
- 10.2. LinearLayout Concepts and Properties
  - 10.2.1. Orientation
  - 10.2.2. Fill Model
  - 10.2.3. Weight
  - 10.2.4. Gravity
  - 10.2.5. Margins
- 10.3. LinearLayout Example
- 10.4. The Box Model
- 10.5. All Things Are Relative
- 10.6. RelativeLayout Concepts and Properties
- 10.7. Positions Relative to Container
  - 10.7.1. Relative Notation in Properties
  - 10.7.2. Positions Relative to Other Widgets
- 10.8. Order of Evaluation
- 10.9. RelativeLayout Example
- 10.10. Overlap
- 10.11. Tabula Rasa
- 10.12. TableLayout Concepts and Properties
  - 10.12.1. Putting Cells in Rows
  - 10.12.2. Non-Row Children of TableLayout
  - 10.12.3. Stretch, Shrink, and Collapse
  - 10.12.4. TableLayout Example
- 10.13. Scrollwork
- 10.14. Take Them to the Grid
11. The Input Method Framework
- 11.1. Keyboards, Hard and Soft
- 11.2. Tell Android Where It Can Go
- 11.3. Fitting In
- 11.4. Jane, Stop This Crazy Thing!
12. Using Selection Widgets
- 12.1. Adapting to the Circumstances
- 12.2. Lists of Naughty and Nice
- 12.3. Selection Modes
- 12.4. Spin Control
- 12.5. Grid Your Lions (or Something Like That...)
- 12.6. Fields: Now with 35% Less Typing!
- 12.7. Galleries, Give or Take the Art
13. Getting Fancy with Lists
- 13.1. Getting to First Base
- 13.2. A Dynamic Presentation
- 13.3. Inflating Rows Ourselves
- 13.4. A Sidebar About Inflation
- 13.5. And Now, Back to Our Story
- 13.6. Better. Stronger. Faster.
- 13.7. Using convertView
- 13.8. Using the Holder Pattern
- 13.9. Interactive Rows
14. Still More Widgets and Containers
- 14.1. Pick and Choose
- 14.2. Time Keeps Flowing Like a River
- 14.3. Seeking Resolution
- 14.4. Putting It on My Tab
- 14.5. The Pieces
- 14.6. Wiring It Together
- 14.7. Adding Them Up
- 14.8. Flipping Them Off
- 14.9. Getting in Somebody’s Drawer
- 14.10. Other Good Stuff
15. Embedding the WebKit Browser
- 15.1. A Browser, Writ Small
- 15.2. Loading It Up
- 15.3. Navigating the Waters
- 15.4. Entertaining the Client
- 15.5. Settings, Preferences, and Options (Oh, My!)
16. Applying Menus
- 16.1. Flavors of Menu
- 16.2. Menus of Options
- 16.3. Menus in Context
- 16.4. Taking a Peek
- 16.5. Yet More Inflation
- 16.6. Menu XML Structure
- 16.7. Menu Options and XML
- 16.8. Inflating the Menu
- 16.9. When Giant Menus Walk the Earth
17. Showing Pop-Up Messages
- 17.1. Raising Toasts
- 17.2. Alert! Alert!
- 17.3. Checking Them Out
18. Handling Activity Lifecycle Events
- 18.1. Schrödinger’s Activity
- 18.2. Life, Death, and Your Activity
- 18.3. onCreate() and onDestroy()
- 18.4. onStart(), onRestart(), and onStop()
- 18.5. onPause() and onResume()
- 18.6. The Grace of State
19. Handling Rotation
- 19.1. A Philosophy of Destruction
- 19.2. It’s All the Same, Just Different
- 19.3. Picking and Viewing a Contact
- 19.4. Saving Your State
- 19.5. Now with More Savings!
- 19.6. DIY Rotation
- 19.7. Forcing the Issue
- 19.8. Making Sense of It All
20. Dealing with Threads
- 20.1. The Main Application Thread
- 20.2. Making Progress with ProgressBars
- 20.3. Getting Through the Handlers
- 20.4. Messages
- 20.5. Runnables
- 20.6. Where Oh Where Has My UI Thread Gone?
- 20.7. Asyncing Feeling
- 20.8. The Theory
- 20.9. AsyncTask, Generics, and Varargs
- 20.10. The Stages of AsyncTask
- 20.11. A Sample Task
  - 20.11.1. The AddStringTask Declaration
  - 20.11.2. The doInBackground() Method
  - 20.11.3. The onProgressUpdate() Method
  - 20.11.4. The onPostExecute() Method
  - 20.11.5. The Activity
  - 20.11.6. The Results
- 20.12. Threads and Rotation
- 20.13. Manual Activity Association
- 20.14. Flow of Events
- 20.15. Why This Works
- 20.16. And Now, the Caveats
21. Creating Intent Filters
- 21.1. What’s Your Intent?
- 21.2. Pieces of Intents
- 21.3. Intent Routing
- 21.4. Stating Your Intent(ions)
- 21.5. Narrow Receivers
- 21.6. Intents for Every Occasion
- 21.7. The Pause Caveat
22. Launching Activities and Subactivities
- 22.1. Peers and Subs
- 22.2. Start ’Em Up
- 22.3. Make an Intent
- 22.4. Make the Call
- 22.5. Tabbed Browsing, Sort Of
23. Working with Resources
- 23.1. The Resource Lineup
- 23.2. String Theory
- 23.3. Plain Strings
- 23.4. String Formats
- 23.5. Styled Text
- 23.6. Styled Text and Formats
- 23.7. Got the Picture?
- 23.8. XML: The Resource Way
- 23.9. Miscellaneous Values
- 23.10. Dimensions
- 23.11. Colors
- 23.12. Arrays
- 23.13. Different Strokes for Different Folks
- 23.14. RTL Languages: Going Both Ways
24. Defining and Using Styles
- 24.1. Styles: DIY DRY
- 24.2. Elements of Style
- 24.3. Where to Apply a Style
- 24.4. The Available Attributes
- 24.5. Inheriting a Style
- 24.6. The Possible Values
- 24.7. Themes: A Style by Any Other Name...
25. Handling Multiple Screen Sizes
- 25.1. Taking the Default
- 25.2. Whole in One
- 25.3. Think About Rules, Not Positions
- 25.4. Consider Physical Dimensions
- 25.5. Avoid “Real” Pixels
- 25.6. Choose Scalable Drawables
- 25.7. Tailor-Made, Just for You (and You, and You, and...)
- 25.8. Adding the <supports-screens> Element
- 25.9. Resources and Resource Sets
- 25.10. Default Scaling
- 25.11. Density-Based Sets
- 25.12. Size-Based Sets
- 25.13. Version-Based Sets
- 25.14. Finding Your Size
- 25.15. Ain’t Nothing Like the Real Thing
- 25.16. Density Differs
- 25.17. Adjusting the Density
- 25.18. Ruthlessly Exploiting the Situation
- 25.19. Replace Menus with Buttons
- 25.20. Replace Tabs with a Simple Activity
- 25.21. Consolidate Multiple Activities
- 25.22. Example: EU4You
- 25.23. The First Cut
- 25.24. Fixing the Fonts
- 25.25. Fixing the Icons
- 25.26. Using the Space
- 25.27. What If It Is Not a Browser?
26. Focusing on Tablets and Larger UIs
- 26.1. Why the Drive to Tablets?
- 26.2. What the User Sees
- 26.3. Dealing with the Rest of the Devices
27. Using the Action Bar
- 27.1. Enabling the Action Bar
- 27.2. Promoting Menu Items to the Action Bar
- 27.3. Responding to the Logo
- 27.4. Adding Custom Views to the Action Bar
- 27.5. Defining the Layout
- 27.6. Putting the Layout in the Menu
- 27.7. Getting Control of User Input
- 27.8. Don’t Forget the Phones!
28. Fragments
- 28.1. Introducing Fragments
- 28.2. The Problem Addressed by Fragments
- 28.3. The Fragments Solution
- 28.4. The Android Compatibility Library
- 28.5. Creating Fragment Classes
- 28.6. General Fragments
- 28.7. ListFragment
- 28.8. Persistent Highlight
- 28.9. Other Fragment Base Classes
- 28.10. Fragments, Layouts, Activities, and Multiple Screen Sizes
- 28.11. EU4You
- 28.12. The Layout
- 28.13. The Other Layout
- 28.14. The Listener Interface
- 28.15. The Activity
- 28.16. DetailsActivity
- 28.17. The Layout
- 28.18. The Activity
- 28.19. Fragments and Configuration Changes
- 28.20. Designing for Fragments
29. Handling Platform Changes
- 29.1. Things That Make You Go Boom
- 29.2. View Hierarchy
- 29.2. Changing Resources
- 29.3. Handling API Changes
- 29.4. Minimum, Maximum, Target, and Build Versions
- 29.5. Targets vs. SDK Versions vs. OS Versions
- 29.6. Minimum SDK Version
- 29.7. Target SDK Version
- 29.8. Maximum SDK Version
- 29.9. Detecting the Version
- 29.10. Wrapping the API
- 29.11. Detecting Classes
- 29.12. Reflection
- 29.13. Conditional Class Loading
- 29.14. Patterns for Ice Cream Sandwich and Honeycomb
- 29.15. The Action Bar
- 29.16. Checking the API Level
- 29.17. Isolating the Ice Cream Sandwich/Honeycomb Code
- 29.18. Writing Tablet-Only Apps
30. Accessing Files
- 30.1. You and the Horse You Rode in On
- 30.2. Readin’ ’n Writin’
- 30.3. External Storage: Giant Economy-Size Space
- 30.4. Where to Write
- 30.5. When to Write
- 30.6. StrictMode: Avoiding Janky Code
- 30.7. Setting Up StrictMode
- 30.8. Seeing StrictMode in Action
- 30.9. Development Only, Please!
- 30.10. Conditionally Being Strict
- 30.11. Linux File Systems: You Sync, You Win
31.Using Preferences
- 31.1. Getting What You Want
- 31.2. Stating Your Preference
- 31.3. Introducing PreferenceFragment and PreferenceActivity
- 31.4. Preferences via Fragments
- 31.5. Preferences the New and Improved Way
- 31.6. Preference Headers
- 31.7. PreferenceFragment and StockPreferenceFragment
- 31.8. Avoiding Nested PreferenceScreen Elements
- 31.9. Intents for Headers or Preferences
- 31.10. Adding Backward Compatibility
- 31.11. The Older Model of Preference Handling
- 31.12. Letting Users Have Their Say
- 31.13. Adding a Wee Bit o’ Structure
- 31.14. The Kind of Pop-Ups You Like
32. Managing and Accessing Local Databases
- 32.1. A Quick SQLite Primer
- 32.2. Start at the Beginning
- 32.3. Setting the Table
- 32.4. Makin’ Data
- 32.5. What Goes Around, Comes Around
- 32.6. Raw Queries
- 32.7. Regular Queries
- 32.8. Using Cursors
- 32.9. Custom CursorAdapters
- 32.10. Making Your Own Cursors
- 32.11. SQLite and Android Versions
- 32.12. Flash: Sounds Faster Than It Is
- 32.13. Ship Ahoy!
- 32.14. Data, Data, Everywhere
33. Leveraging Java Libraries
- 33.1. Ants and JARs
- 33.2. The Outer Limits
- 33.3. Following the Script
- 33.4. Reviewing the Script
34. Communicating via the Internet
- 34.1. REST and Relaxation
- 34.2. HTTP Operations via Apache HttpClient
- 34.3. Parsing Responses
- 34.4. Stuff to Consider
- 34.5. AndroidHttpClient
- 34.6. Leveraging Internet-Aware Android Components
- 34.7. Downloading Files
- 34.8. The Permissions
- 34.9. The Layout
- 34.10. Requesting the Download
- 34.11. Keeping Track of Download Status
- 34.12. What the User Sees
- 34.13. Limitations
- 34.14. Continuing Our Escape from Janky Code
35. Services: The Theory
- 35.1. Why Services?
- 35.2. Setting Up a Service
- 35.3. Service Class
- 35.4. Lifecycle Methods
- 35.5. Manifest Entry
- 35.6. Communicating to Services
- 35.7. Sending Commands with startService()
- 35.8. Binding with bindService()
- 35.9. Communicating from Services
- 35.10. Callback/Listener Objects
- 35.11. Broadcast Intents
- 35.12. Pending Results
- 35.13. Messenger
- 35.14. Notifications
36. Basic Service Patterns
- 36.1. The Downloader
- 36.2. The Design
- 36.3. The Service Implementation
- 36.4. Using the Service
- 36.5. The Music Player
- 36.6. The Design
- 36.7. The Service Implementation
- 36.8. Using the Service
- 36.9. The Web Service Interface
- 36.10. The Design
- 36.11. The Rotation Challenge
- 36.12. The Service Implementation
- 36.13. The Forecast
- 36.14. The Interface
- 36.15. The Binder
- 36.16. The Service
- 36.17. Using the Service
- 36.18. Managing the State
- 36.19. Time to Unbind
37. Alerting Users via Notifications
- 37.1. Notification Configuration
- 37.2. Hardware Notifications
- 37.3. Icons
- 37.4. Notifications in Action
- 37.5. Staying in the Foreground
- 37.6. FakePlayer, Redux
- 37.7. Notifications in Ice Cream Sandwich and Honeycomb
38. Requesting and Requiring Permissions
- 38.1. Mother, May I?
- 38.2. Halt! Who Goes There?
- 38.3. Enforcing Permissions via the Manifest
- 38.4. Enforcing Permissions Elsewhere
- 38.5. May I See Your Documents?
- 38.6. New Permissions in Old Applications
- 38.7. Permissions: Up Front or Not at All
39. Accessing Location-Based Services
- 39.1. Location Providers: They Know Where You’re Hiding
- 39.2. Finding Yourself
- 39.3. On the Move
- 39.4. Are We There Yet? Are We There Yet?
- 39.5. Testing... Testing...
40. Mapping with MapView and MapActivity
- 40.1. Terms, Not of Endearment
- 40.2. Piling On
- 40.3. The Key to It All
- 40.4. The Bare Bones
- 40.5. Optional Maps
- 40.6. Exercising Your Control
- 40.7. Zoom
- 40.8. Center
- 40.9. Layers Upon Layers
- 40.10. Overlay Classes
- 40.11. Drawing the ItemizedOverlay
- 40.12. Handling Screen Taps
- 40.13. My, Myself, and MyLocationOverlay
- 40.14. Rugged Terrain
- 40.15. Maps and Fragments
- 40.16. Limit Yourself to the Latest AndroidVersions
- 40.17. Use onCreateView() and onActivityCreated()
- 40.18. Host the Fragment in a MapActivity
- 40.19. A Custom Alternative for Maps and Fragments
41. Handling Telephone Calls
- 41.1. Report to the Manager
- 41.2. You Make the Call!
42. Fonts
- 42.1. Love the One You’re With
- 42.2. Additional Fonts
- 42.3. Here a Glyph, There a Glyph
43. More Development Tools
- 43.1. Hierarchy Viewer: How Deep Is Your Code?
- 43.2. DDMS: Under Android’s Hood
- 43.3. Logging
- 43.4. File Push and Pull
- 43.5. Screenshots
- 43.6. Location Updates
- 43.7. Placing Calls and Messages
- 43.8. Memory Management
- 43.9. adb: Like DDMS, with More Typing
- 43.10. Getting Graphical
44. The Role of Alternative Environments
- 44.1. In the Beginning, There Was Java...
- 44.2. ...And It Was OK
- 44.3. Bucking the Trend
- 44.4. Support, Structure
- 44.5. Caveat Developer
45. HTML5
- 45.1. Offline Applications
- 45.2. What Does It Mean?
- 45.3. How Do You Use It?
- 45.4. About the Sample App
- 45.5. “Installing” Checklist on Your Android Device
- 45.6. Examining the HTML
- 45.7. Examining the Manifest
- 45.8. Web Storage
- 45.9. What Does It Mean?
- 45.10. How Do You Use It?
- 45.11. Web SQL Database
- 45.12. Going to Production
- 45.13. Testing
- 45.14. Signing and Distribution
- 45.15. Updates
- 45.16. Issues You May Encounter
- 45.17. Android Device Versions
- 45.18. Screen Sizes and Densities
- 45.19. Limited Platform Integration
- 45.20. Performance and Battery
- 45.21. Look and Feel
- 45.22. Distribution
- 45.23. Browser Changes Post Ice Cream Sandwich
- 45.24. HTML5 and Alternative Android Browsers
- 45.25. HTML5: The Baseline
46. PhoneGap
- 46.1. What Is PhoneGap?
- 46.2. What Do You Write In?
- 46.3. What Features Do You Get?
- 46.4. What Do Apps Look Like?
- 46.5. How Does Distribution Work?
- 46.6. What About Other Platforms?
- 46.7. Using PhoneGap
- 46.8. Installation
- 46.9. Creating and Installing Your Project
- 46.10. PhoneGap Build
- 46.11. PhoneGap and the Checklist Sample
- 46.12. Sticking to the Standards
- 46.13. Adding PhoneGap APIs
- 46.14. Set Up Device-Ready Event Handler
- 46.15. Use What PhoneGap Gives You
- 46.16. Issues You May Encounter
- 46.17. Security
- 46.18. Screen Sizes and Densities
- 46.19. Look and Feel
- 46.20. For More Information
47. Other Alternative Environments
- 47.1. Rhodes
- 47.2. Flash, Flex, and AIR
- 47.3. JRuby and Ruboto
- 47.4. Mono for Android
- 47.5. App Inventor
- 47.6. Titanium Mobile
- 47.7. Other JVM Compiled Languages
48. Dealing with Devices
- 48.1. This App Contains Explicit Instructions
- 48.2. Explicit Feature Requests
- 48.3. Implied Feature Requests
- 48.4. A Guaranteed Market
- 48.5. Other Stuff That Varies
- 48.6. Bugs, Bugs, Bugs
- 48.7. Device Testing
49. Where Do We Go from Here?
- 49.1. Questions, Sometimes with Answers
- 49.2. Heading to the Source
- 49.3. Getting Your News Fix

Online LIVE Training Programming Course offered by INCAPROG ONLINE - www.incaprog.com - contacto@incaprog.com - Phone : (954) 727-3141

Share this ad:
Print:
Add to favorites:
Report: