book

Head First Android Development, 2nd Edition

by Dawn Griffiths, David Griffiths

August 2017

Beginner to intermediate

928 pages

22h 2m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Authors of Head First Android Development
How to use this Book: Intro
Who is this book for?Who should probably back away from this book?We know what you’re thinkingWe know what your brain is thinkingMetacognition: thinking about thinkingHere’s what WE didHere’s what YOU can do to bend your brain into submissionRead me
The technical review team
Acknowledgments
O’Reilly Safari ®
1. Getting Started: Diving In
Welcome to AndroidvilleLayouts define what each screen looks likeActivities define what the app doesSometimes extra resources are needed tooThe Android platform dissectedHere’s what we’re going to doYour development environmentThe Android SDKAndroid Studio is a special version of IntelliJ IDEAInstall Android StudioBuild a basic appHow to build the app1. Create a new projectHow to build the app (continued)2. Configure the projectHow to build the app (continued)3. Specify the minimum SDKActivities and layouts from 50,000 feetHow to build the app (continued)4. Add an activityHow to build the app (continued)5. Customize the activityYou’ve just created your first Android appAndroid Studio creates a complete folder structure for youThe folder structure includes different types of filesUseful files in your projectEdit code with the Android Studio editorsThe code editorThe design editorRun the app in the Android emulatorSo what does the emulator look like?Create an Android Virtual DeviceOpen the Android Virtual Device ManagerSelect the hardwareCreating an AVD (continued)Select a system imageCreating an AVD (continued)Verify the AVD configurationRun the app in the emulatorCompile, package, deploy, and runYou can watch progress in the consoleTest driveWhat just happened?Refine the appThe app has one activity and one layoutThe activity controls what the app doesThe layout controls the app’s appearanceWhat’s in the layout?The design editorThe code editoractivity_main.xml has two elementsUpdate the text displayed in the layoutTake the app for a test driveChapter 1 Your Android Toolbox
2. Building Interactive Apps: Apps That Do Something
Let’s build a Beer Adviser appHere’s what we’re going to doCreate the projectWe’ve created a default activity and layoutA closer look at the design editorAdd a button using the design editorChanges in the design editor are reflected in the XMLactivity_find_beer.xml has a new buttonButtons and text views are subclasses of the same Android View classandroid:idandroid:layout_width, android:layout_heightandroid:textA closer look at the layout codeThe LinearLayout elementA closer look at the layout code (continued)The Button elementThe TextView elementChanges to the XML...... are reflected in the design editorLet’s take the app for a test driveHere’s what we’ve done so farHardcoding text makes localization hardPut the text in a String resource fileHow do you use String resources?Create the String resourceUse the String resource in your layoutThe code for activity_find_beer.xmlTime for a test driveHere’s what we’ve done so farAdd values to the spinnerAdding an array resource is similar to adding a StringAdd the string-array to strings.xmlGet the spinner to reference a string-arrayTest drive the spinnerWhere we’ve got toWe need to make the button do somethingMake the button call a methodUse onClick to say which method the button callsWhat activity code looks likeAdd an onClickFindBeer() method to the activityonClickFindBeer() needs to do somethingUse findViewById() to get a reference to a viewOnce you have a view, you can access its methodsSetting the text in a text viewRetrieving the selected value in a spinnerUpdate the activity codeThe first version of the activityWhat the code doesTest drive the changesBuild the custom Java classCustom Java class specBuild and test the Java classEnhance the activity to call the custom Java class so that we can get REAL adviceActivity code version 2What happens when you run the codeTest drive your appChapter 2 Your Android Toolbox
3. Multiple Activities and Intents: State Your Intent
Apps can contain more than one activityHere’s what we’re going to do in this chapterHere’s the app structureGet started: create the projectUpdate the layoutUpdate strings.xml...... and add the method to the activityCreate the second activity and layoutWhat just happened?Welcome to the Android manifest fileEvery activity needs to be declaredAn intent is a type of message Use an intent to start the second activityWhat happens when you run the appThe story continues...Test drive the appPass text to a second activityLet’s start with the layoutUpdate the text view propertiesputExtra() puts extra info in an intentHow to retrieve extra information from an intentUpdate the CreateMessageActivity codeGet ReceiveMessageActivity to use the information in the intentWhat happens when the user clicks the Send Message buttonTest drive the appWe can change the app to send messages to other peopleHow Android apps workIntents can start activities in other appsBut we don’t know what apps are on the user’s deviceHere’s what you’re going to doCreate an intent that specifies an actionHow to create the intentAdding extra informationChange the intent to use an actionWhat happens when the code runsThe story continues...The intent filter tells Android which activities can handle which actionsHow Android uses the intent filterYou need to run your app on a REAL device1. Enable USB debugging on your device2. Set up your system to detect your device3. Plug your device into your computer with a USB cableRunning your app on a real device (continued)4. Stop your app running on the emulator5. Run your app on the physical deviceAnd here’s the app running on the physical deviceTest drive the appIf you have one activityIf you have more than one activityWhat if you ALWAYS want your users to choose an activity?Intent.createChooser() displays a chooser dialogWhat happens when you call createChooser()The story continues...Change the code to create a chooserUpdate strings.xml...... and update the onSendMessage() methodTest drive the appIf you have one activityIf you have more than one activityIf you have NO matching activitiesChapter 3 Your Android Toolbox
4. The Activity Lifecycle: Being an Activity
How do activities really work?The Stopwatch appCreate a new project for the Stopwatch appAdd String resourcesUpdate the stopwatch layout codeThe layout code (continued)How the activity code will workAdd code for the buttonsThe runTimer() methodHandlers allow you to schedule codeThe post() methodThe postDelayed() methodThe full runTimer() codeThe full StopwatchActivity codeThe activity code (continued)What happens when you run the appThe story continuesTest drive the appBut there’s just one problem...What just happened?Rotating the screen changes the device configurationThe states of an activityThe activity lifecycle: from create to destroyYour activity inherits the lifecycle methodsSave the current state...... then restore the state in onCreate()The updated StopwatchActivity codeWhat happens when you run the appThe story continuesTest drive the appThere’s more to an activity’s life than create and destroyStart, stop, and restartThe activity lifecycle: the visible lifetimeWe need to implement two more lifecycle methodsImplement onStop() to stop the timerThe updated StopwatchActivity codeWhat happens when you run the appTest drive the appWhat if an app is only partially visible?The activity lifecycle: the foreground lifetimeStop the stopwatch if the activity’s pausedImplement the onPause() and onResume() methodsThe complete StopwatchActivity codeThe activity code (continued)The activity code (continued)What happens when you run the appTest drive the appYour handy guide to the lifecycle methodsChapter 4 Your Android Toolbox
5. Views and View Groups: Enjoy the View
Your user interface is made up of layouts and GUI componentsLinearLayout displays views in a single row or columnYou MUST set the layout’s width and heightOrientation is vertical or horizontalPadding adds spaceAdd a dimension resource file for consistent padding across layoutsA linear layout displays views in the order they appear in the layout XMLUse margins to add distance between viewsLet’s change up a basic linear layoutHere’s the starting point for the linear layoutMake a view streeeeetch by adding weightAdding weight to one viewAdding weight to multiple viewsGravity controls the position of a view’s contentsTest driveValues you can use with the android:gravity attributelayout_gravity controls the position of a view within a layoutMore values you can use with the android:layout_gravity attributeThe full linear layout codeLinearLayout: a summaryHow you specify a linear layoutViews get displayed in the order they’re listed in the codeStretch views using weightUse gravity to specify where a view’s contents appear within a viewUse layout_gravity to specify where a view appears in its available spaceFrame layouts stack their viewsHow you define a frame layoutCreate a new projectAdd an image to your projectA frame layout stacks views in the order they appear in the layout XMLPosition views in the layout using layout_gravityYou can nest layoutsThe full code to nest a layoutFrameLayout: a summaryHow you specify a frame layoutViews are stacked in the order they appearUse layout_gravity to specify where a view appearsLayouts and GUI components have a lot in commonGUI components are a type of ViewLayouts are a type of View called a ViewGroupWhat being a view buys youGetting and setting propertiesSize and positionFocus handlingEvent handling and listenersA layout is really a hierarchy of ViewsPlaying with viewsText viewDefining it in XMLUsing it in your activity codeEditable text viewDefining it in XMLUsing it in your activity codeButtonDefining it in XMLUsing it in your activity codeToggle buttonDefining it in XMLUsing it in your activity codeSwitchDefining it in XMLUsing it in your activity codeCheckboxesDefining them in XMLUsing them in your activity codeCheckboxes (continued)Radio buttonsDefining them in XMLUsing them in your activity codeRadio buttons (continued)SpinnerDefining it in XMLUsing it in your activity codeImage viewAdding an image to your projectImage view: the layout XMLUsing image views in your activity codeAdding images to buttonsDisplaying text and an image on a buttonImage buttonDefining it in XMLUsing it in your activity codeScroll viewToastsUsing it in your activity codeChapter 5 Your Android Toolbox

