PROFESSIONAL

Android 4 Application Development

CONTENTS

INTRODUCTION xxxvii

CHAPTER 1: HELLO, ANDROID 1

A Little Background 2

The Not-So-Distant Past 2

Living in the Future 3

What Android Isn't 3

Android: An Open Platform for Mobile Development 4

Native Android Applications 5

Android SDK Features 6

Access to Hardware, Including Camera, GPS, and Sensors 6

Data Transfers Using Wi-Fi, Bluetooth, and NFC 7

Maps, Geocoding, and Location-Based Services 7

Background Services 7

SQLite Database for Data Storage and Retrieval 8

Shared Data and Inter-Application Communication 8

Using Widgets and Live Wallpaper to Enhance the Home Screen 9

Extensive Media Support and 2D/3D Graphics 9

Cloud to Device Messaging 9

Optimized Memory and Process Management 10

Introducing the Open Handset Alliance 10

What Does Android Run On? 10

Why Develop for Mobile? 11

Why Develop for Android? 11

Factors Driving Android's Adoption 12

What Android Has That Other Platforms Don't Have 12

The Changing Mobile Development Landscape 13

Introducing the Development Framework 14

What Comes in the Box 14

Understanding the Android Software Stack 15

The Dalvik Virtual Machine 16

Android Application Architecture 17

Android Libraries 18

CONTENTS

CHAPTER 2: GETTING STARTED 19

Developing for Android 20

What You Need to Begin 20

Downloading and Installing the Android SDK 21

Downloading and Installing Updates to the SDK 23

Developing with Eclipse 23

Using the Android Developer Tools Plug-In for Eclipse 24

Using the Support Package 27

Creating Your First Android Application 28

Creating a New Android Project 28

Creating an Android Virtual Device 30

Creating Launch Configurations 30

Running and Debugging Your Android Application 33

Understanding Hello World 33

Types of Android Applications 36

Foreground Applications 36

Background Applications 37

Intermittent Applications 37

Widgets and Live Wallpapers 37

Developing for Mobile and Embedded Devices 38

Hardware-Imposed Design Considerations 38

Be Efficient 38

Expect Limited Capacity 39

Design for Different Screens 39

Expect Low Speeds, High Latency 40

At What Cost? 41

Considering the User's Environment 42

Developing for Android 43

Being Fast and Efficient 43

Being Responsive 44

Ensuring Data Freshness 45

Developing Secure Applications 45

Ensuring a Seamless User Experience 46

Providing Accessibility 47

Android Development Tools 47

The Android Virtual Device Manager 48

Android SDK Manager 49

The Android Emulator 50

xvili

The Dalvik Debug Monitor Service 50

The Android Debug Bridge 51

The Hierarchy Viewer and Lint Tool 51

Monkey and Monkey Runner 52

CHAPTER 3: CREATING APPLICATIONS AND ACTIVITIES 53

What Makes an Android Application? 54

Introducing the Application Manifest File 55

A Closer Look at the Application Manifest 56

Using the Manifest Editor 63

Externalizing Resources 64

Creating Resources 65

Simple Values 65

Styles and Themes 68

Drawables 68

Layouts 69

Animations 70

Menus 73

Using Resources 74

Using Resources in Code 74

Referencing Resources Within Resources 75

Using System Resources 76

Referring to Styles in the Current Theme 76

Creating Resources for Different Languages and Hardware 77

Runtime Configuration Changes 79

The Android Application Lifecycle 81

Understanding an Application's Priority and Its Process' States 82

Introducing the Android Application Class 83

Extending and Using the Application Class 83

Overriding the Application Lifecycle Events 84

A Closer Look at Android Activities 86

Creating Activities 86

The Activity Lifecycle 87

Activity Stacks 88

Activity States 88

Monitoring State Changes 89

Understanding Activity Lifetimes 91

Android Activity Classes 93

CONTENTS

CHAPTER 4: BUILDING USER INTERFACES 95

Fundamental Android Ul Design 96

Android User Interface Fundamentals 97

