Android Application Development All - In - One for Dummies, 3ed

Barry Burd, John Paul Mueller

ISBN: 9789354245787

812 pages

INR 899


6 books in 1 takes you from Android newbie to confident programmer! Follow along with Java expert Barry Burd as he introduces you to Android programming in six self-contained minibooks!  Series Features: Like all For Dummies books, this book will be written in clear, plain English explanations and careful organization that make For Dummies the easiest way for experienced programmers to get up to speed quickly!


How to Use This Book  

Conventions Used in This Book  

Foolish Assumptions

Icons Used in This Book  

Beyond the Book  

Where to Go from Here  


Book 1: Getting Started with Android Application Development 

Chapter 1: All about Android

  • The Consumer Perspective
  • The Versions of Android
  • The Developer Perspective
  • Java and Kotlin
  • XML
  • Linux
  • The Business Perspective


Chapter 2: Installing the Software Tools

  • Setting Up the Software
  • Considering the requirements
  • Downloading the software
  • Installing Android Studio
  • Installing offline tools
  • Launching the Android Studio IDE
  • In Windows
  • On a Mac
  • In Linux
  • In Chrome OS
  • Using the Android Studio Setup Wizard
  • Fattening Up the Android SDK
  • The more things stay the same, the more they change
  • Installing new versions (and older versions) of Android
  • Creating an Android virtual device
  • A third-party emulator


Chapter 3: Creating an Android App

  • Creating Your First App
  • Starting the IDE and creating your first app
  • Launching your first app
  • Running Your App
  • You Can Download All the Code
  • Troubleshooting Common IDE Errors
  • Error message: Failed to find target
  • Error running ‘app': No target device found
  • Error message: Android Virtual Device may be incompatible with your configuration 58
  • You lose contact with the Android Debug Bridge (ADB)
  • You don't like whatever AVD opens automatically
  • The emulator stalls during startup
  • Error message: The user data image is used by another emulator
  • Error message: Unknown virtual device name
  • The emulator displays a "process isn't responding" dialog box
  • Changes to your app don't appear in the emulator
  • Testing Apps on a Real Device


Chapter 4: Examining a Basic Android App

  • A Project's Files
  • The MainActivity.kt file
  • The onCreate() method
  • Using other templates
  • The res Branch
  • The res/drawable branch
  • The res/layout branch
  • The res/menu branch
  • The res/mipmap branch
  • The res/values branch
  • Other Files in an Android Project
  • The build.gradle file
  • The AndroidManifest.xml file
  • The file
  • The assets folder
  • The android.jar archive
  • The APK file
  • What Did I Agree To?
  • What's in a name?
  • Choosing a language
  • Your app's API levels


Chapter 5: Conjuring and Embellishing an Android App

  • Dragging, Dropping, and Otherwise Tweaking an App
  • Creating the "look"
  • Coding the behavior
  • A Bit of Debugging
  • Try it!
  • Discovering the secrets of Logcat
  • Using the debugger


Chapter 6: Improving Your App

  • Improving the Layout
  • Changing the layout
  • Creating a reusable layout
  • Reusing a layout
  • Starting Another Activity
  • Localizing Your App
  • Responding to Check Box Events
  • Displaying Images
  • Sending in Your Order


Book 2: Android Background Material 

Chapter 1: Using Android Studio

  • Good to Know versus Need to Know
  • Getting a Feel for the Big Picture
  • The main window
  • Viewing modes
  • The Designer tool
  • Discovering What You Can Do
  • Finding things
  • Fixing code
  • Refactoring


Chapter 2: Kotlin for Java Programmers

  • Using Kotlin or Java for Development
  • Defining the Java Issues That Kotlin Fixes
  • Improving control over null references
  • Removing raw data types
  • Using invariant arrays
  • Working with proper function types
  • Getting rid of the checked exceptions
  • Nothing's Perfect: Kotlin is Missing Features, Too
  • Considering primitive types that are not classes
  • Losing static members
  • Eliminating non-private fields
  • Reducing confusion by eliminating wildcard-types
  • Abandoning the ternary-operator a ? b : c
  • Looking at What Kotlin Adds to the Picture
  • Considering higher order functions and lambdas
  • Refining object orientation using extension functions
  • Relying on smart casts
  • Employing string templates
  • Understanding primary constructors
  • Implementing first-class delegation
  • Using ranges of values
  • Creating data classes
  • Overloading operators
  • Developing asynchronous code using coroutines


Chapter 3: Kotlin for Everyone

  • Moving from Development to Execution with Kotlin
  • What is a compiler?
  • Understanding native code compiler or interpreter issues
  • Considering the Android Runtime (ART)
  • Grasping Kotlin Code
  • Nearly everything begins with an expression
  • The Kotlin class
  • Classes and objects
  • Kotlin types
  • Performing casts
  • The Kotlin function
  • Objects and their constructors
  • Classes grow on trees
  • The Kotlin package
  • Considering Kotlin visibility rules
  • Defying your parent
  • Kotlin comments


