E. The Android Emulator: Speeding Things Up
by David Griffiths, Dawn Griffiths
Head First Android Development, 2nd Edition
- Authors of Head First Android Development
- How to use this Book: Intro
- The technical review team
- Acknowledgments
- O’Reilly Safari ®
- 1. Getting Started: Diving In
- Welcome to Androidville
- The Android platform dissected
- Here’s what we’re going to do
- Your development environment
- Install Android Studio
- Build a basic app
- How to build the app
- How to build the app (continued)
- How to build the app (continued)
- Activities and layouts from 50,000 feet
- How to build the app (continued)
- How to build the app (continued)
- You’ve just created your first Android app
- Android Studio creates a complete folder structure for you
- Useful files in your project
- Edit code with the Android Studio editors
- Run the app in the Android emulator
- Create an Android Virtual Device
- Creating an AVD (continued)
- Creating an AVD (continued)
- Run the app in the emulator
- You can watch progress in the console
- Test drive
- What just happened?
- Refine the app
- What’s in the layout?
- activity_main.xml has two elements
- Update the text displayed in the layout
- Take the app for a test drive
- Chapter 1 Your Android Toolbox
- 2. Building Interactive Apps: Apps That Do Something
- Let’s build a Beer Adviser app
- Here’s what we’re going to do
- Create the project
- We’ve created a default activity and layout
- A closer look at the design editor
- Add a button using the design editor
- activity_find_beer.xml has a new button
- A closer look at the layout code
- A closer look at the layout code (continued)
- Changes to the XML...
- ... are reflected in the design editor
- Let’s take the app for a test drive
- Hardcoding text makes localization hard
- Create the String resource
- Use the String resource in your layout
- The code for activity_find_beer.xml
- Time for a test drive
- Add values to the spinner
- Add the string-array to strings.xml
- Test drive the spinner
- We need to make the button do something
- Make the button call a method
- What activity code looks like
- Add an onClickFindBeer() method to the activity
- onClickFindBeer() needs to do something
- Once you have a view, you can access its methods
- Update the activity code
- The first version of the activity
- What the code does
- Test drive the changes
- Build the custom Java class
- Enhance the activity to call the custom Java class so that we can get REAL advice
- Activity code version 2
- What happens when you run the code
- Test drive your app
- Chapter 2 Your Android Toolbox
- 3. Multiple Activities and Intents: State Your Intent
- Apps can contain more than one activity
- Here’s the app structure
- Get started: create the project
- Update the layout
- Update strings.xml...
- Create the second activity and layout
- What just happened?
- Welcome to the Android manifest file
- Every activity needs to be declared
- An intent is a type of message
- Use an intent to start the second activity
- What happens when you run the app
- The story continues...
- Test drive the app
- Pass text to a second activity
- Update the text view properties
- putExtra() puts extra info in an intent
- Update the CreateMessageActivity code
- Get ReceiveMessageActivity to use the information in the intent
- What happens when the user clicks the Send Message button
- Test drive the app
- We can change the app to send messages to other people
- How Android apps work
- But we don’t know what apps are on the user’s device
- Create an intent that specifies an action
- Change the intent to use an action
- What happens when the code runs
- The story continues...
- The intent filter tells Android which activities can handle which actions
- How Android uses the intent filter
- You need to run your app on a REAL device
- Running your app on a real device (continued)
- Test drive the app
- What if you ALWAYS want your users to choose an activity?
- What happens when you call createChooser()
- The story continues...
- Change the code to create a chooser
- Test drive the app
- If you have NO matching activities
- Chapter 3 Your Android Toolbox
- 4. The Activity Lifecycle: Being an Activity
- How do activities really work?
- The Stopwatch app
- Add String resources
- The layout code (continued)
- How the activity code will work
- Add code for the buttons
- The runTimer() method
- Handlers allow you to schedule code
- The full runTimer() code
- The full StopwatchActivity code
- The activity code (continued)
- What happens when you run the app
- The story continues
- Test drive the app
- What just happened?
- Rotating the screen changes the device configuration
- The states of an activity
- The activity lifecycle: from create to destroy
- Your activity inherits the lifecycle methods
- Save the current state...
- ... then restore the state in onCreate()
- The updated StopwatchActivity code
- What happens when you run the app
- The story continues
- Test drive the app
- There’s more to an activity’s life than create and destroy
- The activity lifecycle: the visible lifetime
- We need to implement two more lifecycle methods
- The updated StopwatchActivity code
- What happens when you run the app
- Test drive the app
- What if an app is only partially visible?
- The activity lifecycle: the foreground lifetime
- Stop the stopwatch if the activity’s paused
- Implement the onPause() and onResume() methods
- The complete StopwatchActivity code
- The activity code (continued)
- The activity code (continued)
- What happens when you run the app
- Test drive the app
- Your handy guide to the lifecycle methods
- Chapter 4 Your Android Toolbox
- 5. Views and View Groups: Enjoy the View
- Your user interface is made up of layouts and GUI components
- LinearLayout displays views in a single row or column
- Orientation is vertical or horizontal
- Padding adds space
- Add a dimension resource file for consistent padding across layouts
- A linear layout displays views in the order they appear in the layout XML
- Use margins to add distance between views
- Let’s change up a basic linear layout
- Here’s the starting point for the linear layout
- Make a view streeeeetch by adding weight
- Adding weight to one view
- Adding weight to multiple views
- Gravity controls the position of a view’s contents
- Test drive
- Values you can use with the android:gravity attribute
- layout_gravity controls the position of a view within a layout
- More values you can use with the android:layout_gravity attribute
- The full linear layout code
- LinearLayout: a summary
- Frame layouts stack their views
- Add an image to your project
- A frame layout stacks views in the order they appear in the layout XML
- You can nest layouts
- The full code to nest a layout
- FrameLayout: a summary
- Layouts and GUI components have a lot in common
- GUI components are a type of View
- What being a view buys you
- A layout is really a hierarchy of Views
- Playing with views
- Text view
- Editable text view
- Button
- Toggle button
- Switch
- Checkboxes
- Checkboxes (continued)
- Radio buttons
- Radio buttons (continued)
- Spinner
- Image view
- Image view: the layout XML
- Adding images to buttons
- Image button
- Scroll view
- Toasts
- Chapter 5 Your Android Toolbox
- 6. Constraint Layouts: Put Things in Their Place
- Nested layouts can be inefficient
- Introducing the constraint layout
- Make sure your project includes the Constraint Layout Library
- Add the String resources to strings.xml
- Use the blueprint tool
- Position views using constraints
- Add a vertical constraint
- Changes to the blueprint are reflected in the XML
- How to center views
- Adjust a view’s position by updating its bias
- How to change a view’s size
- How to align views
- Let’s build a real layout
- First, add the top line of views
- The Infer Constraints feature guesses which constraints to add
- Add the next line to the blueprint...
- Finally, add a view for the message
- Test drive the app
- Chapter 6 Your Android Toolbox
- 7. List Views and Adapters: Getting Organized
- Every app starts with ideas
- Organize your ideas: top-level, category, and detail/edit activities
- Navigating through the activities
- Use list views to navigate to data
- We’re going to build part of the Starbuzz app
- The drink detail activity
- The Starbuzz app structure
- Here’s what we’re going to do
- The Drink class
- The image files
- The top-level layout contains an image and a list
- Use a list view to display the list of options
- The full top-level layout code
- Test drive
- Get list views to respond to clicks with a listener
- Set the listener to the list view
- TopLevelActivity.java (continued)
- Where we’ve got to
- A category activity displays the data for a single category
- Update activity_drink_category.xml
- For nonstatic data, use an adapter
- Connect list views to arrays with an array adapter
- Add the array adapter to DrinkCategoryActivity
- What happens when you run the code
- Test drive the app
- App review: where we are
- How we handled clicks in TopLevelActivity
- Pass the ID of the item that was clicked by adding it to an intent
- The full DrinkCategoryActivity code
- A detail activity displays data for a single record
- Retrieve data from the intent
- Update the views with the data
- The DrinkActivity code
- What happens when you run the app
- The story continues
- Test drive the app
- Chapter 7 Your Android Toolbox
- 8. Support Libraries and App Bars: Taking Shortcuts
- Great apps have a clear structure
- Different types of navigation
- Here’s what we’re going to do
- Add an app bar by applying a theme
- Support libraries allow you to use new features in older versions of Android
- Create the Pizza app
- Add the v7 AppCompat Support Library
- AppCompatActivity lets you use AppCompat themes
- MainActivity needs to be an AppCompatActivity
- AndroidManifest.xml can change your app bar’s appearance
- How to apply a theme
- Define styles in a style resource file
- Theme gallery
- Customize the look of your app
- Define colors in a color resource file
- The code for activity_main.xml
- Test drive the app
- ActionBar vs. Toolbar
- 1. Add the AppCompat Support Library
- 2. Extend the AppCompatActivity class
- 3. Remove the app bar
- 4. Add a toolbar to the layout
- Add the toolbar to the layout...
- ... or define the toolbar as a separate layout
- Include the toolbar in the activity’s layout
- 5. Set the toolbar as the activity’s app bar
- Test drive the app
- Add actions to the app bar
- Update activity_order.xml
- Update OrderActivity.java
- Change the app bar text by adding a label
- The code for AndroidManifest.xml
- 1. Add the action’s resources
- 2. Create the menu resource file
- Control the action’s appearance
- 3. Add the menu to the app bar with the onCreateOptionsMenu() method
- 4. React to action item clicks with the onOptionsItemSelected() method
- The full MainActivity.java code
- Test drive the app
- Enable Up navigation
- Set an activity’s parent
- Adding the Up button
- Test drive the app
- Sharing content on the app bar
- Add a share action provider to menu_main.xml
- Specify the content with an intent
- The full MainActivity.java code
- The MainActivity.java code (continued)
- Test drive the app
- Chapter 8 Your Android Toolbox
- 9. Fragments: Make It Modular
- Your app needs to look great on ALL devices
- Your app may need to behave differently too
- Fragments allow you to reuse code
- The phone version of the app
- Here’s what we’re going to do
- Create the project and activities
- Add a button to MainActivity’s layout
- Make the button respond to clicks
- How to add a fragment to your project
- What fragment code looks like
- The fragment’s onCreateView() method
- Fragment layout code looks just like activity layout code
- Add a fragment to an activity’s layout
- Simplify the layout
- Support Library fragments need activities that extend FragmentActivity
- What the code does
- The story continues
- Test drive the app
- Get the fragment and activity to interact
- The Workout class
- Pass the workout ID to the fragment
- Use the fragment manager to manage fragments
- Get the activity to set the workout ID
- Activity states revisited
- The fragment lifecycle
- Fragments inherit lifecycle methods
- Set the view’s values in the fragment’s onStart() method
- What happens when the code runs
- The story continues
- Test drive the app
- Where we’ve got to
- We need to create a fragment with a list
- A list fragment is a fragment that contains only a list
- How to create a list fragment
- Adapters revisited
- Our previous array adapter
- The updated WorkoutListFragment code
- Display WorkoutListFragment in the MainActivity layout
- The code for activity_main.xml
- What happens when the code runs
- The story continues
- Test drive the app
- Connect the list to the detail
- We need to decouple the fragment by using an interface
- The code for WorkoutListFragment.java
- MainActivity needs to implement the interface
- DetailActivity needs to pass the ID to WorkoutDetailFragment
- What happens when the code runs
- The story continues...
- Test drive the app
- Chapter 9 Your Android Toolbox
- 10. Fragments for Larger Interfaces: Different Size, Different Interface
- The Workout app looks the same on a phone and a tablet
- Designing for larger interfaces
- The phone version of the app
- The tablet version of the app
- Here’s what we’re going to do
- Create a tablet AVD
- Creating a tablet AVD (continued)
- Creating a tablet AVD (continued)
- Put screen-specific resources in screen-specific folders
- The different folder options
- Tablets use layouts in the layout-large folder
- The layout-large version of the layout needs to display two fragments
- What the updated code does
- Test drive the app
- We need to change the itemClicked() code
- You want fragments to work with the Back button
- Welcome to the back stack
- Back stack transactions don’t have to be activities
- Use a frame layout to replace fragments programmatically
- Use layout differences to tell which layout the device is using
- The revised MainActivity code
- Using fragment transactions
- The updated MainActivity code
- What happens when the code runs
- The story continues...
- Test drive the app
- Rotating the tablet breaks the app
- Saving an activity’s state (revisited)
- Save the fragment’s state...
- The updated code for WorkoutDetailFragment.java
- WorkoutDetailFragment.java (continued)
- Test drive the app
- Chapter 10 Your Android Toolbox
- 11. Dynamic Fragments: Nesting Fragments
- Adding dynamic fragments
- Here’s what we’re going to do
- The new version of the app
- Create TempActivity
- TempActivity needs to extend AppCompatActivity
- Fragments and activities have similar lifecycles...
- The StopwatchFragment.java code
- StopwatchFragment.java (continued)
- StopwatchFragment.java (continued)
- The StopwatchFragment layout
- The StopwatchFragment layout (continued)
- Add StopwatchFragment to TempActivity’s layout
- Test drive the app
- The app crashes if you click on a button
- Let’s look at the StopwatchFragment layout code
- The onClick attribute calls methods in the activity, not the fragment
- 1. Remove the onClick attributes from the fragment’s layout
- 2. Change the onClick... method signatures
- 3. Make the fragment implement OnClickListener
- Attach the OnClickListener to the buttons
- The StopwatchFragment code
- The StopwatchFragment code (continued)
- The StopwatchFragment code (continued)
- Test drive the app
- Rotating the device resets the stopwatch
- Use <fragment> for static fragments...
- Change activity_temp.xml to use a FrameLayout
- The full code for TempActivity.java
- Test drive the app
- Add the stopwatch to WorkoutDetailFragment
- What we’re going to do
- Add a FrameLayout where the fragment should appear
- So far, we’ve only used fragment transactions in activities
- Using getFragmentManager() creates extra transactions on the back stack
- Using getChildFragmentManager() creates nested transactions instead
- What getChildFragmentManager() fragment transaction code looks like
- The full WorkoutDetailFragment.java code
- The full code (continued)
- Test drive the app
- Test drive (continued)
- Chapter 11 Your Android Toolbox
- 12. Design Support Library: Swipe Right
- The Bits and Pizzas app revisited
- The app structure
- Here’s what we’re going to do
- Create TopFragment
- Create PizzaFragment
- Create PastaFragment
- Create StoresFragment
- Use a view pager to swipe through fragments
- Add a view pager to MainActivity’s layout
- Tell a view pager about its pages using a fragment pager adapter
- The code for our fragment pager adapter
- Attach the fragment pager adapter to the view pager
- The full code for MainActivity.java
- The MainActivity.java code (continued)
- The MainActivity.java code (continued)
- Test drive the app
- Add tab navigation to MainActivity
- How to add tabs to your layout
- Add tabs to MainActivity’s layout
- Link the tab layout to the view pager
- The full code for MainActivity.java
- The MainActivity.java code (continued)
- The MainActivity.java code (continued)
- Test drive the app
- The Design Support Library helps you implement material design
- Here’s what we’ll do
- Make the toolbar respond to scrolls
- Add a coordinator layout to MainActivity’s layout
- How to coordinate scroll behavior
- The code to enable to toolbar to scroll
- Add scrollable content to TopFragment
- Use a nested scroll view to make layout content scrollable
- How we’ll structure TopFragment’s layout
- The full code for fragment_top.xml
- Test drive the app
- Add a collapsing toolbar to OrderActivity
- How to create a plain collapsing toolbar
- The full code to add a collapsing toolbar to activity_order.xml
- The activity_order.xml code (continued)
- Test drive the app
- How to add an image to a collapsing toolbar
- The updated code for activity_order.xml
- The activity_order.xml code (continued)
- Test drive the app
- FABs and snackbars
- Add the icon for the FAB
- The updated code for activity_order.xml
- The activity_order.xml code (continued)
- How to create a snackbar
- The full code for OrderActivity.java
- Test drive the app
- Chapter 12 Your Android Toolbox
- 13. Recycler Views and Card Views: Get Recycling
- There’s still work to do on the Bits and Pizzas app
- Recycler views from 10,000 feet
- Here’s what we’re going to do
- Add the pizza data
- Display the pizza data in a card
- How to create a card view
- The full card_captioned_image.xml code
- How our recycler view adapter will work
- Add a recycler view adapter
- Tell the adapter what data it should work with...
- Define the adapter’s view holder
- Override the onCreateViewHolder() method
- Add the data to the card views
- The full code for CaptionedImagesAdapter.java
- The full CaptionedImagesAdapter.java code (continued)
- Create the recycler view
- Add the RecyclerView to PizzaFragment’s layout
- The full PizzaFragment.java code
- A recycler view uses a layout manager to arrange its views
- Specify the layout manager
- The full PizzaFragment.java code
- What happens when the code runs
- The story continues
- Test drive the app
- Make the recycler view respond to clicks
- Create PizzaDetailActivity
- What PizzaDetailActivity needs to do
- The code for PizzaDetailActivity.java
- Get a recycler view to respond to clicks
- You can listen for view events from the adapter
- Keep your adapters reusable
- Add the interface to the adapter
- The CaptionedImagesAdapter.java code (continued)
- Implement the listener in PizzaFragment.java
- The PizzaFragment.java code (continued)
- Test drive the app
- Chapter 13 Your Android Toolbox
- 14. Navigation Drawers: Going Places
- Tab layouts allow easy navigation...
- ... but navigation drawers let you show more options
- We’re going to create a navigation drawer for a new email app
- Navigation drawers deconstructed
- Here’s what we’re going to do
- Create the CatChat project
- Create InboxFragment
- Create DraftsFragment
- Create SentItemsFragment
- Create TrashFragment
- Create a toolbar layout
- Update the app’s theme
- Create HelpActivity
- Create FeedbackActivity
- We need to build a navigation drawer
- Create the navigation drawer’s header
- The full nav_header.xml code
- The drawer gets its options from a menu
- Add items in the order you want them to appear in the drawer
- How to group items together
- We’ll use a group for the first section
- Add the support section as a submenu
- The full menu_nav.xml code
- How to create a navigation drawer
- The full code for activity_main.xml
- Add InboxFragment to MainActivity’s frame layout
- Test drive the app
- What the activity code needs to do
- Add a drawer toggle
- Respond to the user clicking items in the drawer
- Implement the onNavigationItemSelected() method
- Close the drawer when the user presses the Back button
- The full MainActivity.java code
- MainActivity.java (continued)
- MainActivity.java (continued)
- Test drive the app
- Chapter 14 Your Android Toolbox
- 15. SQLite Databases: Fire Up the Database
- Back to Starbuzz
- Android uses SQLite databases to persist data
- Android comes with SQLite classes
- The current Starbuzz app structure
- Let’s change the app to use a database
- The SQLite helper manages your database
- Create the SQLite helper
- Specify the database
- Inside a SQLite database
- You create tables using Structured Query Language (SQL)
- Insert data using the insert() method
- Insert multiple records
- The StarbuzzDatabaseHelper code
- What the SQLite helper code does
- What if you need to make changes to the database?
- SQLite databases have a version number
- What happens when you change the version number
- Upgrade your database with onUpgrade()
- Downgrade your database with onDowngrade()
- Let’s upgrade the database
- The SQLite helper code (continued)
- Upgrade an existing database
- Update records with the update() method
- Apply conditions to multiple columns
- Change the database structure
- Delete tables by dropping them
- The full SQLite helper code
- The SQLite helper code (continued)
- What happens when the code runs
- Chapter 15 Your Android Toolbox
- 16. Basic Cursors: Getting Data Out
- The story so far...
- The new Starbuzz app structure
- What we’ll do to change DrinkActivity to use the Starbuzz database
- The current DrinkActivity code
- Get a reference to the database
- Get data from the database with a cursor
- Return all the records from a table
- Return records in a particular order
- Return selected records
- The DrinkActivity code so far
- To read a record from a cursor, you first need to navigate to it
- Navigate cursors
- Get cursor values
- Finally, close the cursor and the database
- The DrinkActivity code
- The DrinkActivity code (continued)
- What we’ve done so far
- What we’ll do to change DrinkCategoryActivity to use the Starbuzz database
- The current DrinkCategoryActivity code
- Get a reference to the Starbuzz database...
- ... then create a cursor that returns the drinks
- How do we replace the array data in the list view?
- A simple cursor adapter maps cursor data to views
- How to use a simple cursor adapter
- Close the cursor and database
- The story continues
- The revised code for DrinkCategoryActivity
- The DrinkCategoryActivity code (continued)
- Test drive the app
- Chapter 16 Your Android Toolbox
- 17. Cursors and Asynctasks: Staying in the Background
- We want our Starbuzz app to update database data
- We’ll update DrinkActivity first
- Add a checkbox to DrinkActivity’s layout
- Display the value of the FAVORITE column
- Respond to clicks to update the database
- The full DrinkActivity.java code
- DrinkActivity.java (continued)
- DrinkActivity.java (continued)
- Test drive the app
- Display favorites in TopLevelActivity
- Display the favorite drinks in activity_top_level.xml
- Refactor TopLevelActivity.java
- What changes are needed for TopLevelActivity.java
- Ready Bake Code
- The new TopLevelActivity.java code
- The TopLevelActivity.java code (continued)
- The TopLevelActivity.java code (continued)
- Test drive the app
- Cursors don’t automatically refresh
- Change the cursor with changeCursor()
- The revised TopLevelActivity.java code
- The TopLevelActivity.java code (continued)
- The TopLevelActivity.java code (continued)
- Test drive the app
- Databases can make your app go in sloooow-moooo....
- What code goes on which thread?
- AsyncTask performs asynchronous tasks
- The onPreExecute() method
- The doInBackground() method
- The onProgressUpdate() method
- The onPostExecute() method
- The AsyncTask class parameters
- The full UpdateDrinkTask class
- Execute the AsyncTask...
- ... in DrinkActivity’s onFavoritesClicked() method
- The full DrinkActivity.java code
- The full DrinkActivity.java code (continued)
- The full DrinkActivity.java code (continued)
- The full DrinkActivity.java code (continued)
- Test drive the app
- Chapter 17 Your Android Toolbox
- A summary of the AsyncTask steps
- 18. Started Services: At Your Service
- Services work in the background
- We’ll create a STARTED service
- Use the IntentService class to create a basic started service
- How to log messages
- The full DelayedMessageService code
- You declare services in AndroidManifest.xml
- Add a button to activity_main.xml
- You start a service using startService()
- What happens when you run the app
- Test drive the app
- The states of a started service
- The started service lifecycle: from create to destroy
- Your service inherits the lifecycle methods
- Android has a built-in notification service
- We’ll use notifications from the AppCompat Support Library
- First create a notification builder
- Add an action to tell the notification which activity to start when clicked
- Issue the notification using the built-in notification service
- The full code for DelayedMessageService.java
- The DelayedMessageService.java code (continued)
- What happens when you run the code
- The story continues
- Test drive the app
- Chapter 18 Your Android Toolbox
- 19. Bound Services and Permissions: Bound Together
- Bound services are bound to other components
- Here’s what we’re going to do
- Create a new service
- Implement a binder
- Add a getDistance() method to the service
- Update MainActivity’s layout
- What MainActivity needs to do
- Create a ServiceConnection
- The onServiceConnected() method
- The onServiceDisconnected() method
- Use bindService() to bind the service
- Use unbindService() to unbind from the service
- Call OdometerService’s getDistance() method
- The full MainActivity.java code
- The MainActivity.java code (continued)
- What happens when you run the code
- The story continues
- The story continues
- Test drive the app
- The states of a bound service
- The bound service lifecycle: from create to destroy
- We’ll use Android’s Location Services to return the distance traveled
- Add the AppCompat Support Library
- Declare the permissions you need
- Add a location listener to OdometerService
- We need a location manager and location provider
- Request location updates...
- ... but first check that your app has permission
- Here’s the updated OdometerService code
- Calculate the distance traveled
- Return the miles traveled
- Stop the listener getting location updates
- The full OdometerService.java code
- The OdometerService.java code (continued)
- The OdometerService.java code (continued)
- Test drive the app
- Get the app to request permission
- Check permissions at runtime
- Check for Location Services permissions in MainActivity’s onStart() method
- Check the user’s response to the permission request
- Issue a notification if we’re denied permission
- Add notification code to onRequestPermissionsResults()
- The notification code (continued)
- The full code for MainActivity.java
- The MainActivity.java code (continued)
- The MainActivity.java code (continued)
- Test drive the app
- Chapter 19 Your Android Toolbox
- Leaving town...
- It’s been great having you here in Androidville
- A. Relative and Grid Layouts: Meet the Relatives
- A relative layout displays views in relative positions
- Positioning views to the left or right
- Attributes for positioning views relative to the parent layout
- Positioning views relative to other views
- Attributes for positioning views relative to other views
- A grid layout displays views in a grid
- Adding views to the grid layout
- Let’s create a new grid layout
- We’ll start with a sketch
- Row 0: add views to specific rows and columns
- Row 1: make a view span multiple columns
- Row 2: make a view span multiple columns
- The full code for the grid layout
- The grid layout code (continued)
- B. Gradle: The Gradle Build Tool
- C. Art: The Android Runtime
- D. ADB: The Android Debug Bridge
- E. The Android Emulator: Speeding Things Up
- F. Leftovers: The Top Ten Things (we didn’t cover)
- Index
Appendix E. The Android Emulator: Speeding Things Up
Ever felt like you were spending all your time waiting for the emulator? There’s no doubt that using the Android emulator is useful. It allows you to see how your app will run on devices other than the physical ones you have access to. But at times it can feel a little...sluggish. In this appendix, we’ll explain why the emulator can seem slow. Even better, we’ll give you a few tips we’ve learned for speeding it up.
Why the emulator is so slow
When you’re writing Android apps, you’ll spend a lot of time waiting for the Android emulator to start up or deploy your code. Why is that? Why is the Android emulator so sloooooow? If you’ve ever written iPhone code, you know how fast the iPhone simulator is. If it’s possible for the iPhone, then why not for Android?
There’s a clue in the names: the iPhone simulator and the Android emulator.
The iPhone simulator simulates a device running the iOS operating system. All of the code for iOS is compiled to run natively on the Mac and the iPhone simulator runs at Mac-native speed. That means it can simulate an iPhone boot-up in just a few seconds.
The Android emulator works in a completely different way. It uses an open source application called QEMU (or Quick Emulator) to emulate the entire Android hardware device. It runs code that interprets machine code that’s intended to be run by the device’s processor. It has code that emulates the storage system, the screen, and pretty much every other piece of physical equipment on an Android device.
An emulator like QEMU creates a much more realistic representation of a virtual device than something like the iPhone simulator does, but the downside is that it has to do far more work for even simple operations like reading from disk or displaying something on a screen. That’s why the emulator takes so long to boot up a device. It has to pretend to be every little hardware component inside the device, and it has to interpret every single instruction.
How to speed up your Android development
1. Use a real device
The simplest way to speed up your development process is by using a real device. A real device will boot up much faster than an emulated one, and it will probably deploy and run apps a lot more quickly. If you want to develop on a real device, you may want to go into “Developer options” and check the Stay Awake option. This will prevent your device from locking the screen, which is useful if you are repeatedly deploying to it.
2. Use an emulator snapshot
Booting up is one of the slowest things the emulator does. If you save a snapshot of the device while it’s running, the emulator will be able to reset itself to this state without having to go through the boot-up process. To use a snapshot with your device, open the AVD manager from the Android Studio menu by selecting Tools→Android→AVD Manager, edit the AVD by clicking on the Edit symbol, and then check the “Store a snapshot for faster startup” option.
This will save a snapshot of what the memory looks like when the device is running. The emulator will be able to restore the memory in this state without booting the device.
3. Use hardware acceleration
By default, the QEMU emulator will have to interpret each machine code instruction on the virtual device. That means it’s very flexible because it can pretend to be lots of different CPUs, but it’s one of the main reasons why the emulator is slow. Fortunately, there’s a way to get your development machine to run the machine code instructions directly. There are two main types of Android Virtual Device: ARM machines and x86 machines. If you create an x86 Android device and your development machine is using a particular type of Intel x86 CPU, then you can configure your emulator to run the Android machine code instructions directly on your Intel CPU.
You will need to install Intel’s Hardware Accelerated Execution Manager (HAXM). At the time of writing, you can find HAXM here:
HAXM is a hypervisor. That means it can switch your CPU into a special mode to run virtual machine instructions directly. However, HAXM will only run on Intel processors that support Intel Virtualization Technology. But if your development machine is compatible, then HAXM will make your AVD run much faster.
4. Use Instant Run
Since Android Studio 2.3, it’s been possible to redeploy apps much more quickly using the Instant Run utility. This utility allows Android Studio to recompile just the files that have changed, and then patch the application currently running on the device. This means that instead of waiting for a minute or so while the application is recompiled and deployed, you can see your changes running in just a few seconds.
To use Instant Run, click on the Apply Changes option in the Run menu, or click on the lightning bolt icon in the toolbar:
There are a couple of conditions on using Instant Run. First, your app’s target needs to be at least API 15. Second, you need to deploy to a device that runs API 21 or above. So long as you satisfy both these conditions, you’ll find that Instant Run is by far the fastest way of getting your code up and running.
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.