Assigning User Interfaces to Activities 97

Introducing Layouts 98

Defining Layouts 99

Using Layouts to Create Device Independent User Interfaces 100

Using a Linear Layout 100

Using a Relative Layout 101

Using a Grid Layout 102

Optimizing Layouts 103

Redundant Layout Containers Are Redundant 103

Avoid Using Excessive Views 105

Using Lint to Analyze Your Layouts 106

To-Do List Example 107

Introducing Fragments 114

Creating New Fragments 115

The Fragment Lifecycle 116

Fragment-Specific Lifecycle Events 119

Fragment States 119

Introducing the Fragment Manager 120

Adding Fragments to Activities 120

Using Fragment Transactions 121

Adding, Removing, and Replacing Fragments 122

Using the Fragment Manager to Find Fragments 122

Populating Dynamic Activity Layouts with Fragments 123

Fragments and the Back Stack 124

Animating Fragment Transactions 125

Interfacing Between Fragments and Activities 126

Fragments Without User Interfaces 126

Android Fragment Classes 128

Using Fragments for Your To-Do List 128

The Android Widget Toolbox 132

Creating New Views 133

Modifying Existing Views 133

Customizing Your To-Do List 135

Creating Compound Controls 138

Creating Simple Compound Controls Using Layouts 141

Creating Custom Views 141

Creating a New Visual Interface 142

Handling User Interaction Events 147

Supporting Accessibility in Custom Views

Creating a Compass View Example

Using Custom Controls

Introducing Adapters

Introducing Some Native Adapters

Customizing the Array Adapter

Using Adapters to Bind Data to a View

Customizing the To-Do List Array Adapter

Using the Simple Cursor Adapter

CHAPTER 5: INTENTS AND BROADCAST RECEIVERS

148

149

155

156

156

156

158

158

162

165

Introducing Intents

Using Intents to Launch Activities

Explicitly Starting New Activities

Implicit Intents and Late Runtime Binding

Determining If an Intent Will Resolve

Returning Results from Activities

Native Android Actions

Introducing LinkifyNative Linkify Link Types

Creating Custom Link Strings

Using the Match Filter

Using the Transform Filter

Using Intents to Broadcast Events

Broadcasting Events with Intents

Listening for Broadcasts with Broadcast Receivers

Broadcasting Ordered Intents

Broadcasting Sticky Intents

Introducing the Local Broadcast Manager

Introducing Pending Intents

Creating Intent Filters and Broadcast Receivers

Using Intent Filters to Service Implicit Intents

How Android Resolves Intent Filters

Finding and Using Intents Received Within an Activity

Passing on Responsibility

Selecting a Contact Example

Using Intent Filters for Plug-Ins and Extensibility

Supplying Anonymous Actions to Applications

Discovering New Actions from Third-Party Intent Receivers

Incorporating Anonymous Actions as Menu Items

Listening for Native Broadcast Intents

166

166

167

167

168

169

172

|174

174

175

176

176

177

177

178

180

181

182

182

183

183

185

186

187

187

193

193

194

195

196

xxi

CONTENTS

Monitoring Device State Changes Using Broadcast Intents 197

Listening for Battery Changes 197

Listening for Connectivity Changes 198

Listening for Docking Changes 199

Managing Manifest Receivers at Run Time 199

CHAPTER 6: USING INTERNET RESOURCES 201

Downloading and Parsing Internet Resources 201

Connecting to an Internet Resource 202

Parsing XML Using the XML Pull Parser 203

Creating an Earthquake Viewer 205

Using the Download Manager 210

Downloading Files 211

Customizing Download Manager Notifications 213

Specifying a Download Location 213

Cancelling and Removing Downloads 214

Querying the Download Manager 215

Using Internet Services 217

Connecting to Google App Engine 218

Best Practices for Downloading Data Without Drainingthe Battery 219

CHAPTER 7: FILES, SAVING STATE, AND PREFERENCES 221

Saving Simple Application Data 222

Creating and Saving Shared Preferences 222

Retrieving Shared Preferences 223

