Cover
Title Page
Copyright and Credits
Contributors
Table of Contents
Preface
Chapter 1: Beginning Android and Java
Technical requirements
What's new in the third edition?
Why Java and Android?
The beginner's first stumbling block
How Java and Android work together
Understanding the Android API
Java is object-oriented
Run that by me again โ what exactly is Android?
Android Studio
Setting up Android Studio
What makes an Android app?
Android resources
The structure of Android's Java code
Packages
Classes
Methods
Building our first Android app
Deploying the app so far
Running and debugging the app on an Android emulator
Running the app on a real device
Frequently asked questions
Summary
Chapter 2: First Contact: Java, XML, and the UI Designer
Technical requirements
Examining the logcat output
Filtering the logcat output
Exploring the project Java and the main layout XML
Examining the MainActivity.java file
Examining the app layout file
Adding buttons to the main layout file
Adding a button via the visual designer
Adding a button by editing the XML code
Giving the buttons unique id attributes
Positioning the two buttons in the layout
Making the buttons call different methods
Leaving comments in our Java code
Coding messages to the user and the developer
Writing our first Java code
Adding message code to the onCreate method
Writing our own Java methods
Frequently asked questions
Summary
Chapter 3: Exploring Android Studio and the Project Structure
Technical requirements
Project Explorer and project anatomy
Exploring the file and folder structure of the Empty Activity project template
Exploring an Empty Activity project
Exploring the file and folder structure of the Basic Activity project template
Exploring a Basic Activity project
Exploring the Android emulator
Emulator control panel
Using the emulator as a real device
Summary
Chapter 4: Getting Started with Layouts and Material Design
Technical requirements
Finding out about Material Design
Exploring Android UI design
Introducing layouts
Creating and exploring a layout project
Building a layout with LinearLayout
Adding a LinearLayout layout type to a project
Preparing your workspace
Examining the generated XML
Adding a TextView to the UI
Wiring up the UI with the Java code (Part 1)
Adding layouts within layouts
Making the layout look pretty
Wiring up the UI with Java code (Part 2)
Building a precise UI with ConstraintLayout
Adding a CalendarView
Adding and constraining more UI elements
Making the text clickable
Laying out data with TableLayout
Adding a TableRow element to TableLayout
Organizing the table columns
Linking back to the main menu
Summary
Chapter 5: Beautiful Layouts with CardView and ScrollView
Technical requirements
Attributes quick summary
Sizing using dp
Sizing fonts using sp
Determining size with wrap or match
Using padding and margin
Using the layout_weight property
Using gravity
Building a UI with CardView and ScrollView
Setting the view with Java code
Adding image resources
Creating the contents for the cards
Defining dimensions for CardView
Adding CardView to our layout
Creating a tablet emulator
Frequently asked question
Summary
Chapter 6: The Android Lifecycle
Technical requirements
The life and times of an Android app
How Android interacts with our apps
A simplified explanation of the Android lifecycle
The lifecycle phases demystified
How we handle the lifecycle phases
Lifecycle demo app
Coding the lifecycle demo app
Running the lifecycle demo app
Examining the lifecycle demo app output
Some other overridden methods
The structure of Java code โ revisited
Introducing fragments and the lifecycle
Summary
Chapter 7: Java Variables, Operators, and Expressions
Technical requirements
Java is everywhere
Understanding Java syntax and jargon
More code comments
Storing and using data with variables
Types of variables
Using variables
Variable declaration
Variable initialization
Changing values in variables with operators
The assignment operator
The addition operator
The subtraction operator
The division operator
The multiplication operator
The increment operator
The decrement operator
Trying out expressions
Expressing Yourself demo app
Summary
Chapter 8: Java Decisions and Loops
Technical requirements
Making decisions in Java
Indenting code for clarity
More operators
How to use all these operators to test variables
Switching to make decisions
The switch demo app
Repeating code with loops
while loops
do while loops
for loops
Loops demo app
Summary
Chapter 9: Learning Java Methods
Technical requirements
Methods revisited
What exactly are Java methods?
Method structure
Modifier
Return type
Name of the method
Parameters
The body
Using method demo apps
Real-world methods
Exploring method overloading
Scope and variables revisited
Method recursion
Questions
Summary
Further reading
Chapter 10: Object-Oriented Programming
Technical requirements
Important memory management warning
Object-oriented programming
What is OOP exactly?
Why do it like this?
Class recap
Looking at the code for a class
Class implementation
Declaring, initializing, and using an object of the class
Basic classes app
More things we can do with our first class
Frequently asked questions
Summary
Chapter 11: More Object-Oriented Programming
Technical requirements
Remember that encapsulation thing?
Controlling class use with access modifiers
Controlling variable use with access modifiers
Methods can have access modifiers too
Accessing private variables with getters and setters
Setting up our objects with constructors
Static methods
Encapsulation and static methods mini-app
OOP and inheritance
Inheritance example app
Polymorphism
Abstract classes
Interfaces
Frequently asked questions
Summary
Chapter 12: The Stack, the Heap, and the Garbage Collector
Technical requirements
All the Android UI elements are classes too
Re-introducing references
So how does this heap thing help me?
Using buttons and TextView widgets from our layout
Running the app
Inner and anonymous classes
Frequently asked questions
Summary
Chapter 13: Anonymous Classes โ Bringing Android Widgets to Life
Technical requirements
Declaring and initializing the objects
Creating UI widgets from pure Java without XML
Exploring the palette โ part 1
The EditText widget
The ImageView widget
Radio buttons and groups
Anonymous classes
Exploring the palette and more anonymous classes โ part 2
Switch
CheckBox
TextClock
Using WebView
The Widget Exploration app
Setting up the Widget Exploration project and UI
Coding the Widget Exploration app
Using WebView
Running the Widget Exploration app
Summary
Chapter 14: Android Dialog Windows
Technical requirements
Dialog windows
Creating the Dialog Demo project
Coding a DialogFragment class
Using the DialogFragment class
The Note to Self app
Using naming conventions and string resources
How to get the code files for the Note to Self app
The completed app
Building the project
Preparing the string resources
Coding the Note class
Implementing the dialog designs
Coding the dialog boxes
Showing our new dialogs
Summary
Chapter 15: Arrays, Maps, and Random Numbers
Technical requirements
A random diversion
Handling large amounts of data with arrays
Arrays are objects
Simple array example mini-app
Getting dynamic with arrays
Dynamic array example
Entering the nth dimension with arrays
Multidimensional array mini-app
Array-out-of-bounds exceptions
ArrayList
The enhanced for loop
Arrays and ArrayList instances are polymorphic
More Java collections โ meet the Java HashMap
The Note to Self app
Frequently asked questions
Summary
Chapter 16: Adapters and Recyclers
Technical requirements
RecyclerView and RecyclerAdapter
The problem with displaying lots of widgets
The solution to the problem of displaying lots of widgets
How to use RecyclerView and RecyclerAdapter
What we will do to set up RecyclerView with RecyclerAdapter and an ArrayList of notes
Adding RecyclerView, RecyclerAdapter, and ArrayList to the Note to Self project
Removing the temporary "Show Note" button and adding RecyclerView
Creating a list item for RecyclerView
Coding the RecyclerAdapter class
Coding MainActivity to use the RecyclerView and RecyclerAdapter classes
Running the app
Frequently asked questions
Summary
Chapter 17: Data Persistence and Sharing
Technical requirements
Android intents
Switching Activity
Passing data between activities
Adding a settings page to Note to Self
Creating SettingsActivity
Designing the settings screen layout
Enabling the user to switch to the settings screen
Persisting data with SharedPreferences
Reloading data with SharedPreferences
Making the Note to Self settings persist
Coding the SettingsActivity class
Coding the MainActivity class
More advanced persistence
What is JSON?
Java exceptions โ try, catch, and finally
Backing up user data in Note to Self
Frequently asked questions
Summary
Chapter 18: Localization
Technical requirements
Making the Note to Self app accessible for Spanish and German speakers
Adding Spanish language support
Adding German language support
Adding the string resources
Running Note to Self in German or Spanish
Making the translations work in Java code
Summary
Chapter 19: Animations and Interpolations
Technical requirements
Animations in Android
Designing cool animations in XML
Instantiating animations and controlling them with Java code
More animation features
Animation demo app โ introducing SeekBar
Laying out the animation demo
Coding the XML animations
Wiring up the animation demo app with Java
Frequently asked questions
Summary
Chapter 20 : Drawing Graphics
Technical requirements
Understanding the Canvas class
Getting started drawing with Bitmap, Canvas, and ImageView
Using the Canvas class
Preparing the instances of the required classes
Initializing the objects
Setting the Activity content
Canvas demo app
Creating a new project
The Android coordinate system
Plotting and drawing
Creating bitmaps
Manipulating bitmaps
What is a bitmap exactly?
The Matrix class
Bitmap manipulation demo app
Adding the graphic to the project
Frequently asked question
Summary
Chapter 21: Threads and Starting the Live Drawing App
Technical requirements
Creating the Live Drawing project
Refactoring MainActivity to LiveDrawingActivity
Locking the game to fullscreen and landscape orientation
Looking ahead at the Live Drawing app
Coding the LiveDrawingActivity class
Coding the LiveDrawingView class
Coding the LiveDrawingView class
The game loop
Threads
Problems with threads
Implementing the game loop with a thread
Implementing Runnable and providing the run method
Coding the thread
Starting and stopping the thread
Using the Activity lifecycle to start and stop the thread
Coding the run method
Running the app
Summary
Chapter 22: Particle Systems and Handling Screen Touches
Technical requirements
Adding custom buttons to the screen
Implementing a particle system effect
Coding the Particle class
Coding the ParticleSystem class
Spawning particle systems in the LiveDrawingView class
Handling touches
Coding the onTouchEvent method
Finishing the HUD
Running the app
The Android Studio Profiler tool
Summary
Chapter 23: Supporting Different Versions of Android, Sound Effects, and Spinner Widget
Handling different versions of Android
Detecting the current Android version
The SoundPool class
Initializing SoundPool the new way
Initializing SoundPool the old way
Sound demo app introducing the Spinner widget
Making sound effects
Laying out the sound demo
Coding the sound demo
Summary
Chapter 24: Design Patterns, Multiple Layouts, and Fragments
Technical requirements
Introducing the model-view-controller pattern
Android design guidelines
Real-world apps
Device detection mini-app
Coding the MainActivity class
Running the app
Configuration qualifiers
The limitation of configuration qualifiers
Fragments
Fragments have a lifecycle too
Managing Fragments with FragmentManager
Our first Fragment app
Fragment reality check
Frequently asked question
Summary
Chapter 25: Building a Simple Image Gallery App
Technical requirements
Angry Birds classic swipe menu
Building an image gallery/slider app
Implementing the layout
Coding the PagerAdapter class
Coding the MainActivity class
Running the gallery app
Summary
Chapter 26: Advanced UI with Navigation Drawer and Fragment
Technical requirements
Introducing NavigationView
Examining the Simple Database app
Insert
Delete
Search
Results
Starting the Simple Database project
Exploring the autogenerated code and assets
Coding the Fragment classes and their layouts
Creating the empty files for the classes and layouts
Coding the classes
Designing the layouts
Designing content_insert.xml
Designing content_delete.xml
Designing content_search.xml
Designing content_results.xml
Using the Fragment classes and their layouts
Editing the Navigation Drawer menu
Adding a holder to the main layout
Coding the MainActivity.java class
Summary
Chapter 27: Android Databases
Technical requirements
Databases 101
What is a database?
What is SQL?
What is SQLite?
SQL syntax primer
SQLite example code
Android SQLite API
SQLiteOpenHelper and SQLiteDatabase
Building and executing queries
Database cursors
Coding the database class
Coding the Fragment classes to use the DataManager class
Running the Age Database app
Summary
Chapter 28: A Quick Chat before You Go
Publishing
Make an app!
Keep learning
Keep reading
GitHub
Stack Overflow
Android user forums
Higher-level study
My other channels
Goodbye and thank you
Why subscribe?
Other Books You May Enjoy
Index