Chapter 4: What Kotlin Does (and When)

  • Making Decisions (Kotlin if Statements)
  • Testing for equality
  • Choosing among many alternatives (Kotlin when statements)
  • Repeating Instructions Over and Over Again
  • Kotlin while statements
  • Kotlin do statements
  • Arrays in Kotlin
  • Kotlin's for statements
  • Looping using Kotlin recursion
  • Working with break and continue
  • Jumping Away from Trouble
  • Working with Kotlin Collections
  • Considering the collection types
  • Differentiating between read-only and mutable collections


Chapter 5: Object-Oriented Programming in Kotlin

  • Static Fields and Methods
  • Interfaces and Callbacks
  • Event handling and callbacks
  • An object remembers who created it
  • A less wordy way to implement an interface
  • Classes That Must (and Must Not) Be Extended
  • The need to override
  • Java's final classes
  • Kotlin's open classes
  • Kotlin extensions
  • Abstract classes
  • Inner Classes
  • Named inner classes
  • Anonymous inner classes


Chapter 6: Functional Programming in Kotlin

  • Defining Functional Programming
  • Differences from other programming paradigms
  • Understanding its goals
  • Understanding Pure and Impure Languages
  • Using the pure approach
  • Using the impure approach
  • Comparing the Functional Paradigm
  • Using Kotlin for Functional Programming Needs
  • Defining the Role of State
  • Using Recursion to Perform Calculations
  • Relying on standard recursion
  • Relying on tail recursion
  • Using Function Types
  • Understanding Function Literals
  • Lambda expressions
  • Anonymous functions
  • Defining the Function Types
  • Comprehensions
  • Receivers
  • Inline
  • Utility
  • Using Functional Programming for Android Apps


Chapter 7: A <brief> Look at XML

  • XML Isn't Ordinary Text
  • Of tags and elements
  • Other things you find in an XML document
  • What's in a Namespace?
  • The package attribute
  • The style attribute


Book 3: The Building Blocks 

Chapter 1: Getting an Overview of Jetpack

  • Understanding the Benefits of Jetpack
  • Eliminating boilerplate code
  • Managing background tasks
  • Navigating between activities and fragments
  • Managing memory
  • Performing configuration changes
  • Considering the Jetpack Components
  • Foundation
  • Architecture
  • Behavior
  • UI
  • Getting an Overview of the AndroidX Package
  • Working with Lifecycle-Aware Components
  • Focusing on activities
  • Understanding events and states


Chapter 2: Building a Foundation for Your App

  • Working with Android KTX
  • Getting a feel for KTX features
  • Using KTX in your project
  • Considering the modules
  • Addressing Security Issues
  • Benchmarking Your Application
  • Removing barriers to correct results
  • Creating a test app
  • Profiling your app
  • Tracing your app
  • Checking for benchmarking module support
  • Benchmarking the app
  • Testing Application Functionality


Chapter 3: Creating an Architecture

  • Managing Application Activities
  • Defining an activity
  • Getting an overview of intent filters
  • Considering the activity lifecycle
  • Understanding the backstack
  • Working with fragments
  • Considering the fragment lifecycle
  • Seeing activities and fragments in action
  • Providing for Navigational Needs
  • Creating the navigational graph
  • Adding a NavHostFragment to your activity
  • Adding destinations
  • Creating links between destinations
  • Creating the required linkages
  • Performing Background Tasks Using WorkManager


Chapter 4: Defining an App's Behavior

  • Working with Notifications
  • Understanding what notifications do
  • Anatomy of a notification
  • Assigning a channel to your notification
  • Setting the notification importance
  • Considering the notification types
  • Relying on notification updates
  • Do Not Disturb mode
  • Creating a notification
  • Getting Permission
  • Considering permission use
  • Configuring permissions in AndroidManifest.xml
  • Complying with User Preferences
  • Deciding on a preference set
  • Setting preferences using the Preference Library
  • Working with MediaPlayer
  • Adding Camera Support Using CameraX
  • Sharing with Others
  • Performing simple share actions with other apps
  • Using Slices


Chapter 5: Interacting with the Users

  • Creating a Great Layout
  • Defining the View and ViewGroup elements
  • Creating a layout using XML
  • Modifying a layout at runtime
  • Considering the common layouts
  • Working with adapters
  • Debugging your layout
  • Employing Color and Texture
  • Working with styles and themes
  • Creating a palette
  • Using swatches to create color schemes
  • Using Animations and Transitions
  • Understanding the need for animations
  • Animating graphics
  • Communicating with Emoji
  • Keyboard emoji support
  • Using the cut-and-paste method on standard controls
  • Using the AndroidX approach