Creating a Settings Activity for the Earthquake Viewer 223

Introducing the Preference Framework and the

Preference Activity 231

Defining a Preference Screen Layout in XML 232

Native Preference Controls 234

Using Intents to Import System Preferences into Preference Screens 234

Introducing the Preference Fragment 235

Defining the Preference Fragment HierarchyUsing Preference Headers 235

Introducing the Preference Activity 236

Backward Compatibility and Preference Screens 237

Finding and Using the Shared Preferences Set by Preference Screens 238

Introducing On Shared Preference Change Listeners 238

xxii

CONTENTS

Creating a Standard Preference Activity for the Earthquake Viewer 238

Persisting the Application Instance State 242

Saving Activity State Using Shared Preferences 242

Saving and Restoring Activity Instance State

Using the Lifecycle Handlers 242

Saving and Restoring Fragment Instance State

Using the Lifecycle Handlers 243

Including Static Files as Resources 245

Working with the File System 246

File-Management Tools 246

Using Application-Specific Folders to Store Files 246

Creating Private Application Files 247

Using the Application File Cache 248

Storing Publicly Readable Files 248

CHAPTER 8: DATABASES AND CONTENT PROVIDERS 251

Introducing Android Databases 252

SQLite Databases 252

Content Providers 252

Introducing SQLite 253

Content Values and Cursors 253

Working with SQLite Databases 254

Introducing the SQLiteOpenHelper 255

Opening and Creating Databases Without the SQLite Open Helper 257

Android Database Design Considerations 257

Querying a Database 257

Extracting Values from a Cursor 259

Adding, Updating, and Removing Rows 260

Inserting Rows 260

Updating Rows 261

Deleting Rows 261

Creating Content Providers 262

Registering Content Providers 262

Publishing Your Content Provider's URI Address 263

Creating the Content Provider's Database 264

Implementing Content Provider Queries 264

Content Provider Transactions 266

Storing Files in a Content Provider 268

A Skeleton Content Provider Implementation 270

xxiii

CONTENTS

Using Content Providers 274

Introducing the Content Resolver 274

Querying Content Providers 274

Querying for Content Asynchronously Using the Cursor Loader 277

Introducing Loaders 277

Using the Cursor Loader 277

Adding, Deleting, and Updating Content 280

Inserting Content 280

Deleting Content 281

Updating Content 281

Accessing Files Stored in Content Providers 282

Creating a To-Do List Database and Content Provider 283

Adding Search to Your Application 290

Making Your Content Provider Searchable 291

Creating a Search Activity for Your Application 292

Making Your Search Activity the Default Search Provider

for Your Application 293

Performing a Search and Displaying the Results 294

Using the Search View Widget 297

Supporting Search Suggestions from a Content Provider 298

Surfacing Search Results in the Quick Search Box 301

Creating a Searchable Earthquake Content Provider 301

Creating the Content Provider 302

Using the Earthquake Provider 307

Searching the Earthquake Provider 310

Native Android Content Providers 316

Using the Media Store Content Provider 317

Using the Contacts Contract Content Provider 318

Introducing the Contacts Contract Content Provider 318

Reading Contact Details 319

Creating and Picking Contacts Using Intents 323

Modifying and Augmenting Contact Details Directly 324

Using the Calendar Content Provider 325

Querying the Calendar 325

Creating and Editing Calendar Entries Using Intents 327

Modifying Calendar Entries Directly 329

CHAPTER 9: WORKING IN THE BACKGROUND 331

Introducing Services 332

Creating and Controlling Services 332

Creating Services 332

xxiv

Executing a Service and Controlling Its Restart Behavior 333

Starting and Stopping Services 335

Self-Terminating Services 336

Binding Services to Activities 336

An Earthquake-Monitoring Service Example 338

Creating Foreground Services 343

Using Background Threads 345

Using AsyncTask to Run Asynchronous Tasks 345

Creating New Asynchronous Tasks 346

Running Asynchronous Tasks 347

Introducing the Intent Service 348

Introducing Loaders 349

