Android for Absolute - Beginners Getting Started with Mobile Apps Development Using the Android Java SDK.

✍ Scribed by Grant Allen

• Publisher: Apress
• Year: 2021
• Tongue: English
• Leaves: 356
• Edition: 1
• Category: Library

✦ Synopsis

Get started as a mobile app developer and learn the art and science of Android app development. With no assumed knowledge about programming languages or Android required, you will gain the key skills for constructing fully functional Android apps for smartphones, tablets, and other devices.

You will also build a solid foundation in the Java programming language and the business of creating and releasing software for Android. Along the way you’ll get comfortable with Android Studio - the best way to write modern Android apps - before diving into your first Android code. The author spends plenty of time explaining how to build a robust UI with widgets, menus, layouts and more. These components will be the basis of your Android apps and so are covered in depth.
Having grasped the basics, you’ll move onto what will make your app stand out: sound, music, images, animations, and notifications. Taking these elements and combining them with phone features like calling and sensors, will take your apps to the next level.

The final part of the book covers services, events, intents, receivers, files and databases, essential sources of information and functionality for users and your app. In addition, you'll see how to protect your users and their data with permissions and security in examples throughout the book

---

What You Will Learn:---

Get started with Android and build your first apps with it

Install and use the Android Studio IDE

Set up and manage the app development life cycle

Master the basics of Java and XML required to create Android apps

Discover the strengths and features of the Android APIs and device capabilities

---

Who This Book Is For:-

Total beginners who have little or no exposure to software development. This book is also useful for developers who are completely new to Android.

✦ Table of Contents

