- Title Page
- Dedication
- Acknowledgments
- Table of Contents
- Learning Android
- The Necessary Tools
- 1. Your First Android Application
- App Basics
- Creating an Android Project
- Navigating in Android Studio
- Laying Out the User Interface
- The view hierarchy
- Widget attributes
- android:layout_width and android:layout_height
- android:orientation
- android:text
- Creating string resources
- Previewing the layout
- From Layout XML to View Objects
- Resources and resource IDs
- Wiring Up Widgets
- Getting references to widgets
- Setting listeners
- Using anonymous inner classes
- Making Toasts
- Using code completion
- Running on the Emulator
- For the More Curious: Android Build Process
- Android build tools
- 2. Android and Model-View-Controller
- Creating a New Class
- Generating getters and setters
- Model-View-Controller and Android
- Benefits of MVC
- Updating the View Layer
- Updating the Controller Layer
- Running on a Device
- Connecting your device
- Configuring your device for development
- Adding an Icon
- Adding resources to a project
- Referencing resources in XML
- Challenges
- Challenge: Add a Listener to the TextView
- Challenge: Add a Previous Button
- Challenge: From Button to ImageButton
- 3. The Activity Lifecycle
- Logging the Activity Lifecycle
- Making log messages
- Using LogCat
- Rotation and the Activity Lifecycle
- Device configurations and alternative resources
- Creating a landscape layout
- Saving Data Across Rotation
- Overriding onSaveInstanceState(Bundle)
- The Activity Lifecycle, Revisited
- For the More Curious: Testing onSaveInstanceState(Bundle)
- For the More Curious: Logging Levels and Methods
- 4. Debugging Android Apps
- 5. Your Second Activity
- Setting Up a Second Activity
- Creating a new activity
- A new activity subclass
- Declaring activities in the manifest
- Adding a Cheat! button to QuizActivity
- Starting an Activity
- Communicating with intents
- Explicit and implicit intents
- Passing Data Between Activities
- Using intent extras
- Getting a result back from a child activity
- Setting a result
- Sending back an intent
- Handling a result
- How Android Sees Your Activities
- Challenge
- 6. Android SDK Versions and Compatibility
- 7. UI Fragments and the Fragment Manager
- The Need for UI Flexibility
- Introducing Fragments
- Starting CriminalIntent
- Creating a new project
- Fragments and the support library
- Adding dependencies in Android Studio
- Creating the Crime class
- Hosting a UI Fragment
- The fragment lifecycle
- Two approaches to hosting
- Defining a container view
- Creating a UI Fragment
- Defining CrimeFragment’s layout
- Creating the CrimeFragment class
- Implementing fragment lifecycle methods
- Wiring widgets in a fragment
- Adding a UI Fragment to the FragmentManager
- Fragment transactions
- The FragmentManager and the fragment lifecycle
- Application Architecture with Fragments
- The reason all our activities will use fragments
- For the More Curious: Why Support Fragments are Superior
- For the More Curious: Using Built-In Fragments
- 8. Creating User Interfaces with Layouts and Widgets
- Upgrading Crime
- Updating the Layout
- Wiring Widgets
- More on XML Layout Attributes
- Styles, themes, and theme attributes
- Screen pixel densities and dp and sp
- Android’s design guidelines
- Layout parameters
- Margins vs. padding
- Using the Graphical Layout Tool
- Creating a landscape layout
- Adding a new widget
- Editing attributes in properties view
- Reorganizing widgets in the component tree
- Updating child layout parameters
- How android:layout_weight works
- The graphical layout tool and you
- Widget IDs and multiple layouts
- Challenge: Formatting the Date
- 9. Displaying Lists with RecyclerView
- Updating CriminalIntent’s Model Layer
- Singletons and centralized data storage
- An Abstract Activity for Hosting a Fragment
- A generic fragment-hosting layout
- An abstract Activity class
- Using an abstract class
- Creating the new controllers
- Declaring CrimeListActivity
- RecyclerView, Adapter, and ViewHolder
- ViewHolders and Adapters
- Adapters
- Using a RecyclerView
- Implementing an Adapter and ViewHolder
- Customizing List Items
- Creating the list item layout
- Using a custom item view
- Responding to Presses
- For the More Curious: ListView and GridView
- For the More Curious: Singletons
- 10. Using Fragment Arguments
- Starting an Activity from a Fragment
- Putting an extra
- Retrieving an extra
- Updating CrimeFragment’s view with Crime data
- The downside to direct retrieval
- Fragment Arguments
- Attaching arguments to a fragment
- Retrieving arguments
- Reloading the List
- Getting Results with Fragments
- Challenge: Efficient RecyclerView Reloading
- For the More Curious: Why Use Fragment Arguments?
- 11. Using ViewPager
- 12. Dialogs
- The AppCompat Library
- Creating a DialogFragment
- Showing a DialogFragment
- Setting a dialog’s contents
- Passing Data Between Two Fragments
- Passing data to DatePickerFragment
- Returning data to CrimeFragment
- Setting a target fragment
- Sending data to the target fragment
- More flexibility in presenting a DialogFragment
- Challenge: More Dialogs
- Challenge: A Responsive DialogFragment
- 13. The Toolbar
- AppCompat
- Using the AppCompat library
- Updating the theme
- Using AppCompatActivity
- Menus
- Defining a menu in XML
- The app namespace
- Using Android Asset Studio
- Creating the menu
- Responding to menu selections
- Enabling Hierarchical Navigation
- How hierarchical navigation works
- An Alternative Action Item
- Toggling the action item title
- “Just one more thing...”
- For the More Curious: Toolbar vs Action Bar
- Challenge: Deleting Crimes
- Challenge: Plural String Resources
- Challenge: An Empty View for the RecyclerView
- 14. SQLite Databases
- Defining a Schema
- Building Your Initial Database
- Debugging database issues
- Gutting CrimeLab
- Writing to the Database
- Using ContentValues
- Inserting and updating rows
- Reading from the Database
- Using a CursorWrapper
- Converting to model objects
- Refreshing model data
- For the More Curious: More Databases
- For the More Curious: The Application Context
- Challenge: Deleting Crimes
- 15. Implicit Intents
- Adding Buttons
- Adding a Suspect to the Model Layer
- Using a Format String
- Using Implicit Intents
- Parts of an implicit intent
- Sending a crime report
- Asking Android for a contact
- Getting the data from the contact list
- Contacts permissions
- Checking for responding activities
- Challenge: ShareCompat
- Challenge: Another Implicit Intent
- 16. Taking Pictures with Intents
- A Place for Your Photo
- Including layout files
- External Storage
- Designating a picture location
- Using a Camera Intent
- External storage permission
- Firing the intent
- Scaling and Displaying Bitmaps
- Declaring Features
- For the More Curious: Using Includes
- Challenge: Detail Display
- Challenge: Efficient Thumbnail Load
- 17. Two-Pane Master-Detail Interfaces
- Adding Layout Flexibility
- Modifying SingleFragmentActivity
- Creating a layout with two fragment containers
- Using an alias resource
- Creating tablet alternatives
- Activity: Fragment Boss
- Fragment callback interfaces
- Implementing CrimeListFragment.Callbacks
- Implementing CrimeFragment.Callbacks
- For the More Curious: More on Determining Device Size
- 18. Assets
- 19. Audio Playback with SoundPool
- 20. Styles and Themes
- 21. XML Drawables
- 22. More About Intents and Tasks
- 23. HTTP & Background Tasks
- Creating PhotoGallery
- Networking Basics
- Asking permission to network
- Using AsyncTask to Run on a Background Thread
- You and Your Main Thread
- Beyond the main thread
- Fetching JSON from Flickr
- Parsing JSON text
- From AsyncTask Back to the Main Thread
- Cleaning Up AsyncTasks
- For the More Curious: More on AsyncTask
- For the More Curious: Alternatives to AsyncTask
- Challenge: Gson
- Challenge: Paging
- Challenge: Dynamically Adjusting the Number of Columns
- 24. Loopers, Handlers, and HandlerThread
- Preparing RecyclerView to Display Images
- Downloading Lots of Small Things
- Communicating with the Main Thread
- Assembling a Background Thread
- Messages and Message Handlers
- Message anatomy
- Handler anatomy
- Using handlers
- Passing handlers
- For the More Curious: AsyncTask vs. Threads
- Challenge: Preloading and Caching
- For the More Curious: Solving the Image Downloading Problem
- 25. Search
- 26. Background Services
- Creating an IntentService
- What Services are For
- Safe background networking
- Looking for New Results
- Delayed Execution with AlarmManager
- Being a good citizen: using alarms the right way
- Inexact vs. exact repeating
- Time basis options
- PendingIntent
- Managing alarms with PendingIntent
- Controlling Your Alarm
- Notifications
- Challenge: Notifications on Android Wear
- For the More Curious: Service Details
- What a service does (and does not) do
- A service’s lifecycle
- Non-sticky services
- Sticky services
- Bound services
- Local service binding
- Remote service binding
- For the More Curious: JobScheduler and JobServices
- For the More Curious: Sync Adapters
- Challenge: Using JobService on Lollipop
- 27. Broadcast Intents
- Regular Intents vs. Broadcast Intents
- Receiving a System Broadcast: Waking Up on Boot
- Creating and registering a standalone receiver
- Using receivers
- Filtering Foreground Notifications
- Sending broadcast intents
- Creating and registering a dynamic receiver
- Limiting broadcasts to your app using private permissions
- More about protection levels
- Passing and receiving data with ordered broadcasts
- Receivers and Long-Running Tasks
- For the More Curious: Local Events
- Using EventBus
- Using RxJava
- For the More Curious: Detecting the Visibility of Your Fragment
- 28. Browsing the Web and WebView
- One Last Bit of Flickr Data
- The Easy Way: Implicit Intents
- The Harder Way: WebView
- Using WebChromeClient to spruce things up
- Proper Rotation with WebView
- Dangers of handling configuration changes
- For the More Curious: Injecting JavaScript Objects
- For the More Curious: KitKat’s WebView Overhaul
- Challenge: Using the Back Button for Browser History
- Challenge: Supporting Non-HTTP Links
- 29. Custom Views and Touch Events
- 30. Property Animation
- 31. Locations and Play Services
- Locations and Libraries
- Google Play Services
- Creating Locatr
- Play Services and Location Testing on Emulators
- Mock location data
- Building out Locatr
- Setting Up Google Play Services
- Location permissions
- Using Google Play Services
- Flickr Geosearch
- Getting a Location Fix
- Find and Display an Image
- Challenge: Progress
- 32. Maps
- 33. Material Design
- 34. Afterword
- Index
This second edition shows how to use the Android Studio integrated development environment to write practical applications for Android 5.1 (Lollipop) that are backwards-compatible through Android 4.1 (Jelly Bean). It includes updated coverage of the fundamentals of Android programming as well as new Lollipop tools like the toolbar and material design. It also covers new tools from the support libraries, like RecyclerView and Google Play Services, plus some key standard library tools, like SoundPool, animations, and assets.
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.