Manual Thread Creation and GUI Thread Synchronization 349

Using Alarms 351

Creating, Setting, and Canceling Alarms 352

Setting Repeating Alarms 353

Using Repeating Alarms to Schedule Network Refreshes 354

Using the Intent Service to Simplify the EarthquakeUpdate Service 357

CHAPTER 10: EXPANDING THE USER EXPERIENCE 359

Introducing the Action Bar 360

Customizing the Action Bar 362

Modifying the Icon and Title Text 362

Customizing the Background 363

Enabling the Split Action Bar Mode 364

Customizing the Action Bar to Control Application Navigation Behavior 364

Configuring Action Bar Icon Navigation Behavior 365

Using Navigation Tabs | 366

Using Drop-Down Lists for Navigation 368

Using Custom Navigation Views 370

Introducing Action Bar Actions 370

Adding an Action Bar to the Earthquake Monitor 370

Creating and Using Menus and Action Bar Action Items 377

Introducing the Android Menu System 377

Creating a Menu 379

Specifying Action Bar Actions 380

Menu Item Options 381

Adding Action Views and Action Providers 382

Adding Menu Items from Fragments 383

Defining Menu Hierarchies in XML 384

CONTENTS

Updating Menu Items Dynamically 385

Handling Menu Selections 386

Introducing Submenus and Context Menus 387

Creating Submenus 387

Using Context Menus and Popup Menus 388

Refreshing the Earthquake Monitor 390

Going Full Screen 392

Introducing Dialogs 394

Creating a Dialog 395

Using the Alert Dialog Class 396

Using Specialized Input Dialogs 397

Managing and Displaying Dialogs Using Dialog Fragments 398

Managing and Displaying Dialogs Using Activity Event Handlers 400

Using Activities as Dialogs 401

Let's Make a Toast 401

Customizing Toasts 402

Using Toasts in Worker Threads 404

Introducing Notifications 405

Introducing the Notification Manager 406

Creating Notifications 407

Creating a Notification and Configuring the Status Bar Display 407

Using the Default Notification Sounds, Lights, and Vibrations 408

Making Sounds 408

Vibrating the Device 409

Flashing the Lights 409

Using the Notification Builder 410

Setting and Customizing the Notification Tray Ul 410

Using the Standard Notification Ul 411

Creating a Custom Notification Ul 412

Customizing the Ticker View 414

Configuring Ongoing and Insistent Notifications 415

Triggering, Updating, and Canceling Notifications 416

Adding Notifications and Dialogs to the Earthquake Monitor 418

CHAPTER 11: ADVANCED USER EXPERIENCE 425

Designing for Every Screen Size and Density 426

Resolution Independence 426

Using Density-Independent Pixels 426

Resource Qualifiers for Pixel Density 427

xxvl

CONTENTS

Supporting and Optimizing for Different Screen Sizes 427

Creating Scalable Layouts 428

Optimizing Layouts for Different Screen Types 428

Specifying Supported Screen Sizes 430

Creating Scalable Graphics Assets 431

Color Drawables 431

Shape Drawables 431

Gradient Drawables 432

NinePatch Drawables 434

Creating Optimized, Adaptive, and Dynamic Designs 434

Testing, Testing, Testing 435

Using Emulator Skins 435

Testing for Custom Resolutions and Screen Sizes 435

Ensuring Accessibility 436

Supporting Navigation Without a Touch Screen 436

Providing a Textual Description of Each View 436

Introducing Android Text-to-Speech 437

Using Speech Recognition 439

Using Speech Recognition for Voice Input 440

Using Speech Recognition for Search 441

Controlling Device Vibration 441

Working with Animations 442

Tweened View Animations 442

Creating Tweened View Animations 443

Applying Tweened Animations 443

Using Animation Listeners 444

Animating Layouts and View Groups 444

Creating and Using Frame-by-Frame Animations 445

Interpolated Property Animations 446

Creating Property Animations 447

Creating Property Animation Sets 449

Using Animation Listeners 449

Enhancing Your Views 450

Advanced Canvas Drawing 450

