- 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
The speed of the Android emulator has improved significantly over time and it is a reasonable way to run the code that you write in this book.
As an alternative, Genymotion is a popular, third-party Android emulator. You will occasionally see references to the Genymotion emulator in this book. For more information on Genymotion, visit http://genymotion.com/.
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.