Table of Contents
About the Author
About the Technical
Reviewer
Acknowledgments
Introduction
Part I: Get Android, Get Started
Chapter 1: Introducing Android
Working with Android: The Best Parts
Working with Android: The Challenges
Understanding Android’s Heritage and How It Affects You
Understanding Android’s Future
What to Expect for the Rest of This Book
Detailing More of the Remaining Chapters
Chapter 2: Introducing Android Studio
Understanding What Is Meant by Integrated Development Environment, or IDE
The History and Provenance of Android Studio
Downloading the Android Studio Installer for Your Platform
Working with Android Studio Versions
Understanding How Android Studio and the Android SDK Work Together
Preparing for Android Studio
Choosing Desktop or Laptop Hardware for Android Development
Choosing the Operating System for Your Computer
Continuing with Downloading the Installer
Installing Android Studio on Windows
Installing Android Studio on macOS
Installing Android Studio on Linux
Continuing with Android Studio Setup After Installation
Working with Alternatives to Android Studio
Eclipse
IntelliJ IDEA
Tools That Target Multiple Operating Systems and Mobile Platforms
Traditional Platform-Agnostic Development Tools
Chapter 3: Your First Android Application, Already!
Creating Your First Android Virtual Device
Creating Your First Android Application, Already!
Getting Your First Code Written
Getting Ready to Run Your Application
Installing (Additional) SDK Packages
Running Your Application
Chapter 4: Exploring Your First Project
Viewing the Whole Android Project Structure
Working with Manifests
Jiving with Java
Getting Resourceful with Resources
Drawables
Layouts
Mipmaps
Finding Value in Values
Building Everything with Gradle Files
Understanding SDK Version Parameters
Understanding Application Versioning
Including Libraries for Forward and Backward Version Support
Explaining the Key Android Application Logical Building Blocks
Activities
Intents
Services
Content Providers
Summary
Chapter 5: Android Studio In-Depth
Starting with the Project Explorer
Getting Comfortable Switching Project Explorer Views
Using the Project Explorer Context Menu
Running and Debugging with Android Studio
Running with Run Configs: A Recap
Run Configuration: General Options
Run Configuration: Miscellaneous
Run Configuration: Debugger
Run Configuration: Profiling
Running Farther with AVDs and Connected Devices
Revisiting the AVD Manager
Running Your Code on a Real Device
Debugging Instead of Running Your Code
Setting and Clearing Breakpoints
Starting Applications for Debugging
Stepping Through Code While Debugging
Attaching the Debugger
Viewing What You’ve Run
Understanding Your Build
Understanding Events in the Event Log
Understanding Logcat
Revisiting the SDK Manager
Highlighting the Other Major Features of Android Studio
Summary
Chapter 6: Mastering Your Entire Developer Ecosystem
Choosing Dedicated Developer Hardware
Determining Which CPU Is Right for You
Too Much Memory Is Never Enough!
Storing It All!
Viewing It All!
Connecting It All!
Test Handsets and Tablets
Option 1: All-Virtual Testing
Option 2: Start Virtual and Augment with Top Devices
Option 3: Buy, Buy, and Buy Some More
Option 4: Other People’s Hardware
Building with Build Tools
Update Your gradle.properties File
Use the Gradle Command Line
Visit gradle.org to Learn More
Managing Your Code with Source Control
Completing Your Software Repertoire
Summary
Part II: Get the Android Development Know-how
Chapter 7: Introducing Java for Android Development
Java, Java, Everywhere
Android’s Java Time Warp
Using a JDK Installation for Learning Java
Your First Java Concepts in Code
The Key Java Building Blocks for Android Development
Structure of Code
Understanding Object-Oriented Design, Classes, and Objects
Working with Class Methods and Data Members
Developing Your Java-Specific Coding Knowledge
Interfaces and Implementations
Threading and Concurrency
Garbage Collection
Exception Handling
File Handling
Generics
Collections
Summary
Chapter 8: Introducing XML for Android Development
Getting Started with XML
XML Version and Encoding
XML Elements
XML Attributes
XML Values
XML Namespaces
Other Parts of the XML World
Using XML in Your Android Applications
Reviewing the Android Manifest XML File
Using XML for Resource Definitions
Changing Colors
Getting Descriptive
Defining Activity Layouts with XML
Summary
Chapter 9: Exploring Android Concepts: Core UI Widgets
Everything Starts with View
Key Methods Derived from View
Key Attributes and Properties Derived from View
Introducing the Core UI Widgets in Android
Labeling Things with TextView
Buttoning the Perfect UI
Getting the Picture with ImageView and ImageButton
Editing and Inputting Text with EditText
Checking Out the CheckBox
Switching It Up with a Switch
Choosing Things with Radio Buttons
Learning Even More UI Widgets
Summary
Chapter 10: Exploring Android Concepts: Layouts and More
What Is Android Jetpack
Using Popular Layout Designs
Revisiting the Constraint Layout
Getting in the Flow
Layering with Layer
Moving with Motion
Using Relative Layouts
Placing Widgets Relative to the Parent Container
Controlling Relative Layout Properties with IDs
Relative Positioning Properties
Working with a RelativeLayout Example
Overlapping Widgets in Relative Layouts
Lining Up with Linear Layouts
Mastering the Five Main Qualifiers for LinearLayout
A LinearLayout Example
Even More Layout Options
Table Layouts
Grid Layouts
Mastering XML-Based Layouts with Java Logic: The Best of Both Worlds!
Connecting XML Layout Definition in Java Code
Revisiting MyFirstApp via ButtonAgain
Summary
Chapter 11: Understanding Activities
Delving into the Android Activity Lifecycle
Understanding Activity Lifecycle Callback Methods
onCreate()
onStart()
onRestoreInstanceState()
onResume()
onPause()
onStop()
onSaveInstanceState()
onRestart()
onRetainNonConfigurationInstance()
onDestroy()
Appreciating the Objectives of the Activity Lifecycle
Managing Activity Configuration Changes
Working with the Default Approach to Configuration Change
Summary
Chapter 12: Introducing Fragments
Starting with the Fragment Class
Using Fragment-Based Design for Your Applications
Working with the Fragment Lifecycle
Reviewing the Fragment Lifecycle Callback Methods
onInflate()
onCreate()
onAttach()
onCreateView()
onViewCreated()
onViewStateRestored()
onStart()
onResume()
onPause()
onSaveInstanceState()
onStop()
onDestroyView()
onDestroy()
onDetach()
Starting Simple with Fragment Lifecycle Events
Creating a Fragment-Based Application
Creating Fragment Layouts: The Color List
Creating Fragment Layouts: The Color Detail
The Single-Pane Parent Activity for Color Details
The Dual-Pane Parent Activity for Color Details
Selecting Which Layout to Inflate
Coding for Fragments
ColorFragmentExample in Action
Summary
Part III: Get Sophisticated
Chapter 13: Working with Sound, Audio, and Music for Android
Playing Back Audio
Choosing Your Audio Approach
Using Raw Audio Resources
Using Audio Assets
Using File Storage for Audio
Accessing Audio Streaming Services
Working with the Media Package
Creating an Audio Application
Choosing Between Assets and Resources
Writing the Code for Audio Playback
Playing Back Audio the Simple Way
Coding the Java Logic for AudioPlayExample
Using Streaming for Audio Playback
Playing the Music Stream
Exploring Other Playback Options
Recording Audio
Recording Audio with MediaRecorder
Expanding Your Developer Audio Toolset
Understanding Key Audio Aspects
Audio Sampling and Frequency
Audio Resolution
Encoding, Decoding, and Data Loss
More Audio Theory
Choosing Further Audio Tools
Introducing Audacity
Working with WavePad
For Apple Mac Owners, There Is GarageBand
Summary
Chapter 14: Working with Video and Movies for Android
Playing Back Video
Designing a VideoView-Based Layout
Controlling Video Playback in Your Code
Understanding Key Video Concepts
Bitrate
Frame Rate
Codecs
Understanding the Complex World of Video Containers and Child Codecs
Expanding Your Developer Video Toolset
Reviewing the Range of Video Editing Tools Available to You
Popular Open Source Video Editing Suites
Popular Commercial Video Editing Suites
Introducing HandBrake for Video Editing
Downloading and Installing HandBrake
Running and Using HandBrake
Going Further with Video for Android
Summary
Chapter 15: Introducing Notifications
Configuring Notifications
Customizing Notifications with the Notification Object
Understanding Old and New Ways of Enhancing Notifications
Adding Sounds to Your Notification
Using Device Lights for Your Notification
Shaking It!
Adding Icons for Notifications
Icon Sizes for Different Android Versions
Floating Numbers for Added Information
Introducing Notification Channels in API Level 26
Notifications in Action
Supporting Logic to Create the Notifications
Seeing Notifications from the User’s Perspective
Summary
Chapter 16: Exploring Device Capabilities with Calls
Calling the Shots
Specifying Telephony Support
Making Telephony Support Optional
Making Calls
Laying Out the CallExample Application
Working Logic for the CallExample Application
Making an ACTION_DIAL Call
Making an ACTION_CALL Call
Handling Incoming Calls
Part IV: Get Together
Chapter 17: Understanding Intents, Events, and Receivers
Introducing Android Intents
Understanding Intent Behavior
An Intent Action for Every Occasion
Understanding Intent Routing
Including Intents in Your Manifest
Using Android’s Verified Links
Seeing Intent-Launched Activities in Action
Deciding on Activity Dependency
Creating an Intent
Starting the Intent-Invoked Activity
Introducing Receivers
Using Receivers When No UI Is Needed
Working with Receiver Limitations
Summary
Chapter 18: Introducing Android Services
Services Background
Using WorkManager as an Alternative to Services
Starting with Your Own Service
Implementing Your Service Class
Managing the Service Lifecycle via Callbacks
Providing Manifest Entries for Your Service
Service Communication
Client-to-Service Communication
Invoking Commands with startService()
Using the Bind Approach with Services
Service-to-Client Communication
Using bindService() Methods for All Communication
Intents and Broadcast Receivers
Use PendingIntent Objects
Use Messenger and Message Objects
Use Independent Messaging
Create Callbacks and Listeners
Use Notifications
Services in Action
Choosing the Service Design
Creating the Java Logic for the Service
Creating an Example Client to Use the Service
Testing the Service in Action
Summary
Chapter 19: Working with Files in Android
Using Assets and Raw Files
Populating Lists from Resource Files
Working with Files from the File System
Android’s File System Model
Permissions for Reading and Writing Files
Examining External Files in Action
What Goes into Saving and Reading Files
Helping Streamline IMEs
Saving and Reading Files in Action
Ensuring External Storage Is Available When Needed
Other Considerations with Android File Systems
Android File Systems Throughout History
Avoiding UI Issues with File I/O
Using StrictMode to Profile an Application
Moving Logic to Asynchronous Threads
Summary
Chapter 20: Working with Databases in Android
Working with SQLite: The World’s Most Popular Database!
Quickly Learning SQLite for Android Development
Creating SQLite Databases for Your Applications
Introducing the SQLiteExample Application
Creating a Database-Driven Activity
Choosing Query Approaches for SQLite and Android
Using the Query Building Process
Using the Raw Power of SQL
Managing Results from Queries with Cursors
Modifying Data with Your Android Application
Inserting Data
Updating Data
Deleting Data
Using the Room Persistence Library
Packaging and Managing SQLite Databases for Android
Managing Android Storage for Database Performance
Packaging SQLite Databases with Your Applications
Choosing SQLite Management Tools to Prepare Databases for Packaging
Working with Built-In Tools
Working with Third-Party Database Tools
Summary
Index

✦ Subjects

java jdk android apps