| Introduction |
|
xxxi | |
| Chapter 1 Hello, Android |
|
1 | (12) |
|
Android Application Development |
|
|
1 | (1) |
|
|
|
2 | (1) |
|
|
|
3 | (1) |
|
|
|
3 | (1) |
|
|
|
3 | (1) |
|
Pre-installed Android Applications |
|
|
4 | (1) |
|
|
|
5 | (1) |
|
What Does Android Run On? |
|
|
6 | (1) |
|
|
|
6 | (1) |
|
|
|
7 | (1) |
|
Introducing the Development Framework |
|
|
7 | (6) |
|
|
|
8 | (1) |
|
Understanding the Android Software Stack |
|
|
8 | (2) |
|
|
|
10 | (1) |
|
Android Application Architecture |
|
|
11 | (1) |
|
|
|
12 | (1) |
| Chapter 2 Getting Started |
|
13 | (44) |
|
Getting Started Developing Android Apps |
|
|
14 | (1) |
|
|
|
15 | (24) |
|
|
|
15 | (5) |
|
Creating Your First Android Application |
|
|
20 | (15) |
|
Getting Started Writing Android Apps Using Kotlin |
|
|
35 | (1) |
|
Using the Android Support Library Package |
|
|
36 | (3) |
|
Developing for Mobile and Embedded Devices |
|
|
39 | (9) |
|
Hardware-Imposed Design Considerations |
|
|
39 | (4) |
|
Considering the User's Environment |
|
|
43 | (1) |
|
|
|
44 | (4) |
|
Android Development Tools |
|
|
48 | (9) |
|
|
|
49 | (2) |
|
The Android Virtual Device Manager |
|
|
51 | (1) |
|
|
|
51 | (1) |
|
|
|
52 | (2) |
|
|
|
54 | (1) |
|
|
|
54 | (1) |
|
|
|
55 | (1) |
|
Monkey, Monkey Runner, and Espresso UI Testing |
|
|
55 | (1) |
|
|
|
56 | (1) |
| Chapter 3 Applications And Activities And Fragments, Oh My! |
|
57 | (38) |
|
Applications, Activities, and Fragments |
|
|
58 | (1) |
|
The Components of an Android Application |
|
|
58 | (1) |
|
The Android Application Life Cycle, Priority, and Process States |
|
|
59 | (2) |
|
Introducing the Android Application Class |
|
|
61 | (1) |
|
A Closer Look at Android Activities |
|
|
61 | (12) |
|
|
|
62 | (1) |
|
Using the AppCompatActivity |
|
|
63 | (1) |
|
|
|
64 | (7) |
|
Responding to Memory Pressure |
|
|
71 | (2) |
|
|
|
73 | (14) |
|
|
|
73 | (1) |
|
|
|
74 | (5) |
|
Introducing the Fragment Manager |
|
|
79 | (1) |
|
Adding Fragments to Activities |
|
|
79 | (6) |
|
Communicating Between Fragments and Activities |
|
|
85 | (1) |
|
Fragments Without User Interfaces |
|
|
86 | (1) |
|
Building an Earthquake Viewer Application |
|
|
87 | (8) |
| Chapter 4 Defining The Android Manifest And Gradle Build Files, And Externalizing Resources |
|
95 | (34) |
|
The Manifest, Build Files, and Resources |
|
|
96 | (1) |
|
Introducing the Android Manifest |
|
|
96 | (5) |
|
Configuring the Gradle Build |
|
|
101 | (6) |
|
|
|
101 | (1) |
|
Project Gradle Build File |
|
|
102 | (1) |
|
Module Gradle Build Files |
|
|
102 | (5) |
|
|
|
107 | (22) |
|
|
|
108 | (11) |
|
|
|
119 | (3) |
|
Creating Resources for Different Languages and Hardware |
|
|
122 | (4) |
|
Runtime Configuration Changes |
|
|
126 | (3) |
| Chapter 5 Building User Interfaces |
|
129 | (48) |
|
Fundamental Android Design |
|
|
130 | (1) |
|
Density-Independent Design |
|
|
130 | (1) |
|
Android User Interface Fundamentals |
|
|
131 | (1) |
|
Assigning User Interfaces to Activities |
|
|
132 | (1) |
|
|
|
132 | (11) |
|
|
|
134 | (2) |
|
Using Layouts to Create Device-Independent User Interfaces |
|
|
136 | (3) |
|
|
|
139 | (4) |
|
The Android Widget Toolbox |
|
|
143 | (1) |
|
Working with Lists and Grids |
|
|
144 | (6) |
|
Recycler View and Layout Managers |
|
|
145 | (1) |
|
|
|
146 | (3) |
|
Returning to the Earthquake Viewer Application |
|
|
149 | (1) |
|
|
|
150 | (5) |
|
|
|
151 | (1) |
|
Variables in Data Binding |
|
|
152 | (1) |
|
Data Binding for the Earthquake Viewer Application |
|
|
153 | (2) |
|
|
|
155 | (22) |
|
|
|
155 | (4) |
|
Creating Compound Controls |
|
|
159 | (2) |
|
Creating Simple Compound Controls as a Layout |
|
|
161 | (1) |
|
|
|
162 | (14) |
|
|
|
176 | (1) |
| Chapter 6 Intents And Broadcast Receivers |
|
177 | (34) |
|
Using Intents and Broadcast Receivers |
|
|
178 | (1) |
|
Using Intents to Launch Activities |
|
|
178 | (8) |
|
Explicitly Starting New Activities |
|
|
179 | (1) |
|
Implicit Intents and Late Runtime Binding |
|
|
179 | (1) |
|
Determining If an Intent Will Resolve |
|
|
180 | (1) |
|
Returning Results from Activities |
|
|
181 | (3) |
|
Using Platform-Native Actions to Launch Activities |
|
|
184 | (2) |
|
Creating Intent Filters to Receive Implicit Intents |
|
|
186 | (12) |
|
Defining an Intent Filter |
|
|
186 | (8) |
|
Using Intent Filters for Plug-Ins and Extensibility |
|
|
194 | (4) |
|
|
|
198 | (2) |
|
Native Linkify Link Types |
|
|
198 | (1) |
|
Creating Custom Link Strings |
|
|
199 | (1) |
|
|
|
200 | (1) |
|
Using the Transform Filter |
|
|
200 | (1) |
|
Using Intents to Broadcast Events |
|
|
200 | (7) |
|
Broadcasting Events with Intents |
|
|
201 | (1) |
|
Listening for Intent Broadcasts with Broadcast Receivers |
|
|
202 | (1) |
|
Registering Broadcast Receivers in Code |
|
|
203 | (1) |
|
Registering Broadcast Receivers in Your Application Manifest |
|
|
204 | (1) |
|
Managing Manifest Receivers at Run Time |
|
|
204 | (1) |
|
Monitoring Device State Changes Through Broadcast Intents |
|
|
205 | (2) |
|
Introducing the Local Broadcast Manager |
|
|
207 | (1) |
|
Introducing Pending Intents |
|
|
208 | (3) |
| Chapter 7 Using Internet Resources |
|
211 | (34) |
|
Connecting to the Internet |
|
|
211 | (1) |
|
Connecting, Downloading, and Parsing Internet Resources |
|
|
212 | (21) |
|
Why Build a Native Internet App? |
|
|
212 | (1) |
|
Connecting to an Internet Resource |
|
|
213 | (1) |
|
Performing Network Operations on Background Threads Using View Models, Live Data, and Asynchronous Tasks |
|
|
214 | (5) |
|
Parsing XML Using the XML Pull Parser |
|
|
219 | (1) |
|
Connecting the Earthquake Viewer to the Internet |
|
|
220 | (8) |
|
Parsing JSON Using the JSON Parser |
|
|
228 | (5) |
|
Using the Download Manager |
|
|
233 | (8) |
|
|
|
233 | (2) |
|
Customizing Download Manager Notifications |
|
|
235 | (2) |
|
Specifying a Download Location |
|
|
237 | (1) |
|
Canceling and Removing Downloads |
|
|
238 | (1) |
|
Querying the Download Manager |
|
|
238 | (3) |
|
Best Practices for Downloading Data Without Draining the Battery |
|
|
241 | (1) |
|
An Introduction to Internet Services and Cloud Computing |
|
|
242 | (3) |
| Chapter 8 Files, Saving State, And User Preferences |
|
245 | (36) |
|
Saving Files, States, and Preferences |
|
|
246 | (1) |
|
Saving and Restoring Activity and Fragment Instance State Using the Lifecycle Handlers |
|
|
246 | (2) |
|
Retaining Instance State with Headless Fragments and View Models |
|
|
248 | (4) |
|
View Models and Live Data |
|
|
248 | (3) |
|
|
|
251 | (1) |
|
Creating and Saving Shared Preferences |
|
|
252 | (1) |
|
Retrieving Shared Preferences |
|
|
253 | (1) |
|
Introducing On Shared Preference Change Listeners |
|
|
254 | (1) |
|
Configuring Auto Backup of Application Files and Shared Preferences |
|
|
254 | (2) |
|
|
|
256 | (5) |
|
Using the Preference Support Library |
|
|
256 | (1) |
|
Defining a Preference Screen Layout in XML |
|
|
257 | (3) |
|
Introducing the Preference Fragment |
|
|
260 | (1) |
|
Creating a Settings Activity for the Earthquake Monitor |
|
|
261 | (6) |
|
Including Static Files as Resources |
|
|
267 | (1) |
|
Working with the Filesystem |
|
|
267 | (7) |
|
|
|
267 | (1) |
|
Creating Files on Application-Specific Internal Storage |
|
|
268 | (1) |
|
Creating Files on Application-Specific External Storage |
|
|
268 | (2) |
|
Accessing Public Directories Using Scoped Directory Access |
|
|
270 | (4) |
|
Sharing Files Using File Provider |
|
|
274 | (1) |
|
|
|
274 | (1) |
|
Sharing a File Using a File Provider |
|
|
275 | (1) |
|
Receiving a File from a File Provider |
|
|
275 | (1) |
|
Accessing Files from Other Applications Using the Storage Access Framework |
|
|
275 | (3) |
|
Requesting Temporary Access to Files |
|
|
276 | (1) |
|
Requesting Persistent Access to Files |
|
|
277 | (1) |
|
Requesting Access to Directories |
|
|
277 | (1) |
|
|
|
278 | (1) |
|
Using URI-Based Permissions |
|
|
278 | (3) |
| Chapter 9 Creating And Using Databases |
|
281 | (36) |
|
Introducing Structured Data Storage in Android |
|
|
282 | (1) |
|
Storing Data Using the Room Persistence Library |
|
|
282 | (12) |
|
Adding the Room Persistence Library |
|
|
283 | (1) |
|
|
|
284 | (2) |
|
Persisting Complex Objects Using Type Convertors |
|
|
286 | (2) |
|
Defining Room Database Interactions Using Data Access Objects |
|
|
288 | (3) |
|
Performing Room Database Interactions |
|
|
291 | (1) |
|
Monitoring Query Result Changes with Live Data |
|
|
292 | (2) |
|
Persisting Earthquakes to a Database with Room |
|
|
294 | (4) |
|
Working with SQLite Databases |
|
|
298 | (10) |
|
Input Validation and SQL Injection |
|
|
299 | (1) |
|
Cursors and Content Values |
|
|
299 | (1) |
|
Defining a Database Contract |
|
|
300 | (1) |
|
Introducing the SQLiteOpenHelper |
|
|
300 | (2) |
|
Opening Databases with the SQLite Open Helper |
|
|
302 | (1) |
|
Opening and Creating Databases Without the SQLite Open Helper |
|
|
303 | (1) |
|
Adding, Updating, and Deleting Rows |
|
|
303 | (2) |
|
|
|
305 | (2) |
|
Extracting Values from a Cursor |
|
|
307 | (1) |
|
Introducing the Firebase Realtime Database |
|
|
308 | (9) |
|
Adding Firebase to Your App |
|
|
309 | (2) |
|
Defining a Firebase Database and Defining Access Rules |
|
|
311 | (2) |
|
Adding, Modifying, Deleting, and Querying Data from a Firebase Realtime Database |
|
|
313 | (4) |
| Chapter 10 Content Providers And Search |
|
317 | (60) |
|
Introducing Content Providers |
|
|
318 | (1) |
|
Why Should I Use Content Providers? |
|
|
318 | (1) |
|
Creating Content Providers |
|
|
319 | (11) |
|
Creating the Content Provider's Database |
|
|
320 | (1) |
|
Registering Content Providers |
|
|
321 | (1) |
|
Publishing Your Content Provider's URI Address |
|
|
321 | (1) |
|
Implementing Content Provider Queries |
|
|
322 | (3) |
|
Content Provider Transactions |
|
|
325 | (2) |
|
Sharing Files Using a Content Provider |
|
|
327 | (1) |
|
Adding Permission Requirements to Content Providers |
|
|
328 | (2) |
|
Accessing Content Providers with Content Resolvers |
|
|
330 | (11) |
|
Querying Content Providers |
|
|
330 | (3) |
|
|
|
333 | (1) |
|
Querying for Content Asynchronously with a Cursor Loader |
|
|
333 | (3) |
|
Adding, Deleting, and Updating Content |
|
|
336 | (2) |
|
Accessing Files Stored in Content Providers |
|
|
338 | (1) |
|
Accessing Permission-Restricted Content Providers |
|
|
339 | (2) |
|
Using Native Android Content Providers |
|
|
341 | (13) |
|
|
|
341 | (1) |
|
Using the Media Store Content Provider |
|
|
342 | (2) |
|
Using the Contacts Content Provider |
|
|
344 | (7) |
|
Using the Calendar Content Provider |
|
|
351 | (3) |
|
Adding Search to Your Application |
|
|
354 | (23) |
|
Defining Your Search Metadata |
|
|
354 | (1) |
|
Creating a Search Results Activity |
|
|
355 | (2) |
|
Searching a Content Provider |
|
|
357 | (3) |
|
Using the Search View Widget |
|
|
360 | (2) |
|
Providing Search Suggestions Using a Content Provider |
|
|
362 | (4) |
|
Searching the Earthquake Monitor Database |
|
|
366 | (11) |
| Chapter 11 Working In The Background |
|
377 | (56) |
|
Working in the Background |
|
|
378 | (1) |
|
|
|
379 | (6) |
|
Using Asynchronous Tasks to Run Tasks Asynchronously |
|
|
379 | (4) |
|
Manual Thread Creation Using Handler Threads |
|
|
383 | (2) |
|
Scheduling Background Jobs |
|
|
385 | (16) |
|
Creating a Job Service for the Job Scheduler |
|
|
386 | (2) |
|
Scheduling Jobs with the Job Scheduler |
|
|
388 | (3) |
|
Scheduling Jobs with the Firebase Job Dispatcher |
|
|
391 | (2) |
|
Scheduling Work with the Work Manager |
|
|
393 | (3) |
|
An Earthquake-Monitoring Job Service Example |
|
|
396 | (5) |
|
Using Notifications to Notify Users |
|
|
401 | (16) |
|
Introducing the Notification Manager |
|
|
401 | (1) |
|
Working with Notification Channels |
|
|
402 | (1) |
|
|
|
403 | (4) |
|
Setting a Notification's Priority |
|
|
407 | (4) |
|
Adding Notification Actions |
|
|
411 | (1) |
|
Adding Direct Reply Actions |
|
|
412 | (1) |
|
Grouping Multiple Notifications |
|
|
413 | (1) |
|
Adding Notifications to the Earthquake Monitor |
|
|
414 | (3) |
|
Using Firebase Cloud Messaging |
|
|
417 | (5) |
|
Triggering Notifications Remotely with Firebase Notifications |
|
|
418 | (3) |
|
Receiving Data with Firebase Cloud Messaging |
|
|
421 | (1) |
|
|
|
422 | (2) |
|
Creating, Setting, and Canceling Alarms |
|
|
423 | (1) |
|
|
|
424 | (1) |
|
|
|
424 | (9) |
|
|
|
425 | (2) |
|
Creating a Started Service |
|
|
427 | (6) |
| Chapter 12 Implementing The Android Design Philosophy |
|
433 | (30) |
|
Introducing the Android Design Philosophy |
|
|
434 | (1) |
|
Designing for Every Screen |
|
|
434 | (11) |
|
|
|
435 | (1) |
|
Supporting and Optimizing for Different Screen Sizes |
|
|
436 | (3) |
|
Creating Scalable Graphics Assets |
|
|
439 | (6) |
|
Introducing Material Design |
|
|
445 | (7) |
|
Thinking in Terms of Paper and Ink |
|
|
446 | (1) |
|
Using Color and Keylines as Guides |
|
|
447 | (2) |
|
Continuity Through Motion |
|
|
449 | (3) |
|
Material Design UI Elements |
|
|
452 | (11) |
|
|
|
452 | (3) |
|
Applying Material Design to the Earthquake Monitor |
|
|
455 | (1) |
|
Using Cards to Display Content |
|
|
456 | (4) |
|
|
|
460 | (3) |
| Chapter 13 Implementing A Modern Android User Experience |
|
463 | (38) |
|
|
|
464 | (1) |
|
Creating Consistent, Modern User Interfaces Using AppCompat |
|
|
464 | (3) |
|
Creating and Applying Themes Using AppCompat |
|
|
465 | (1) |
|
Creating Theme Overlays for Specific Views |
|
|
466 | (1) |
|
Adding a Menu and Actions to the App Bar |
|
|
467 | (5) |
|
|
|
467 | (1) |
|
Adding a Menu to an Activity |
|
|
468 | (1) |
|
Adding a Menu to a Fragment |
|
|
469 | (1) |
|
Updating Menu Items Dynamically |
|
|
469 | (1) |
|
|
|
470 | (1) |
|
Adding Action Views and Action Providers |
|
|
470 | (2) |
|
Going Beyond the Default App Bar |
|
|
472 | (5) |
|
Replacing Your App Bar with a Toolbar |
|
|
472 | (1) |
|
Advanced Scrolling Techniques for the Toolbar |
|
|
473 | (3) |
|
Incorporating Menus Without the App Bar |
|
|
476 | (1) |
|
Improving the Earthquake Monitor's App Bar |
|
|
477 | (2) |
|
|
|
479 | (13) |
|
|
|
479 | (3) |
|
Implementing a Bottom Navigation Bar |
|
|
482 | (3) |
|
Using a Navigation Drawer |
|
|
485 | (6) |
|
Combining Navigation Patterns |
|
|
491 | (1) |
|
Adding Tabs to the Earthquake Monitor |
|
|
492 | (4) |
|
Choosing the Right Level of Interruption |
|
|
496 | (5) |
|
|
|
497 | (1) |
|
|
|
498 | (1) |
|
Inline Interruptions with Snackbars |
|
|
499 | (2) |
| Chapter 14 Advanced Customization Of Your User Interface |
|
501 | (40) |
|
Expanding the User Experience |
|
|
502 | (1) |
|
|
|
502 | (1) |
|
Supporting Navigation Without a Touch Screen |
|
|
502 | (1) |
|
Providing a Textual Description of Each View |
|
|
503 | (1) |
|
Introducing Android Text-to-Speech |
|
|
503 | (2) |
|
|
|
505 | (3) |
|
Using Speech Recognition for Voice Input |
|
|
506 | (1) |
|
Using Speech Recognition for Search |
|
|
507 | (1) |
|
Controlling Device Vibration |
|
|
508 | (1) |
|
|
|
508 | (2) |
|
Working with Property Animations |
|
|
510 | (3) |
|
|
|
513 | (1) |
|
|
|
514 | (22) |
|
Creating Interactive Controls |
|
|
530 | (6) |
|
Composite Drawable Resources |
|
|
536 | (3) |
|
|
|
536 | (1) |
|
|
|
537 | (1) |
|
|
|
537 | (1) |
|
|
|
538 | (1) |
|
Copy, Paste, and the Clipboard |
|
|
539 | (2) |
|
Copying Data to the Clipboard |
|
|
539 | (1) |
|
|
|
539 | (2) |
| Chapter 15 Location, Contextual Awareness, And Mapping |
|
541 | (78) |
|
Adding Location, Maps, and Contextual Awareness to Your Applications |
|
|
542 | (1) |
|
Introducing Google Play Services |
|
|
542 | (4) |
|
Adding Google Play Services to Your Application |
|
|
543 | (2) |
|
Determining the Availability of Google Play Services |
|
|
545 | (1) |
|
Finding Device Location Using Google Location Services |
|
|
546 | (21) |
|
Using the Emulator to Test Location-Based Functionality |
|
|
548 | (1) |
|
Finding the Last Known Location |
|
|
549 | (2) |
|
|
|
551 | (4) |
|
Requesting Location Change Updates |
|
|
555 | (5) |
|
Changing Device Location Settings |
|
|
560 | (3) |
|
Updating the Location in the "Where Am I" Example |
|
|
563 | (3) |
|
Best Practices When Using Location |
|
|
566 | (1) |
|
Setting and Managing Geofences |
|
|
567 | (4) |
|
Using the Legacy Platform Location-Based Services |
|
|
571 | (9) |
|
Selecting a Location Provider |
|
|
572 | (2) |
|
Finding the Last Known Location |
|
|
574 | (1) |
|
Requesting Location Change Updates |
|
|
575 | (2) |
|
Best Practice for Using the Legacy Location-Based Services |
|
|
577 | (3) |
|
|
|
580 | (5) |
|
|
|
581 | (1) |
|
|
|
582 | (1) |
|
|
|
583 | (2) |
|
Creating Map-Based Activities |
|
|
585 | (20) |
|
Getting Your Maps API Key |
|
|
586 | (1) |
|
Creating a Map-Based Activity |
|
|
586 | (3) |
|
|
|
589 | (1) |
|
Changing the Camera Position with Camera Updates |
|
|
590 | (2) |
|
|
|
592 | (4) |
|
Displaying the Current Location with the My Location Layer |
|
|
596 | (1) |
|
Displaying Interactive Map Markers |
|
|
596 | (3) |
|
Adding Shapes to Google Maps |
|
|
599 | (3) |
|
Adding Image Overlays to Google Maps |
|
|
602 | (1) |
|
Adding Markers and Shapes to Where Am I |
|
|
602 | (3) |
|
Mapping the Earthquake Example |
|
|
605 | (4) |
|
Adding Contextual Awareness |
|
|
609 | (10) |
|
Connecting to the Google Play Services API Client and Obtaining API Keys |
|
|
610 | (2) |
|
Using Awareness Snapshots |
|
|
612 | (1) |
|
Setting and Monitoring Awareness Fences |
|
|
613 | (4) |
|
|
|
617 | (2) |
| Chapter 16 Hardware Sensors |
|
619 | (46) |
|
Introducing Android Sensors |
|
|
620 | (15) |
|
|
|
620 | (1) |
|
Understanding the Android Sensors |
|
|
621 | (2) |
|
Discovering and Identifying Sensors |
|
|
623 | (2) |
|
Determining Sensor Capabilities |
|
|
625 | (2) |
|
Wakeup and Non-Wakeup Sensors |
|
|
627 | (1) |
|
Monitoring Sensor Results |
|
|
627 | (5) |
|
Interpreting Sensor Values |
|
|
632 | (3) |
|
Testing Sensors with the Android Virtual Device and Emulator |
|
|
635 | (2) |
|
Best Practices for Working with Sensors |
|
|
637 | (1) |
|
Monitoring a Device's Movement and Orientation |
|
|
637 | (17) |
|
Determining the Natural Orientation of a Device |
|
|
638 | (1) |
|
Introducing Accelerometers |
|
|
639 | (1) |
|
Detecting Acceleration Changes |
|
|
640 | (2) |
|
Creating a Gravitational Force Meter |
|
|
642 | (3) |
|
Determining a Device's Orientation |
|
|
645 | (5) |
|
Creating a Compass and Artificial Horizon |
|
|
650 | (4) |
|
Using the Environmental Sensors |
|
|
654 | (5) |
|
Using the Barometer Sensor |
|
|
654 | (1) |
|
Creating a Weather Station |
|
|
655 | (4) |
|
|
|
659 | (3) |
|
User Activity Recognition |
|
|
662 | (3) |
| Chapter 17 Audio, Video, And Using The Camera |
|
665 | (48) |
|
Playing Audio and Video, and Using the Camera |
|
|
666 | (1) |
|
|
|
666 | (16) |
|
Introducing the Media Player |
|
|
667 | (2) |
|
Using Media Player for Video Playback |
|
|
669 | (3) |
|
Using ExoPlayer for Video Playback |
|
|
672 | (2) |
|
Requesting and Managing Audio Focus |
|
|
674 | (2) |
|
Pausing Playback When the Output Changes |
|
|
676 | (1) |
|
Responding to the Volume Controls |
|
|
677 | (1) |
|
Working with a Media Session |
|
|
678 | (4) |
|
Using the Media Router and Cast Application Framework |
|
|
682 | (4) |
|
Background Audio Playback |
|
|
686 | (9) |
|
Building an Audio Playback Service |
|
|
686 | (2) |
|
Using a Media Browser to Connect Your Activity to a Media Browser Service |
|
|
688 | (2) |
|
Life Cycle of a Media Browser Service |
|
|
690 | (1) |
|
Playing Audio as a Foreground Service |
|
|
691 | (2) |
|
Creating Media Style Notifications |
|
|
693 | (2) |
|
Using the Media Recorder to Record Audio |
|
|
695 | (2) |
|
Using the Camera for Taking Pictures |
|
|
697 | (9) |
|
Using Intents to Take Pictures |
|
|
697 | (2) |
|
Controlling the Camera Directly |
|
|
699 | (7) |
|
Reading and Writing JPEG EXIF Image Details |
|
|
706 | (1) |
|
|
|
706 | (4) |
|
Using Intents to Record Video |
|
|
707 | (1) |
|
Using the Media Recorder to Record Video |
|
|
707 | (3) |
|
Adding Media to the Media Store |
|
|
710 | (3) |
|
Inserting Media Using the Media Scanner |
|
|
710 | (1) |
|
|
|
711 | (2) |
| Chapter 18 Communicating With Bluetooth, NFC, And Wi-Fi Peer-To-Peer |
|
713 | (30) |
|
Networking and Peer-to-Peer Communication |
|
|
713 | (1) |
|
Transferring Data Using Bluetooth |
|
|
714 | (14) |
|
Managing the Local Bluetooth Device Adapter |
|
|
714 | (2) |
|
Being Discoverable and Remote Device Discovery |
|
|
716 | (4) |
|
|
|
720 | (5) |
|
|
|
725 | (1) |
|
|
|
726 | (2) |
|
Transferring Data Using Wi-Fi Peer-to-Peer |
|
|
728 | (7) |
|
Initializing the Wi-Fi Peer-to-Peer Framework |
|
|
729 | (2) |
|
|
|
731 | (1) |
|
|
|
732 | (1) |
|
Transferring Data Between Peers |
|
|
733 | (2) |
|
Using Near Field Communication |
|
|
735 | (3) |
|
|
|
735 | (1) |
|
Using the Foreground Dispatch System |
|
|
736 | (2) |
|
|
|
738 | (5) |
|
Creating Android Beam Messages |
|
|
739 | (1) |
|
Assigning the Android Beam Payload |
|
|
740 | (2) |
|
Receiving Android Beam Messages |
|
|
742 | (1) |
| Chapter 19 Invading The Home Screen |
|
743 | (44) |
|
Customizing the Home Screen |
|
|
743 | (1) |
|
Introducing Home Screen Widgets |
|
|
744 | (13) |
|
Defining the Widget Layout |
|
|
745 | (1) |
|
Defining Your Widget Size and Other Metadata |
|
|
746 | (2) |
|
|
|
748 | (1) |
|
Updating the Widget UI Using the App Widget Manager |
|
|
|
|
|
749 | (4) |
|
Forcing Refreshes of Your Widget Data and UI |
|
|
753 | (3) |
|
Creating and Using a Widget Configuration Activity |
|
|
756 | (1) |
|
Creating an Earthquake Widget |
|
|
757 | (6) |
|
Introducing Collection View Widgets |
|
|
763 | (14) |
|
Creating Collection View Widget Layouts |
|
|
764 | (1) |
|
Updating Collection View Items with a Remote Views Factory |
|
|
765 | (2) |
|
Updating Collection View Items with a Remote Views Service |
|
|
767 | (1) |
|
Populating Collection View Widgets Using a Remote Views Service |
|
|
768 | (1) |
|
Adding Interactivity to the Items Within a Collection View Widget |
|
|
769 | (1) |
|
Refreshing Your Collection View Widgets |
|
|
770 | (1) |
|
Creating an Earthquake Collection View Widget |
|
|
770 | (7) |
|
|
|
777 | (4) |
|
Creating a Live Wallpaper Definition Resource |
|
|
778 | (1) |
|
Creating a Wallpaper Service Engine |
|
|
778 | (2) |
|
Creating a Wallpaper Service |
|
|
780 | (1) |
|
|
|
781 | (6) |
|
|
|
783 | (1) |
|
|
|
784 | (1) |
|
Tracking App Shortcut Use |
|
|
785 | (2) |
| Chapter 20 Advanced Android Development |
|
787 | (38) |
|
|
|
788 | (1) |
|
|
|
788 | (5) |
|
|
|
788 | (1) |
|
Re-introducing Permissions |
|
|
789 | (3) |
|
Storing Keys in the Android Keystore |
|
|
792 | (1) |
|
Using the Fingerprint Sensor |
|
|
792 | (1) |
|
Dealing with Different Hardware and Software Availability |
|
|
793 | (4) |
|
Specifying Required Hardware |
|
|
794 | (1) |
|
Confirming Hardware Availability |
|
|
795 | (1) |
|
Building Backward-Compatible Applications |
|
|
795 | (2) |
|
Optimizing UI Performance with Strict Mode |
|
|
797 | (1) |
|
|
|
798 | (27) |
|
|
|
799 | (7) |
|
Sending and Receiving SMS Messages |
|
|
806 | (19) |
| Chapter 21 Releasing, Distributing, And Monitoring Applications |
|
825 | (38) |
|
|
|
826 | (2) |
|
Preparing Release Support Material |
|
|
826 | (1) |
|
Preparing Your Code for a Release Build |
|
|
827 | (1) |
|
Updating Application Metadata in Your Application Manifest |
|
|
828 | (2) |
|
Reviewing Application Installation Restrictions |
|
|
828 | (2) |
|
|
|
830 | (1) |
|
Signing Production Builds of Your Application |
|
|
830 | (5) |
|
Creating a Keystore and Signing Key with Android Studio |
|
|
832 | (1) |
|
Obtaining API Keys Based on Your Private Release Key |
|
|
833 | (1) |
|
Building and Signing a Production Release |
|
|
834 | (1) |
|
Distributing Your Application on the Google Play Store |
|
|
835 | (18) |
|
Introducing the Google Play Store |
|
|
835 | (1) |
|
Getting Started with the Google Play Store |
|
|
836 | (1) |
|
Creating an Application on the Google Play Store |
|
|
837 | (8) |
|
Publishing Your Application |
|
|
845 | (3) |
|
Monitoring Your Application in Production |
|
|
848 | (5) |
|
An Introduction to Monetizing Applications |
|
|
853 | (1) |
|
Application Marketing, Promotion, and Distribution Strategies |
|
|
854 | (2) |
|
Application Launch Strategies |
|
|
854 | (1) |
|
|
|
855 | (1) |
|
Using Firebase to Monitor Your Application |
|
|
856 | (7) |
|
Adding Firebase to Your Application |
|
|
856 | (1) |
|
|
|
857 | (3) |
|
Firebase Performance Monitoring |
|
|
860 | (3) |
| Index |
|
863 | |
Lisainfo e-raamatute kohta