Email RIS file
Bookmark
Report an Issue

Professional Android 4 application development [electronic resource] / Reto Meier

Author
Meier, Reto, 1978-
Additional Titles
Android 4 Application Development and Professional Android 3 Application Development
Published
Indianapolis, IN : John Wiley & Sons, [2012]
Copyright Date
©2012
Edition
Updated for Android 4.
Physical Description
1 online resource (xlii, 817 pages) : illustrations
Access Online

Availability

I Want It
I Want It

Finding items...

Contents
Machine generated contents note: ch. 1 Hello, Android -- A Little Background -- The Not-So-Distant Past -- Living in the Future -- What Android Isn't -- Android: An Open Platform for Mobile Development -- Native Android Applications -- Android SDK Features -- Access to Hardware, Including Camera, GPS, and Sensors -- Data Transfers Using Wi-Fi, Bluetooth, and NFC -- Maps, Geocoding, and Location-Based Services -- Background Services -- SQLite Database for Data Storage and Retrieval -- Shared Data and Inter-Application Communication -- Using Widgets and Live Wallpaper to Enhance the Home Screen -- Extensive Media Support and 2D/3D Graphics -- Cloud to Device Messaging -- Optimized Memory and Process Management -- Introducing the Open Handset Alliance -- What Does Android Run On? -- Why Develop for Mobile? -- Why Develop for Android? -- Factors Driving Android's Adoption -- What Android Has That Other Platforms Don't Have -- The Changing Mobile Development Landscape -- Introducing the Development Framework -- What Comes in the Box -- Understanding the Android Software Stack -- The Dalvik Virtual Machine -- Android Application Architecture -- Android Libraries -- ch. 2 Getting Started -- Developing for Android -- What You Need to Begin -- Downloading and Installing the Android SDK -- Downloading and Installing Updates to the SDK -- Developing with Eclipse -- Using the Android Developer Tools Plug-In for Eclipse -- Using the Support Package -- Creating Your First Android Application -- Creating a New Android Project -- Creating an Android Virtual Device -- Creating Launch Configurations -- Running and Debugging Your Android Application -- Understanding Hello World -- Types of Android Applications -- Foreground Applications -- Background Applications -- Intermittent Applications -- Widgets and Live Wallpapers -- Developing for Mobile and Embedded Devices -- Hardware-Imposed Design Considerations -- Be Efficient -- Expect Limited Capacity -- Design for Different Screens -- Expect Low Speeds, High Latency -- At What Cost? -- Considering the User's Environment -- Developing for Android -- Being Fast and Efficient -- Being Responsive -- Ensuring Data Freshness -- Developing Secure Applications -- Ensuring a Seamless User Experience -- Providing Accessibility -- Android Development Tools -- The Android Virtual Device Manager -- Android SDK Manager -- The Android Emulator -- The Dalvik Debug Monitor Service -- The Android Debug Bridge -- The Hierarchy Viewer and Lint Tool -- Monkey and Monkey Runner -- ch. 3 Creating Applications And Activities -- What Makes an Android Application? -- Introducing the Application Manifest File -- A Closer Look at the Application Manifest -- Using the Manifest Editor -- Externalizing Resources -- Creating Resources -- Simple Values -- Styles and Themes -- Drawables -- Layouts -- Animations -- Menus -- Using Resources -- Using Resources in Code -- Referencing Resources Within Resources -- Using System Resources -- Referring to Styles in the Current Theme -- Creating Resources for Different Languages and Hardware -- Runtime Configuration Changes -- The Android Application Lifecycle -- Understanding an Application's Priority and Its Process' States -- Introducing the Android Application Class -- Extending and Using the Application Class -- Overriding the Application Lifecycle Events -- A Closer Look at Android Activities -- Creating Activities -- The Activity Lifecycle -- Activity Stacks -- Activity States -- Monitoring State Changes -- Understanding Activity Lifetimes -- Android Activity Classes -- ch. 4 Building User Interfaces -- Fundamental Android UI Design -- Android User Interface Fundamentals -- Assigning User Interfaces to Activities -- Introducing Layouts -- Defining Layouts -- Using Layouts to Create Device Independent User Interfaces -- Using a Linear Layout -- Using a Relative Layout -- Using a Grid Layout -- Optimizing Layouts -- Redundant Layout Containers Are Redundant -- Avoid Using Excessive Views -- Using Lint to Analyze Your Layouts -- To-Do List Example -- Introducing Fragments -- Creating New Fragments -- The Fragment Lifecycle -- Fragment-Specific Lifecycle Events -- Fragment States -- Introducing the Fragment Manager -- Adding Fragments to Activities -- Using Fragment Transactions -- Adding, Removing, and Replacing Fragments -- Using the Fragment Manager to Find Fragments -- Populating Dynamic Activity Layouts with Fragments -- Fragments and the Back Stack -- Animating Fragment Transactions -- Interfacing Between Fragments and Activities -- Fragments Without User Interfaces -- Android Fragment Classes -- Using Fragments for Your To-Do List -- The Android Widget Toolbox -- Creating New Views -- Modifying Existing Views -- Customizing Your To-Do List -- Creating Compound Controls -- Creating Simple Compound Controls Using Layouts -- Creating Custom Views -- Creating a New Visual Interface -- Handling User Interaction Events -- 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 -- ch. 5 Intents And Broadcast Receivers -- 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 Linkify -- Native 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 -- Monitoring Device State Changes Using Broadcast Intents -- Listening for Battery Changes -- Listening for Connectivity Changes -- Listening for Docking Changes -- Managing Manifest Receivers at Run Time -- ch. 6 Using Internet Resources -- Downloading and Parsing Internet Resources -- Connecting to an Internet Resource -- Parsing XML Using the XML Pull Parser -- Creating an Earthquake Viewer -- Using the Download Manager -- Downloading Files -- Customizing Download Manager Notifications -- Specifying a Download Location -- Cancelling and Removing Downloads -- Querying the Download Manager -- Using Internet Services -- Connecting to Google App Engine -- Best Practices for Downloading Data Without Draining the Battery -- ch. 7 Files, Saving State, And Preferences -- Saving Simple Application Data -- Creating and Saving Shared Preferences -- Retrieving Shared Preferences -- Creating a Settings Activity for the Earthquake Viewer -- Introducing the Preference Framework and the Preference Activity -- Defining a Preference Screen Layout in XML -- Native Preference Controls -- Using Intents to Import System Preferences into Preference Screens -- Introducing the Preference Fragment -- Defining the Preference Fragment Hierarchy Using Preference Headers -- Introducing the Preference Activity -- Backward Compatibility and Preference Screens -- Finding and Using the Shared Preferences Set by Preference Screens -- Introducing On Shared Preference Change Listeners -- Creating a Standard Preference Activity for the Earthquake Viewer -- Persisting the Application Instance State -- Saving Activity State Using Shared Preferences -- Saving and Restoring Activity Instance State Using the Lifecycle Handlers -- Saving and Restoring Fragment Instance State Using the Lifecycle Handlers -- Including Static Files as Resources -- Working with the File System -- File-Management Tools -- Using Application-Specific Folders to Store Files -- Creating Private Application Files -- Using the Application File Cache -- Storing Publicly Readable Files -- ch. 8 Databases And Content Providers -- Introducing Android Databases -- SQLite Databases -- Content Providers -- Introducing SQLite -- Content Values and Cursors -- Working with SQLite Databases -- Introducing the SQLiteOpenHelper -- Opening and Creating Databases Without the SQLite Open Helper -- Android Database Design Considerations -- Querying a Database -- Extracting Values from a Cursor -- Adding, Updating, and Removing Rows -- Inserting Rows -- Updating Rows -- Deleting Rows -- Creating Content Providers -- Registering Content Providers -- Publishing Your Content Provider's URI Address -- Creating the Content Provider's Database -- Implementing Content Provider Queries -- Content Provider Transactions -- Storing Files in a Content Provider -- A Skeleton Content Provider Implementation -- Using Content Providers -- Introducing the Content Resolver -- Querying Content Providers -- Querying for Content Asynchronously Using the Cursor Loader -- Introducing Loaders -- Using the Cursor Loader -- Adding, Deleting, and Updating Content -- Inserting Content -- Deleting Content -- Updating Content -- Accessing Files Stored in Content Providers -- Creating a To-Do List Database and Content Provider -- Adding Search to Your Application -- Making Your Content Provider Searchable -- Creating a Search Activity for Your Application -- Making Your Search Activity the Default Search Provider for Your Application --, Contents note continued: Performing a Search and Displaying the Results -- Using the Search View Widget -- Supporting Search Suggestions from a Content Provider -- Surfacing Search Results in the Quick Search Box -- Creating a Searchable Earthquake Content Provider -- Creating the Content Provider -- Using the Earthquake Provider -- Searching the Earthquake Provider -- Native Android Content Providers -- Using the Media Store Content Provider -- Using the Contacts Contract Content Provider -- Introducing the Contacts Contract Content Provider -- Reading Contact Details -- Creating and Picking Contacts Using Intents -- Modifying and Augmenting Contact Details Directly -- Using the Calendar Content Provider -- Querying the Calendar -- Creating and Editing Calendar Entries Using Intents -- Modifying Calendar Entries Directly -- ch. 9 Working In The Background -- Introducing Services -- Creating and Controlling Services -- Creating Services -- Executing a Service and Controlling Its Restart Behavior -- Starting and Stopping Services -- Self-Terminating Services -- Binding Services to Activities -- An Earthquake-Monitoring Service Example -- Creating Foreground Services -- Using Background Threads -- Using AsyncTask to Run Asynchronous Tasks -- Creating New Asynchronous Tasks -- Running Asynchronous Tasks -- Introducing the Intent Service -- Introducing Loaders -- Manual Thread Creation and GUI Thread Synchronization -- Using Alarms -- Creating, Setting, and Canceling Alarms -- Setting Repeating Alarms -- Using Repeating Alarms to Schedule Network Refreshes -- Using the Intent Service to Simplify the Earthquake Update Service -- ch. 10 Expanding The User Experience -- Introducing the Action Bar -- Customizing the Action Bar -- Modifying the Icon and Title Text -- Customizing the Background -- Enabling the Split Action Bar Mode -- Customizing the Action Bar to Control Application Navigation Behavior -- Configuring Action Bar Icon Navigation Behavior -- Using Navigation Tabs -- Using Drop-Down Lists for Navigation -- Using Custom Navigation Views -- Introducing Action Bar Actions -- Adding an Action Bar to the Earthquake Monitor -- Creating and Using Menus and Action Bar Action Items -- Introducing the Android Menu System -- Creating a Menu -- Specifying Action Bar Actions -- Menu Item Options -- Adding Action Views and Action Providers -- Adding Menu Items from Fragments -- Defining Menu Hierarchies in XML -- Updating Menu Items Dynamically -- Handling Menu Selections -- Introducing Submenus and Context Menus -- Creating Submenus -- Using Context Menus and Popup Menus -- Refreshing the Earthquake Monitor -- Going Full Screen -- Introducing Dialogs -- Creating a Dialog -- Using the Alert Dialog Class -- Using Specialized Input Dialogs -- Managing and Displaying Dialogs Using Dialog Fragments -- Managing and Displaying Dialogs Using Activity Event Handlers -- Using Activities as Dialogs -- Let's Make a Toast -- Customizing Toasts -- Using Toasts in Worker Threads -- Introducing Notifications -- Introducing the Notification Manager -- Creating Notifications -- Creating a Notification and Configuring the Status Bar Display -- Using the Default Notification Sounds, Lights, and Vibrations -- Making Sounds -- Vibrating the Device -- Flashing the Lights -- Using the Notification Builder -- Setting and Customizing the Notification Tray UI -- Using the Standard Notification UI -- Creating a Custom Notification UI -- Customizing the Ticker View -- Configuring Ongoing and Insistent Notifications -- Triggering, Updating, and Canceling Notifications -- Adding Notifications and Dialogs to the Earthquake Monitor -- ch. 11 Advanced User Experience -- Designing for Every Screen Size and Density -- Resolution Independence -- Using Density-Independent Pixels -- Resource Qualifiers for Pixel Density -- Supporting and Optimizing for Different Screen Sizes -- Creating Scalable Layouts -- Optimizing Layouts for Different Screen Types -- Specifying Supported Screen Sizes -- Creating Scalable Graphics Assets -- Color Drawables -- Shape Drawables -- Gradient Drawables -- NinePatch Drawables -- Creating Optimized, Adaptive, and Dynamic Designs -- Testing, Testing, Testing -- Using Emulator Skins -- Testing for Custom Resolutions and Screen Sizes -- Ensuring Accessibility -- Supporting Navigation Without a Touch Screen -- Providing a Textual Description of Each View -- Introducing Android Text-to-Speech -- Using Speech Recognition -- Using Speech Recognition for Voice Input -- Using Speech Recognition for Search -- Controlling Device Vibration -- Working with Animations -- Tweened View Animations -- Creating Tweened View Animations -- Applying Tweened Animations -- Using Animation Listeners -- Animating Layouts and View Groups -- Creating and Using Frame-by-Frame Animations -- Interpolated Property Animations -- Creating Property Animations -- Creating Property Animation Sets -- Using Animation Listeners -- Enhancing Your Views -- Advanced Canvas Drawing -- What Can You Draw? -- Getting the Most from Your Paint -- Improving Paint Quality with Anti-Aliasing -- Canvas Drawing Best Practice -- Advanced Compass Face Example -- Hardware Acceleration -- Managing Hardware Acceleration Use in Your Applications -- Checking If Hardware Acceleration Is Enabled -- Introducing the Surface View -- When to Use a Surface View -- Creating Surface Views -- Creating 3D Views with a Surface View -- Creating Interactive Controls -- Using the Touch Screen -- Using the Device Keys, Buttons, and D-Pad -- Using the On Key Listener -- Using the Trackball -- Advanced Drawable Resources -- Composite Drawables -- Transformative Drawables -- Layer Drawables -- State List Drawables -- Level List Drawables -- Copy, Paste, and the Clipboard -- Copying Data to the Clipboard -- Pasting Clipboard Data -- ch. 12 Hardware Sensors -- Using Sensors and the Sensor Manager -- Supported Android Sensors -- Introducing Virtual Sensors -- Finding Sensors -- Monitoring Sensors -- Interpreting Sensor Values -- Monitoring a Device's Movement and Orientation -- Determining the Natural Orientation of a Device -- Introducing Accelerometers -- Detecting Acceleration Changes -- Creating a Gravitational Force Meter -- Determining a Device's Orientation -- Understanding the Standard Reference Frame -- Calculating Orientation Using the Accelerometer and Magnetic Field Sensors -- Remapping the Orientation Reference Frame -- Determining Orientation Using the Deprecated Orientation Sensor -- Creating a Compass and Artificial Horizon -- Introducing the Gyroscope Sensor -- Introducing the Environmental Sensors -- Using the Barometer Sensor -- Creating a Weather Station -- ch. 13 Maps, Geocoding, And Location-Based Services -- Using Location-Based Services -- Using the Emulator with Location-Based Services -- Updating Locations in Emulator Location Providers -- Configuring the Emulator to Test Location-Based Services -- Selecting a Location Provider -- Finding Location Providers -- Finding Location Providers by Specifying Criteria -- Determining Location Provider Capabilities -- Finding Your Current Location -- Location Privacy -- Finding the Last Known Location -- Where Am I Example -- Refreshing the Current Location -- Tracking Your Location in Where Am I -- Requesting a Single Location Update -- Best Practice for Location Updates -- Monitoring Location Provider Status and Availability -- Using Proximity Alerts -- Using the Geocoder -- Reverse Geocoding -- Forward Geocoding -- Geocoding Where Am I -- Creating Map-Based Activities -- Introducing Map View and Map Activity -- Getting Your Maps API Key -- Getting Your Development/Debugging MD5 Fingerprint -- Getting your Production/Release MD5 Fingerprint -- Creating a Map-Based Activity -- Maps and Fragments -- Configuring and Using Map Views -- Using the Map Controller -- Mapping Where Am I -- Creating and Using Overlays -- Creating New Overlays -- Introducing Projections -- Drawing on the Overlay Canvas -- Handling Map Tap Events -- Adding and Removing Overlays -- Annotating Where Am I -- Introducing My Location Overlay -- Introducing Itemized Overlays and Overlay Items -- Pinning Views to the Map and Map Positions -- Mapping Earthquakes Example -- ch. 14 Invading The Home Screen -- Introducing Home Screen Widgets -- Creating App Widgets -- Creating the Widget XML Layout Resource -- Widget Design Guidelines -- Supported Widget Views and Layouts -- Defining Your Widget Settings -- Creating Your Widget Intent Receiver and Adding It to the Application Manifest -- Introducing the App Widget Manager and Remote Views -- Creating and Manipulating Remote Views -- Applying Remote Views to Running App Widgets -- Using Remote Views to Add Widget Interactivity -- Refreshing Your Widgets -- Using the Minimum Update Rate -- Using Intents -- Using Alarms -- Creating and Using a Widget Configuration Activity -- Creating an Earthquake Widget -- Introducing Collection View Widgets -- Creating Collection View Widget Layouts -- Creating the Remote Views Service -- Creating a Remote Views Factory -- Populating Collection View Widgets Using a Remote Views Service -- Adding Interactivity to the Items Within a Collection View Widget -- Binding Collection View Widgets to Content Providers -- Refreshing Your Collection View Widgets -- Creating an Earthquake Collection View Widget -- Introducing Live Folders -- Creating Live Folders -- The Live Folder Content Provider -- The Live Folder Activity -- Creating an Earthquake Live Folder -- Surfacing Application Search Results Using the Quick Search Box -- Surfacing Search Results to the Quick Search Box -- Adding the Earthquake Example Search Results to the Quick Search Box -- Creating Live Wallpaper -- Creating a Live Wallpaper Definition Resource -- Creating a Wallpaper Service -- Creating a Wallpaper Service Engine -- ch. 15 Audio, Video, And Using The Camera -- Playing Audio and Video -- Introducing the Media Player --, and Contents note continued: Preparing Audio for Playback -- Initializing Audio Content for Playback -- Preparing Video for Playback -- Playing Video Using the Video View -- Creating a Surface for Video Playback -- Controlling Media Player Playback -- Managing Media Playback Output -- Responding to the Volume Controls -- Responding to the Media Playback Controls -- Requesting and Managing Audio Focus -- Pausing Playback When the Output Changes -- Introducing the Remote Control Client -- Manipulating Raw Audio -- Recording Sound with Audio Record -- Playing Sound with Audio Track -- Creating a Sound Pool -- Using Audio Effects -- Using the Camera for Taking Pictures -- Using Intents to Take Pictures -- Controlling the Camera Directly -- Camera Properties -- Camera Settings and Image Parameters -- Controlling Auto Focus, Focus Areas, and Metering Areas -- Using the Camera Preview -- Detecting Faces and Facial Features -- Taking a Picture -- Reading and Writing JPEG EXIF Image Details -- Recording Video -- Using Intents to Record Video -- Using the Media Recorder to Record Video -- Configuring the Video Recorder -- Previewing the Video Stream -- Controlling the Recording -- Creating a Time-Lapse Video -- Using Media Effects -- Adding Media to the Media Store -- Inserting Media Using the Media Scanner -- Inserting Media Manually -- ch. 16 Bluetooth, Nfc, Networks, And Wi-Fi -- Using Bluetooth -- Managing the Local Bluetooth Device Adapter -- Being Discoverable and Remote Device Discovery -- Managing Device Discoverability -- Discovering Remote Devices -- Bluetooth Communications -- Opening a Bluetooth Server Socket Listener -- Selecting Remote Bluetooth Devices for Communications -- Opening a Client Bluetooth Socket Connection -- Transmitting Data Using Bluetooth Sockets -- Managing Network and Internet Connectivity -- Introducing the Connectivity Manager -- Supporting User Preferences for Background Data Transfers -- Finding and Monitoring Network Connectivity -- Managing Wi-Fi -- Monitoring Wi-Fi Connectivity -- Monitoring Active Wi-Fi Connection Details -- Scanning for Hotspots -- Managing Wi-Fi Configurations -- Creating Wi-Fi Network Configurations -- Transferring Data Using Wi-Fi Direct -- Initializing the Wi-Fi Direct Framework -- Enabling Wi-Fi Direct and Monitoring Its Status -- Discovering Peers -- Connecting with Peers -- Transferring Data Between Peers -- Near Field Communication -- Reading NFC Tags -- Using the Foreground Dispatch System -- Introducing Android Beam -- Creating Android Beam Messages -- Assigning the Android Beam Payload -- Receiving Android Beam Messages -- ch. 17 Telephony And Sms -- Hardware Support for Telephony -- Marking Telephony as a Required Hardware Feature -- Checking for Telephony Hardware -- Using Telephony -- Initiating Phone Calls -- Replacing the Native Dialer -- Accessing Telephony Properties and Phone State -- Reading Phone Device Details -- Reading Network Details -- Reading SIM Details -- Reading Data Connection and Transfer State Details -- Monitoring Changes in Phone State Using the Phone State Listener -- Monitoring Incoming Phone Calls -- Tracking Cell Location Changes -- Tracking Service Changes -- Monitoring Data Connectivity and Data Transfer Status Changes -- Using Intent Receivers to Monitor Incoming Phone Calls -- Introducing SMS and MMS -- Using SMS and MMS in Your Application -- Sending SMS and MMS from Your Application Using Intents -- Sending SMS Messages Using the SMS Manager -- Sending Text Messages -- Tracking and Confirming SMS Message Delivery -- Conforming to the Maximum SMS Message Size -- Sending Data Messages -- Listening for Incoming SMS Messages -- Simulating Incoming SMS Messages in the Emulator -- Handling Data SMS Messages -- Emergency Responder SMS Example -- Automating the Emergency Responder -- Introducing SIP and VOIP -- ch. 18 Advanced Android Development -- Paranoid Android -- Linux Kernel Security -- Introducing Permissions -- Declaring and Enforcing Permissions -- Enforcing Permissions when Broadcasting Intents -- Introducing Cloud to Device Messaging -- C2DM Restrictions -- Signing Up to Use C2DM -- Registering Devices with a C2DM Server -- Sending C2DM Messages to Devices -- Receiving C2DM Messages -- Implementing Copy Protection Using the License Verification Library -- Installing the License Verification Library -- Finding Your License Verification Public Key -- Configuring Your License Validation Policy -- Performing License Validation Checks -- Introducing In-App Billing -- In-App Billing Restrictions -- Installing the In-App Billing Library -- Finding Your Public Key and Defining Your Purchasable Items -- Initiating In-App Billing Transactions -- Handling In-App Billing Purchase Request Responses -- Using Wake Locks -- Using AIDL to Support Inter-Process Communication for Services -- Implementing an AIDL Interface -- Making Classes Parcelable -- Creating an AIDL Service Definition -- Implementing and Exposing the AIDL Service Definition -- Dealing with Different Hardware and Software Availability -- Specifying Hardware as Required -- Confirming Hardware Availability -- Building Backward-Compatible Applications -- Parallel Activities -- Interfaces and Fragments -- Optimizing UI Performance with Strict Mode -- ch. 19 Monetizing, Promoting, And Distributing Applications -- Signing and Publishing Applications -- Signing Applications Using the Export Android Application Wizard -- Distributing Applications -- Introducing the Google Play -- Getting Started with Google Play -- Publishing Applications -- Application Reports Within the Developer Console -- Accessing Application Error Reports -- An Introduction to Monetizing Your Applications -- Application Marketing, Promotion, and Distribution Strategies -- Application Launch Strategies -- Promotion Within Google Play -- Internationalization -- Analytics and Referral Tracking -- Using Google Analytics for Mobile Applications -- Referral Tracking with Google Analytics.
Summary
Annotation Developers, build mobile Android apps using Android 4The fastgrowing popularity of Android smartphones and tablets creates a huge opportunities for developers. If youre an experienced developer, you can start creating robust mobile Android apps right away with this professional guide to Android 4 application development. Written by one of Googles lead Android developer advocates, this practical book walks you through a series of handson projects that illustrate the features of the Android SDK. That includes all the new APIs introduced in Android 3 and 4, including building for tablets, using the Action Bar, WiFi Direct, NFC Beam, and more.Shows experienced developers how to create mobile applications for Android smartphones and tabletsRevised and expanded to cover all the Android SDK releases including Android 4.0 (Ice Cream Sandwich), including all updated APIs, and the latest changes to the Android platform.Explains new and enhanced features such as drag and drop, fragments, the action bar, enhanced multitouch support, new environmental sensor support, major improvements to the animation framework, and a range of new communications techniques including NFC and WiFi direct.Provides practical guidance on publishing and marketing your applications, best practices for user experience, and moreThis book helps you learn to master the design, lifecycle, and UI of an Android app through practical exercises, which you can then use as a basis for developing your own Android apps.
Subject(s)
ISBN
1118223853 (electronic bk)
9781118223857 (electronic bk)
Note
Includes index.
"Updated for Android 4".
AVAILABLE ONLINE TO AUTHORIZED PSU USERS.
View MARC record | catkey: 8278978