Android application development for dummies all-in-one / Barry Burd, John Paul Mueller.

Format:

Book

Author/Creator:

Mueller, John, 1958- author.

Series:

--For dummies

Language:

English

Subjects (All):

Android (Electronic resource).

Application software--Development.

Application software.

Mobile computing.

Physical Description:

1 online resource (803 pages) : illustrations

Edition:

Third edition.

Place of Publication:

Hoboken, N.J. : John Wiley and Sons, 2020.

Summary:

Conquer the world of Android app development Android has taken over the mobile and TV markets and become unstoppable! Android offers a vast stage for developers to serve millions-and rake in the profits-with diverse and wide-ranging app ideas. Whether you're a raw recruit or a veteran programmer, you can get in on the action and become a master of the Android programming universe with the new edition of Android Application Development For Dummies All-in-One . In addition to receiving guidance on mobile and TV development, you'll find overviews of native code, watch, car, Android wear, and other device development. This friendly, easy-to-follow book kicks off by offering a fundamental understanding of Android's major technical ideas, including functional programming techniques. It moves on to show you how to work effectively in Studio, program cool new features, and test your app to make sure it's ready to release to a waiting world. You'll also have an opportunity to brush up on your Kotlin and develop your marketing savvy. There are millions of potential customers out there, and you want to stand out from the crowd! Understand new features and enhancements Get development best-practices Know your Android hardware Access online materials With a market share like Android's, the stakes couldn't be higher. Android Application Development For Dummies All-in-One levels the field and gives you the tools you need to take on the world.

Contents:

Intro

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 &lt

brief&gt

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.

Notes:

Includes index.

Description based on print version record.

Description based on publisher supplied metadata and other sources.

ISBN:

1-119-66043-2

1-119-66046-7

OCLC:

1175918226