What Can You Draw? 450

Getting the Most from Your Paint 451

Improving Paint Quality with Anti-Aliasing 456

Canvas Drawing Best Practice 457

Advanced Compass Face Example 458

xxvii

CONTENTS

Hardware Acceleration 466

Managing Hardware Acceleration Use in Your Applications 466

Checking If Hardware Acceleration Is Enabled 467

Introducing the Surface View 467

When to Use a Surface View 467

Creating Surface Views 468

Creating 3D Views with a Surface View 470

Creating Interactive Controls 470

Using the Touch Screen 471

Using the Device Keys, Buttons, and D-Pad 475

Using the On Key Listener 475

Using the Trackball 476

Advanced Drawable Resources 476

Composite Drawables 476

Transformative Drawables 476

Layer Drawables 477

State List Drawables 478

Level List Drawables 479

Copy, Paste, and the Clipboard 479

Copying Data to the Clipboard 479

Pasting Clipboard Data 480

CHAPTER 12: HARDWARE SENSORS 481

Using Sensors and the Sensor Manager 482

Supported Android Sensors 482

Introducing Virtual Sensors 483

Finding Sensors 484

Monitoring Sensors 485

Interpreting Sensor Values 487

Monitoring a Device's Movement and Orientation 489

Determining the Natural Orientation of a Device 490

Introducing Accelerometers 491

Detecting Acceleration Changes 492

Creating a Gravitational Force Meter 494

Determining a Device's Orientation 497

Understanding the Standard Reference Frame 497

Calculating Orientation Using the Accelerometer and

Magnetic Field Sensors 498

Remapping the Orientation Reference Frame 500

Determining Orientation Using the Deprecated Orientation Sensor 501

xxvili

Creating a Compass and Artificial Horizon 502

Introducing the Gyroscope Sensor 505

Introducing the Environmental Sensors 506

Using the Barometer Sensor 506

Creating a Weather Station 508

CHAPTER 13: MAPS, GEOCODING, ANDLOCATION-BASED SERVICES 513

Using Location-Based Services 514

Using the Emulator with Location-Based Services 515

Updating Locations in Emulator Location Providers 515

Configuring the Emulator to Test Location-Based Services 516

Selecting a Location Provider 516

Finding Location Providers 517

Finding Location Providers by Specifying Criteria 517

Determining Location Provider Capabilities 518

Finding Your Current Location 519

Location Privacy 519

Finding the Last Known Location 519

Where Am I Example 519

Refreshing the Current Location 522

Tracking Your Location in Where Am I 525

Requesting a Single Location Update 527

Best Practice for Location Updates 527

Monitoring Location Provider Status and Availability 528

Using Proximity Alerts 530

Using the Geocoder 532

Reverse Geocoding 533

Forward Geocoding 534

Geocoding Where Am I 535

Creating Map-Based Activities 536

Introducing Map View and Map Activity 537

Getting Your Maps API Key 537

Getting Your Development/Debugging MD5 Fingerprint 537

Getting your Production/Release MD5 Fingerprint 538

Creating a Map-Based Activity 538

Maps and Fragments 540

Configuring and Using Map Views 541

Using the Map Controller 541

Mapping Where Am I 542

CONTENTS

Creating and Using Overlays 546

Creating New Overlays 546

Introducing Projections 547

Drawing on the Overlay Canvas 547

Handling Map Tap Events 548

Adding and Removing Overlays 549

Annotating Where Am I 549

Introducing My Location Overlay 553

Introducing Itemized Overlays and Overlay Items 554

Pinning Views to the Map and Map Positions 556

Mapping Earthquakes Example 558

CHAPTER 14: INVADING THE HOME SCREEN 565

Introducing Home Screen Widgets 566

Creating App Widgets 567

Creating the Widget XML Layout Resource 567

Widget Design Guidelines 567

Supported Widget Views and Layouts 568

Defining Your Widget Settings 569

Creating Your Widget Intent Receiver and Adding It to the

Application Manifest 570

Introducing the App Widget Manager and Remote Views 572

