Android Programming for Beginners: Build in-depth, full-featured Android apps starting from zero programming experience, 3rd Edition

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