Book 4: Programming Cool Phone Features 

Chapter 1: Hungry Burds: A Simple Android Game

  • Introducing the Hungry Burds Game
  • The Hungry Burds Project's Files
  • The Main Activity
  • The Code, All the Code, and Nothing But the Code
  • Setting Up the Game
  • Declaring properties
  • The onCreate Method
  • Displaying a Burd
  • Creating random values
  • Creating a Burd
  • Placing a Burd on the constraint layout
  • Animating a Burd
  • Handling a Touch Event
  • Finishing Up


Chapter 2: An Android Social Media App

  • Setting Things Up on Facebook's Developer Site
  • A Minimal Facebook App
  • The build.gradle file
  • The manifest file
  • A Bare-Bones Main Activity
  • Enriching the Minimal App
  • Working with a radio group
  • Controlling the web view
  • Who tests your Facebook app?


Chapter 3: Going Native

  • The Native Development Kit
  • Understanding why you need the NDK
  • Knowing what you get
  • Getting the NDK
  • Creating an Application
  • Starting with the template
  • Seeing the essential project differences
  • Considering the build.gradle (Module: app) differences
  • Understanding the default template differences
  • Getting an overview of the C++ file
  • Seeing the result


Book 5: Apps for Tablets, Watches, TV Sets, and Cars 

Chapter 1: Apps for Tablets

  • Gaining Perspective
  • Creating the right devices
  • Running code on multiple devices
  • Copying the project
  • Seeing presentation differences
  • Developing a Nested Navigational Graph
  • Understanding the uses for nested navigational graphs
  • Developing an app design
  • Considering the content needs
  • Creating a Responsive App


Chapter 2: Developing for Android Wear

  • Seeing Where Wearables Are Used
  • Setting Up Your Testing Environment
  • Creating the project
  • Configuring a wearable device emulator
  • Other testing configurations
  • Wearable Apps: What's the Big Deal?
  • Case Study: A Watch Face
  • Defining the watch face project
  • Testing the watch face app
  • Dissecting the skeletal watch face project
  • Enhancing the skeletal watch face project


Chapter 3: Developing for Android TV

  • Getting Started
  • Running the Skeletal App
  • Dissecting the TV App
  • Adding to the standard AndroidManifest.xml
  • Looking into build.gradle (Module: app)
  • Defining a layout
  • The adapter and the presenter
  • Using the Adapter class
  • Using the Presenter class


Chapter 4: Developing for Android Auto

  • Checking Auto Compatibility
  • Choosing the Google Play Services
  • Considering Notification Limits
  • Creating an Emulator
  • Configuring your car for development
  • Defining an emulator
  • Developing an Android Auto App
  • Creating the project
  • Viewing the project configuration
  • Performing required configuration tasks
  • Touring the Media Service app


Book 6: The Job Isn't Done Until

Chapter 1: Publishing Your App to the Google Play Store

  • Creating a Google Play Developer Account
  • Preparing Your Code
  • Un-testing the app
  • Choosing Android versions
  • Setting your app's own version code and version name
  • Choosing a package name
  • Preparing Graphic Assets for the Play Store
  • Creating an icon
  • Creating screenshots
  • Providing other visual assets
  • Creating a Publishable File
  • Differences among builds
  • Creating the release build
  • Running a new APK file
  • Running the app in a new AAB file
  • Another way to build and run an AAB file
  • Publishing Your App
  • The App Releases page
  • The Store Listing page
  • The App Signing page
  • Other pages
  • Leave No Stone Unturned
  • Publishing Elsewhere
  • The Amazon Appstore
  • Other venues


Chapter 2: Monetizing and Marketing Your App

  • Choosing a Revenue Model
  • Charging for your app
  • Offering an extended free trial
  • Freemium apps
  • Selling things with your app
  • Subscription pricing
  • Earning revenue from advertising
  • Variations on in-app advertising
  • Donationware
  • Offering your app for free
  • Getting paid to develop apps for others
  • Marketing Your Application
  • Brick Breaker Master: An App Marketing Case Study


Chapter 3: Creating Public Support for Your App

  • Obtaining Support through Patreon
  • Discovering that patronage isn't new
  • Considering crowdfunding
  • Defining why you should use crowdfunding
  • Understanding the development angle
  • Determining the trade-offs
  • Developing Your Own Distribution Stream
  • Creating podcasts
  • Developing YouTube videos
  • Employing social media
  • Answering questions
  • Taking the Personal Approach
  • Creating a blog
  • Answering your email
  • Considering App Store Alternatives
  • Getting Awards
  • Looking for awards in all the right places
  • Strutting your stuff




  • Name:
  • Designation:
  • Name of Institute:
  • Email:
  • * Request from personal id will not be entertained
  • Moblie:
  • ISBN / Title:
  • ISBN:    * Please specify ISBN / Title Name clearly