Creating and Manipulating Remote Views 572

Applying Remote Views to Running App Widgets 574

Using Remote Views to Add Widget Interactivity 575

Refreshing Your Widgets 577

Using the Minimum Update Rate 577

Using Intents 578

Using Alarms 579

Creating and Using a Widget Configuration Activity 580

Creating an Earthquake Widget 582

Introducing Collection View Widgets 587

Creating Collection View Widget Layouts 589

Creating the Remote Views Service 591

Creating a Remote Views Factory 591

Populating Collection View Widgets Using a Remote Views Service 594

Adding Interactivity to the Items Within a Collection View Widget 595

Binding Collection View Widgets to Content Providers 596

Refreshing Your Collection View Widgets 598

Creating an Earthquake Collection View Widget 598

XXX

Introducing Live Folders 605

Creating Live Folders 606

The Live Folder Content Provider . 606

The Live Folder Activity 608

Creating an Earthquake Live Folder 610

Surfacing Application Search Results Using the Quick Search Box 614

Surfacing Search Results to the Quick Search Box 614

Adding the Earthquake Example Search Results to the

Quick Search Box 615

Creating Live Wallpaper 616

Creating a Live Wallpaper Definition Resource 616

Creating a Wallpaper Service 617

Creating a Wallpaper Service Engine 618

CHAPTER 15: AUDIO, VIDEO, AND USING THE CAMERA 621

Playing Audio and Video 622

Introducing the Media Player 623

Preparing Audio for Playback 624

Initializing Audio Content for Playback 624

Preparing Video for Playback 625

Playing Video Using the Video View 625

Creating a Surface for Video Playback 626

Controlling Media Player Playback 629

Managing Media Playback Output 631

Responding to the Volume Controls 631

Responding to the Media Playback Controls 632

Requesting and Managing Audio Focus 635

Pausing Playback When the Output Changes 637

Introducing the Remote Control Client 637

Manipulating Raw Audio 640

Recording Sound with Audio Record 640

Playing Sound with Audio Track 642

Creating a Sound Pool 643

Using Audio Effects 645

Using the Camera for Taking Pictures 646

Using Intents to Take Pictures 646

Controlling the Camera Directly 648

Camera Properties 648

Camera Settings and Image Parameters 649

Controlling Auto Focus, Focus Areas, and Metering Areas 650

xxxi

CONTENTS

Using the Camera Preview 651

Detecting Faces and Facial Features 653

Taking a Picture 654

Reading and Writing JPEG EXIF Image Details 655

Recording Video 656

Using Intents to Record Video 656

Using the Media Recorder to Record Video 657

Configuring the Video Recorder 658

Previewing the Video Stream 660

Controlling the Recording 660

Creating a Time-Lapse Video 661

Using Media Effects 661

Adding Media to the Media Store 662

Inserting Media Using the Media Scanner 662

Inserting Media Manually 663

CHAPTER 16: BLUETOOTH, NFC, NETWORKS, AND WI-FI 665

Using Bluetooth 666

Managing the Local Bluetooth Device Adapter 666

Being Discoverable and Remote Device Discovery 669

Managing Device Discoverability 669

Discovering Remote Devices 671

Bluetooth Communications 673

Opening a Bluetooth Server Socket Listener 674

Selecting Remote Bluetooth Devices for Communications 675

Opening a Client Bluetooth Socket Connection 676

Transmitting Data Using Bluetooth Sockets 677

Managing Network and Internet Connectivity 679

Introducing the Connectivity Manager 679

Supporting User Preferences for Background Data Transfers 679

Finding and Monitoring Network Connectivity 681

Managing Wi-Fi 682

Monitoring Wi-Fi Connectivity 683

Monitoring Active Wi-Fi Connection Details 684

Scanning for Hotspots 684

Managing Wi-Fi Configurations 685

Creating Wi-Fi Network Configurations 685

Transferring Data Using Wi-Fi Direct 686

Initializing the Wi-Fi Direct Framework 686

Enabling Wi-Fi Direct and Monitoring Its Status 688