6. Constraint Layouts: Put Things in Their Place
Nested layouts can be inefficientIntroducing the constraint layoutYou design constraint layouts VISUALLYCreate a new projectMake sure your project includes the Constraint Layout LibraryAdd the String resources to strings.xmlChange activity_main.xml to use a constraint layoutUse the blueprint toolPosition views using constraintsWe’ll add a horizontal constraint to the buttonAdd a vertical constraintChanging the view’s marginsChanges to the blueprint are reflected in the XMLHow to center viewsAdjust a view’s position by updating its biasHow to change a view’s size1. Make the view a fixed size2. Make it just big enough3. Match the view’s constraints4. Specify the width:height ratioHow to align viewsLet’s build a real layoutFirst, add the top line of viewsGet the design editor to infer the constraintsThe Infer Constraints feature guesses which constraints to addAdd the next line to the blueprint...... and then add the buttonFinally, add a view for the messageTest drive the appChapter 6 Your Android Toolbox
7. List Views and Adapters: Getting Organized
Every app starts with ideasOrganize your ideas: top-level, category, and detail/edit activitiesTop-level activitiesCategory activitiesDetail/edit activitiesNavigating through the activitiesTop-level activities go at the topCategory activities go between top-level and detail/edit activitiesDetail/edit activitiesUse list views to navigate to dataWe’re going to build part of the Starbuzz appThe top-level activityThe drink category activityThe drink detail activityHow the user navigates through the appThe Starbuzz app structureHere’s what we’re going to doCreate the projectThe Drink classThe image filesThe top-level layout contains an image and a listUse a list view to display the list of optionsHow to define a list view in XMLThe full top-level layout codeTest driveGet list views to respond to clicks with a listenerOnItemClickListener listens for item clicksSet the listener to the list viewThe full TopLevelActivity.java codeTopLevelActivity.java (continued)What the TopLevelActivity.java code doesWhere we’ve got toA category activity displays the data for a single categoryCreate DrinkCategoryActivityUpdate activity_drink_category.xmlFor nonstatic data, use an adapterConnect list views to arrays with an array adapterAdd the array adapter to DrinkCategoryActivityWhat happens when you run the codeTest drive the appApp review: where we areHow we handled clicks in TopLevelActivityPass the ID of the item that was clicked by adding it to an intentThe full DrinkCategoryActivity codeA detail activity displays data for a single recordRetrieve data from the intentUpdate the views with the dataThe DrinkActivity codeWhat happens when you run the appThe story continuesTest drive the appChapter 7 Your Android Toolbox
8. Support Libraries and App Bars: Taking Shortcuts
Great apps have a clear structureTop-level screensCategory screensDetail/edit screensThey also have great shortcutsDifferent types of navigationHere’s what we’re going to doAdd an app bar by applying a themeSupport libraries allow you to use new features in older versions of AndroidCreate the Pizza appAdd the v7 AppCompat Support LibraryAppCompatActivity lets you use AppCompat themesMainActivity needs to be an AppCompatActivityAndroidManifest.xml can change your app bar’s appearanceHow to apply a theme1. Hardcoding the theme2. Using a style to apply the themeDefine styles in a style resource fileTheme galleryCustomize the look of your appDefine colors in a color resource fileThe code for activity_main.xmlTest drive the appActionBar vs. ToolbarHow to add a toolbar1. Add the AppCompat Support Library2. Extend the AppCompatActivity class3. Remove the app bar4. Add a toolbar to the layoutAdd the toolbar to the layout...... or define the toolbar as a separate layoutInclude the toolbar in the activity’s layout5. Set the toolbar as the activity’s app barTest drive the appAdd actions to the app barCreate OrderActivityUpdate activity_order.xmlUpdate OrderActivity.javaAdd a String resource for the activity’s titleChange the app bar text by adding a labelThe code for AndroidManifest.xmlHow to add an action to an app bar1. Add the action’s resourcesAdd the iconAdd the action’s title as a String resource2. Create the menu resource fileControl the action’s appearance3. Add the menu to the app bar with the onCreateOptionsMenu() method4. React to action item clicks with the onOptionsItemSelected() methodThe full MainActivity.java codeTest drive the appBut how do we get back to MainActivity?Enable Up navigationSet an activity’s parentAdding the Up buttonTest drive the appSharing content on the app barYou share the content with an intentAdd a share action provider to menu_main.xmlSpecify the content with an intentThe full MainActivity.java codeThe MainActivity.java code (continued)Test drive the appChapter 8 Your Android Toolbox
9. Fragments: Make It Modular
Your app needs to look great on ALL devicesOn a phone:On a tablet:Your app may need to behave differently tooOn a phone:On a tablet:But that means you might duplicate codeFragments allow you to reuse codeA fragment has a layoutThe phone version of the appHere’s what we’re going to doCreate the project and activitiesAdd the AppCompat Support LibraryAdd a button to MainActivity’s layoutMake the button respond to clicksHow to add a fragment to your projectWhat fragment code looks likeThe fragment’s onCreateView() methodFragment layout code looks just like activity layout codeAdd a fragment to an activity’s layoutSimplify the layoutSupport Library fragments need activities that extend FragmentActivityWhat the code doesThe story continuesTest drive the appGet the fragment and activity to interactThe Workout classPass the workout ID to the fragmentUse the fragment manager to manage fragmentsGet the activity to set the workout IDActivity states revisitedThe fragment lifecycleFragments inherit lifecycle methodsSet the view’s values in the fragment’s onStart() methodWhat happens when the code runsThe story continuesTest drive the appWhere we’ve got toWe need to create a fragment with a listA list fragment is a fragment that contains only a listHow to create a list fragmentAdapters revisitedOur previous array adapterA fragment isn’t a subclass of ContextThe updated WorkoutListFragment codeDisplay WorkoutListFragment in the MainActivity layoutThe code for activity_main.xmlWhat happens when the code runsThe story continuesTest drive the appConnect the list to the detailWe need to decouple the fragment by using an interfaceWhat WorkoutListFragment needs to do1. Define the listener interface2. Register the listener3. Respond to clicksThe code for WorkoutListFragment.javaMainActivity needs to implement the interfaceDetailActivity needs to pass the ID to WorkoutDetailFragmentWhat happens when the code runsThe story continues...Test drive the appChapter 9 Your Android ToolboxFragment lifecycle methods
10. Fragments for Larger Interfaces: Different Size, Different Interface
The Workout app looks the same on a phone and a tabletDesigning for larger interfacesThe phone version of the appThe tablet version of the appHere’s what we’re going to doCreate a tablet AVDOpen the Android Virtual Device ManagerSelect the hardwareCreating a tablet AVD (continued)Select a system imageCreating a tablet AVD (continued)Verify the AVD configurationPut screen-specific resources in screen-specific foldersThe different folder optionsTablets use layouts in the layout-large folderThe layout-large version of the layout needs to display two fragmentsWhat the updated code doesTest drive the appWe need to change the itemClicked() codeBut how do we update the workout details?You want fragments to work with the Back buttonWelcome to the back stackA back stack scenarioBack stack transactions don’t have to be activitiesDon’t update—instead, replaceUse a frame layout to replace fragments programmaticallyUse layout differences to tell which layout the device is usingThe revised MainActivity codeUsing fragment transactions1. Begin the transaction2. Specify the changes3. Commit the transactionThe updated MainActivity codeWhat happens when the code runsThe story continues...Test drive the appRotating the tablet breaks the appSaving an activity’s state (revisited)Fragments can lose state tooSave the fragment’s state...... then use onCreate() to restore the stateThe updated code for WorkoutDetailFragment.javaWorkoutDetailFragment.java (continued)Test drive the appChapter 10 Your Android Toolbox
11. Dynamic Fragments: Nesting Fragments
Adding dynamic fragmentsHere’s what we’re going to doThe new version of the appCreate TempActivityTempActivity needs to extend AppCompatActivityWe’ll add a new stopwatch fragmentFragments and activities have similar lifecycles...... but the methods are slightly differentThe StopwatchFragment.java codeStopwatchFragment.java (continued)StopwatchFragment.java (continued)The StopwatchFragment layoutThe StopwatchFragment layout (continued)The StopwatchFragment layout uses String valuesAdd StopwatchFragment to TempActivity’s layoutTest drive the appThe app crashes if you click on a buttonLet’s look at the StopwatchFragment layout codeThe onClick attribute calls methods in the activity, not the fragmentHow to make button clicks call methods in the fragment1. Remove the onClick attributes from the fragment’s layout2. Change the onClick... method signatures3. Make the fragment implement OnClickListenerThe StopwatchFragment onClick() methodAttach the OnClickListener to the buttonsThe StopwatchFragment codeThe StopwatchFragment code (continued)The StopwatchFragment code (continued)Test drive the appRotating the device resets the stopwatchUse <fragment> for static fragments...... but dynamic fragments need a fragment transactionChange activity_temp.xml to use a FrameLayoutAdd a fragment transaction to TempActivity.javaThe full code for TempActivity.javaTest drive the appAdd the stopwatch to WorkoutDetailFragmentWhat we’re going to doStart MainActivity when the app launchesAdd a FrameLayout where the fragment should appearSo far, we’ve only used fragment transactions in activitiesUsing fragment transactions in fragments uses most of the same codeUsing getFragmentManager() creates extra transactions on the back stackUsing getChildFragmentManager() creates nested transactions insteadWhat getChildFragmentManager() fragment transaction code looks likeThe full WorkoutDetailFragment.java codeThe full code (continued)Test drive the appTest drive (continued)Chapter 11 Your Android Toolbox
12. Design Support Library: Swipe Right
The Bits and Pizzas app revisitedThe app structureHere’s what we’re going to doCreate TopFragmentCreate PizzaFragmentCreate PastaFragmentCreate StoresFragmentUse a view pager to swipe through fragmentsWhat view pager layout code looks likeAdd a view pager to MainActivity’s layoutTell a view pager about its pages using a fragment pager adapterThe code for our fragment pager adapterAttach the fragment pager adapter to the view pagerThe full code for MainActivity.javaThe MainActivity.java code (continued)The MainActivity.java code (continued)Test drive the appAdd tab navigation to MainActivityHow to add tabs to your layoutAdd tabs to MainActivity’s layoutLink the tab layout to the view pagerThe full code for MainActivity.javaThe MainActivity.java code (continued)The MainActivity.java code (continued)Test drive the appThe Design Support Library helps you implement material designHere’s what we’ll doMake the toolbar respond to scrollsUse a CoordinatorLayout to coordinate animations between viewsAdd a coordinator layout to MainActivity’s layoutHow to coordinate scroll behaviorMark the view the user will scrollTell the toolbar to respond to scroll eventsThe code to enable to toolbar to scrollAdd scrollable content to TopFragmentAdd String and image resourcesUse a nested scroll view to make layout content scrollableHow we’ll structure TopFragment’s layoutThe full code for fragment_top.xmlTest drive the appAdd a collapsing toolbar to OrderActivityFirst add some String resourcesHow to create a plain collapsing toolbarNested scroll view attributesCollapsing toolbar layout attributesApp bar layout attributesToolbar attributesThe full code to add a collapsing toolbar to activity_order.xmlThe activity_order.xml code (continued)Test drive the appYou can add images to collapsing toolbars tooHow to add an image to a collapsing toolbarThe updated code for activity_order.xmlThe activity_order.xml code (continued)Test drive the appFABs and snackbarsWe’ll add a FAB and snackbar to OrderActivityAdd the icon for the FABHow to add a FAB to your layoutThe updated code for activity_order.xmlThe activity_order.xml code (continued)Add the onClickDone() method to OrderActivityHow to create a snackbarThe full code for OrderActivity.javaTest drive the appChapter 12 Your Android Toolbox
13. Recycler Views and Card Views: Get Recycling
There’s still work to do on the Bits and Pizzas appRecycler views from 10,000 feetHere’s what we’re going to doAdd the pizza dataAdd the Pizza classDisplay the pizza data in a cardAdd the CardView and RecyclerView Support LibrariesHow to create a card viewThe full card_captioned_image.xml codeHow our recycler view adapter will workAdd a recycler view adapterTell the adapter what data it should work with...... and implement the getItemCount() methodDefine the adapter’s view holderOverride the onCreateViewHolder() methodAdd the data to the card viewsThe full code for CaptionedImagesAdapter.javaThe full CaptionedImagesAdapter.java code (continued)Create the recycler viewAdd a layout for PizzaFragmentAdd the RecyclerView to PizzaFragment’s layoutGet the recycler view to use the adapterThe full PizzaFragment.java codeA recycler view uses a layout manager to arrange its viewsSpecify the layout managerLinear layout managerGrid layout managerStaggered grid layout managerThe full PizzaFragment.java codeWhat happens when the code runsThe story continuesTest drive the appMake the recycler view respond to clicksCreate PizzaDetailActivityWhat PizzaDetailActivity needs to doUpdate AndroidManifest.xml to give PizzaDetailActivity a parentThe code for PizzaDetailActivity.javaGet a recycler view to respond to clicksYou can listen for view events from the adapterKeep your adapters reusableDecouple your adapter with an interfaceAdd the interface to the adapterThe CaptionedImagesAdapter.java code (continued)Implement the listener in PizzaFragment.javaThe PizzaFragment.java code (continued)Test drive the appChapter 13 Your Android Toolbox
14. Navigation Drawers: Going Places
Tab layouts allow easy navigation...... but navigation drawers let you show more optionsWe’re going to create a navigation drawer for a new email appNavigation drawers deconstructedHere’s what we’re going to doCreate the CatChat projectAdd the v7 AppCompat and Design Support LibrariesCreate InboxFragmentCreate DraftsFragmentCreate SentItemsFragmentCreate TrashFragmentCreate a toolbar layoutUpdate the app’s themeCreate HelpActivityCreate FeedbackActivityWe need to build a navigation drawerCreate the navigation drawer’s headerAdd the image fileAdd the String resourcesThe full nav_header.xml codeThe drawer gets its options from a menuWe need to create a menu with two sectionsAdd items in the order you want them to appear in the drawerHow to group items togetherWe’ll use a group for the first sectionAdd the support section as a submenuThe full menu_nav.xml codeHow to create a navigation drawerThe full code for activity_main.xmlAdd InboxFragment to MainActivity’s frame layoutTest drive the appWhat the activity code needs to doAdd a drawer toggleRespond to the user clicking items in the drawerImplement the onNavigationItemSelected() methodClose the drawer when the user presses the Back buttonThe full MainActivity.java codeMainActivity.java (continued)MainActivity.java (continued)Test drive the appChapter 14 Your Android Toolbox
15. SQLite Databases: Fire Up the Database
Back to StarbuzzAndroid uses SQLite databases to persist dataWhere’s the database stored?Android comes with SQLite classesThe SQLite HelperThe SQLite DatabaseCursorsThe current Starbuzz app structureLet’s change the app to use a databaseThe SQLite helper manages your databaseCreate the SQLite helperSpecify the databaseInside a SQLite databaseStorage classes and data typesYou create tables using Structured Query Language (SQL)The onCreate() method is called when the database is createdInsert data using the insert() methodInsert multiple recordsThe StarbuzzDatabaseHelper codeWhat the SQLite helper code doesWhat if you need to make changes to the database?SQLite databases have a version numberWhat happens when you change the version numberScenario 1: A first-time user installs the appScenario 2: an existing user installs the new versionUpgrade your database with onUpgrade()Downgrade your database with onDowngrade()Let’s upgrade the databaseThe SQLite helper code (continued)Upgrade an existing databaseHow to update recordsUpdate records with the update() methodApply conditions to multiple columnsDelete records with the delete() methodChange the database structureAdd new columns to tables using SQLRenaming tablesDelete tables by dropping themExecute the SQL using execSQL()The full SQLite helper codeThe SQLite helper code (continued)What happens when the code runsChapter 15 Your Android Toolbox
16. Basic Cursors: Getting Data Out
The story so far...The new Starbuzz app structureWhat we’ll do to change DrinkActivity to use the Starbuzz databaseThe current DrinkActivity codeGet a reference to the databaseGet data from the database with a cursorReturn all the records from a tableReturn records in a particular orderReturn selected recordsThe DrinkActivity code so farTo read a record from a cursor, you first need to navigate to itNavigate cursorsGet cursor valuesFinally, close the cursor and the databaseThe DrinkActivity codeThe DrinkActivity code (continued)What we’ve done so farWhat we’ll do to change DrinkCategoryActivity to use the Starbuzz databaseThe current DrinkCategoryActivity codeGet a reference to the Starbuzz database...... then create a cursor that returns the drinksHow do we replace the array data in the list view?A simple cursor adapter maps cursor data to viewsHow to use a simple cursor adapterClose the cursor and databaseThe story continuesThe revised code for DrinkCategoryActivityThe DrinkCategoryActivity code (continued)Test drive the appChapter 16 Your Android Toolbox
17. Cursors and Asynctasks: Staying in the Background
We want our Starbuzz app to update database dataWe’ll update DrinkActivity firstAdd a checkbox to DrinkActivity’s layoutDisplay the value of the FAVORITE columnRespond to clicks to update the databaseThe full DrinkActivity.java codeDrinkActivity.java (continued)DrinkActivity.java (continued)Test drive the appDisplay favorites in TopLevelActivityDisplay the favorite drinks in activity_top_level.xmlRefactor TopLevelActivity.javaWhat changes are needed for TopLevelActivity.java Ready Bake CodeThe new TopLevelActivity.java codeThe TopLevelActivity.java code (continued)The TopLevelActivity.java code (continued)Test drive the appCursors don’t automatically refreshChange the cursor with changeCursor()1. Define the cursor2. Get a reference to the cursor adapter3. Change the cursor using changeCursor()The revised TopLevelActivity.java codeThe TopLevelActivity.java code (continued)The TopLevelActivity.java code (continued)Test drive the appDatabases can make your app go in sloooow-moooo....Life is better when threads work togetherWhat code goes on which thread?AsyncTask performs asynchronous tasksThe onPreExecute() methodThe doInBackground() methodThe onProgressUpdate() methodThe onPostExecute() methodThe AsyncTask class parametersThe full UpdateDrinkTask classExecute the AsyncTask...... in DrinkActivity’s onFavoritesClicked() methodThe full DrinkActivity.java codeThe full DrinkActivity.java code (continued)The full DrinkActivity.java code (continued)The full DrinkActivity.java code (continued)Test drive the appChapter 17 Your Android ToolboxA summary of the AsyncTask steps
18. Started Services: At Your Service
Services work in the backgroundThere are three types of serviceWe’ll create a STARTED serviceCreate the projectUse the IntentService class to create a basic started serviceHow to log messagesThe full DelayedMessageService codeYou declare services in AndroidManifest.xmlAdd a button to activity_main.xmlYou start a service using startService()What happens when you run the appTest drive the appThe states of a started serviceThe started service lifecycle: from create to destroyYour service inherits the lifecycle methodsAndroid has a built-in notification serviceWe’ll use notifications from the AppCompat Support LibraryFirst create a notification builderAdd an action to tell the notification which activity to start when clickedIssue the notification using the built-in notification serviceThe full code for DelayedMessageService.javaThe DelayedMessageService.java code (continued)What happens when you run the codeThe story continuesTest drive the appChapter 18 Your Android Toolbox
19. Bound Services and Permissions: Bound Together
Bound services are bound to other componentsHere’s what we’re going to doCreate a new Odometer projectCreate a new serviceImplement a binderAdd a getDistance() method to the serviceUpdate MainActivity’s layoutWhat MainActivity needs to doCreate a ServiceConnectionThe onServiceConnected() methodThe onServiceDisconnected() methodUse bindService() to bind the serviceUse unbindService() to unbind from the serviceCall OdometerService’s getDistance() methodThe full MainActivity.java codeThe MainActivity.java code (continued)What happens when you run the codeThe story continuesThe story continuesTest drive the appThe states of a bound serviceThe bound service lifecycle: from create to destroyWe’ll use Android’s Location Services to return the distance traveledAdd the AppCompat Support LibraryDeclare the permissions you needAdd a location listener to OdometerServiceWe need a location manager and location providerCreate a location managerSpecify the location providerRequest location updates...... but first check that your app has permissionHere’s the updated OdometerService codeCalculate the distance traveledReturn the miles traveledStop the listener getting location updatesThe full OdometerService.java codeThe OdometerService.java code (continued)The OdometerService.java code (continued)Test drive the appGet the app to request permissionCheck permissions at runtimeAsk for permissions you don’t haveCheck for Location Services permissions in MainActivity’s onStart() methodCheck the user’s response to the permission requestIssue a notification if we’re denied permissionAdd notification code to onRequestPermissionsResults()The notification code (continued)The full code for MainActivity.javaThe MainActivity.java code (continued)The MainActivity.java code (continued)Test drive the appChapter 19 Your Android ToolboxLeaving 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 positionsPositioning views relative to the parent layoutPositioning views to the left or rightUse start and end to take language direction into accountAttributes for positioning views relative to the parent layoutPositioning views relative to other viewsAttributes for positioning views relative to other viewsA grid layout displays views in a gridHow you define a grid layoutAdding views to the grid layoutLet’s create a new grid layoutHere’s what we’re going to doWe’ll start with a sketchThe grid layout needs two columnsRow 0: add views to specific rows and columnsRow 1: make a view span multiple columnsRow 2: make a view span multiple columnsThe full code for the grid layoutThe grid layout code (continued)
B. Gradle: The Gradle Build Tool
What has Gradle have the Romans ever done for us?Your project’s Gradle filesYour app’s main Gradle fileGradle comes built in to your projectThe check taskThe clean installDebug taskThe androidDependencies taskgradlew <your-task-goes-here>Gradle plug-ins
C. Art: The Android Runtime
What is the Android runtime?Previously, Java code ran on the Oracle JVMART compiles code into DEX filesHow DEX files get createdDEX files are zipped into APK filesYou may need to sign the .apk fileSay hello to the Android Debug Bridge (adb)How apps come alive: running your APK fileAndroid converts the .dex code to OAT format
D. ADB: The Android Debug Bridge
adb: your command-line palRunning a shellUseful shell commandsKill the adb serverGet the output from logcatCopying files to/from your deviceAnd much, much more...
E. The Android Emulator: Speeding Things Up
Why the emulator is so slowHow to speed up your Android development1. Use a real device2. Use an emulator snapshot3. Use hardware acceleration4. Use Instant Run
F. Leftovers: The Top Ten Things (we didn’t cover)
1. Distributing your appPreparing your app for releaseReleasing your app2. Content providers3. Loaders4. Sync adapters5. Broadcasts6. The WebView class7. Settings8. AnimationProperty animationView animationsActivity transitions9. App widgets10. Automated testingUnit testsOn-device tests
Index

Content preview from Head First Android Development, 2nd Edition

Chapter 9. Fragments: Make It Modular

You’ve seen how to create apps that work in the same way no matter what device they’re running on.

But what if you want your app to look and behave differently depending on whether it’s running on a phone or a tablet? In this case you need fragments, modular code components that can be reused by different activities. We’ll show you how to create basic fragments and list fragments, how to add them to your activities, and how to get your fragments and activities to communicate with one another.

Your app needs to look great on ALL devices

One of the great things about Android development is that you can put the exact same app on devices with completely different screen sizes and processors, and have them run in exactly the same way. But that doesn’t mean that they always have to look exactly the same.

On a phone:

Take a look at this image of an app on a phone. It displays a list of workouts, and when you click on one, you are shown the details of that workout.

On a tablet:

On a larger device, like a tablet, you have a lot more screen space available, so it would be good if all the information appeared on the same screen. On the tablet, the list of workouts only goes partway across the screen, and when you click on an item, the details appear on the right. ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Head First Android Development, 3rd Edition

Publisher Resources

ISBN: 9781491974049Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business