Android programming for dummies all-in-one

Title Page
Copyright Page
Table of Contents
Introduction
	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
			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 R.java 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  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 Android Manifest.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 Android Manifest.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
Index
EULA