xxxli

Discovering Peers 689

Connecting with Peers 690

Transferring Data Between Peers 692

Near Field Communication 693

Reading NFC Tags 693

Using the Foreground Dispatch System 695

Introducing Android Beam 697

Creating Android Beam Messages 697

Assigning the Android Beam Payload 699

Receiving Android Beam Messages 699

CHAPTER 17: TELEPHONY AND SMS 701

Hardware Support for Telephony 701

Marking Telephony as a Required Hardware Feature 702

Checking for Telephony Hardware 702

Using Telephony 702

Initiating Phone Calls 703

Replacing the Native Dialer 703

Accessing Telephony Properties and Phone State 705

Reading Phone Device Details 705

Reading Network Details 706

Reading SIM Details 707

Reading Data Connection and Transfer State Details 707

Monitoring Changes in Phone State Using the Phone State Listener. 708

Monitoring Incoming Phone Calls 709

Tracking Cell Location Changes 710

Tracking Service Changes 710

Monitoring Data Connectivity and Data Transfer Status Changes 711

Using Intent Receivers to Monitor Incoming Phone Calls ( 712

Introducing SMS and MMS 713

Using SMS and MMS in Your Application 713

Sending SMS and MMS from Your Application Using Intents 713

Sending SMS Messages Using the SMS Manager 714

Sending Text Messages 715

Tracking and Confirming SMS Message Delivery 715

Conforming to the Maximum SMS Message Size 717

Sending Data Messages 717

Listening for Incoming SMS Messages 717

Simulating Incoming SMS Messages in the Emulator 719

Handling Data SMS Messages 719

xxxifi

CONTENTS

Emergency Responder SMS Example 720

Automating the Emergency Responder 729

Introducing SIP and VOIP 737

CHAPTER 18: ADVANCED ANDROID DEVELOPMENT 739

Paranoid Android 740

Linux Kernel Security 740

Introducing Permissions 740

Declaring and Enforcing Permissions 741

Enforcing Permissions when Broadcasting Intents 742

Introducing Cloud to Device Messaging 743

C2DM Restrictions 743

Signing Up to Use C2DM 744

Registering Devices with a C2DM Server 744

Sending C2DM Messages to Devices 748

Receiving C2DM Messages 749

Implementing Copy Protection Using the License

Verification Library 750

Installing the License Verification Library 750

Finding Your License Verification Public Key 751

Configuring Your License Validation Policy 751

Performing License Validation Checks 752

Introducing In-App Billing 753

In-App Billing Restrictions 754

Installing the In-App Billing Library 754

Finding Your Public Key and Defining Your Purchasable Items 754

Initiating In-App Billing Transactions 755

Handling In-App Billing Purchase Request Responses 756

Using Wake Locks 757

Using AIDL to Support Inter-Process Communication for Services 759

Implementing an AIDL Interface 759

Making Classes Parcelable 759

Creating an AIDL Service Definition 762

Implementing and Exposing the AIDL Service Definition 762

Dealing with Different Hardware and Software Availability 765

Specifying Hardware as Required 766

Confirming Hardware Availability 766

Building Backward-Compatible Applications 766

Parallel Activities 767

Interfaces and Fragments 768

Optimizing Ul Performance with Strict Mode 769

xxxiv

CONTENTS

CHAPTER 19: MONETIZING, PROMOTING, AND DISTRIBUTING

APPLICATIONS 771

Signing and Publishing Applications 772

Signing Applications Using the Export Android Application Wizard 772

Distributing Applications 774

Introducing the Google Play 774

Getting Started with Google Play 775

Publishing Applications 776

Application Reports Within the Developer Console 778

Accessing Application Error Reports 778

An Introduction to Monetizing Your Applications 779

Application Marketing, Promotion, and Distribution Strategies 780

Application Launch Strategies 781

Promotion Within Google Play 781

Internationalization 782

Analytics and Referral Tracking 783

Using Google Analytics for Mobile Applications 784

Referral Tracking with Google Analytics 786

INDEX 787

xxxv