Android Programming for Beginners

Name: Android Programming for Beginners | Learn all the Java and Android skills you need to start making powerful mobile applications
Brand: Packt Publishing
Price: 37.99 EUR
Availability: OnlineOnly

Learn all the Java and Android skills you need to start making powerful mobile applications

John Horton(Autor*in)

Packt Publishing

1. Auflage

Erschienen am 31. Dezember 2015

698 Seiten

E-Book

PDF mit Adobe-DRM

Systemvoraussetzungen

978-1-78588-903-5 (ISBN)

37,99 €inkl. 7% MwSt.

Systemvoraussetzungen

für PDF mit Adobe-DRM

E-Book Einzellizenz

Als Download verfügbar

Zur neuen Auflage

Beschreibung

Weitere Details

Weitere Ausgaben

Inhalt

Cover
Copyright
Credits
About the Author
About the Reviewers
www.PacktPub.com
Table of Contents
Preface
Chapter 1: The First App
How Java and Android work together
The Android API
Java is object-oriented
What exactly is Android?
The development environment
A note to the existing developers who use Eclipse
The JDK
What if I already have Java?
Installing the JDK
Setting up Android Studio
What makes an Android app
Android resources
The structure of Android's Java code
Android packages
Our first Android app
Creating the project
A note on version controlling
Deploying and testing the app
Deploying to an emulator
Deploying to a real Android device
FAQ
Summary
Chapter 2: Java - First Contact
Examining the log output
Exploring the project assets and code
Examining the layout file
Improving our app and deploying again
Modifying the UI
Meet Java
Java comments
Sending messages
Writing our first Java code
Writing our own Java methods
Examining the log output
FAQ
Summary
Chapter 3: Exploring Android Studio
The Android Studio guided tour
Parts of the UI
The console
More console features
The project explorer
Transforming the editor into a design studio
E1 - the Preview toolbar
E2 - exploring the palette
E3 - the layout preview
E4 - the Component Tree
E5 - the Properties window
E6 - text and design view tabs
The project folder and file structure
FAQ
Summary
Chapter 4: Designing Layouts
Exploring Android UI design
Structure of a UI design
Configuring and using widgets
Widget properties
Experimenting with widgets
Containing widgets in layouts
RelativeLayout
Using LinearLayout
Summary
Chapter 5: Real-World Layouts
Building a real-world UI
Creating a tablet emulator
List-detail layout with scrollView and LinearLayout
Designing a form with RelativeLayout
Summary
Chapter 6: The Life and Times of an Android App
Introduction to the Android lifecycle
A simplified explanation of the Android lifecycle
Lifecycle phases - what we need to know
Lifecycle phases - what we need to do
The lifecycle demonstration app
Some other overridden methods
The structure of Java code - revisited
Summary
Chapter 7: Coding in Java Part 1 - Variables, Decisions, and Loops
Java is everywhere
Syntax and jargon
More code comments
Storing and using data with variables
Types of variables
Primitive types
Reference types
Variable declaration
Variable initialization
Changing values in variables with operators
Expressing yourself demo app
Decisions
Indenting our code
More operators
If they come over the bridge, shoot them
Else do this instead
Switching to make decisions
The Switch Demo app
Repeating code with loops
While loops
Breaking out of a loop
Continue
Do while loops
For loops
Loops demo app
Summary
Chapter 8: Coding in Java Part 2 - Methods
Methods revisited
The method structure
Modifiers
Return types
The name of a method
Parameters
Working in the method body
Using methods - demo apps
Real-world methods
Exploring method overloading
Scope and variables revisited
FAQ
Further reading
Summary
Chapter 9: Object-Oriented Programming
Important memory management warning
Introducing OOP
What is OOP exactly?
Encapsulation
Polymorphism
Inheritance
Why do it like this?
A class recap
Taking a look at the code for a class
The class implementation
Declaring, initializing, and using an object of the class
The basic classes mini app
More things we can do with our first class
Remember that encapsulation thing?
Controlling class use with access modifiers
Class access in a nutshell
Controlling variable use with access modifiers
Variable access summary
Methods have access modifiers too
A method access summary
Accessing private variables with getters and setters
Setting up our objects with constructors
Static methods
Encapsulation and static methods mini app
OOP and inheritance
The inheritance mini app
Polymorphism
Abstract classes
Interfaces
FAQ
Summary
Chapter 10: Everything's a Class
All Android UI elements are classes too
Reintroducing references
A quick break to throw out the trash
Stack and heap - a quick summary
So, how does this heap thing help me?
Using Button and TextView widgets from our layout
Inner and anonymous classes
FAQ
Summary
Chapter 11: Widget Mania
Exploring Android UI objects
Declaring and initializing objects
Widget news flash
Exploring the palette
EditText
ImageView
Radio button and group
Anonymous classes
A switch widget
CheckBox
WebView
Date & Time
Android permissions and Marshmallows
Pre-Marshmallow permissions
Marshmallow permissions
The permission solution used in this book
The Widget exploration mini app
Setting up the widget exploration project and UI
Coding the widget exploration app
Summary
Chapter 12: Having a Dialogue with the User
Dialog windows
The dialog demo mini project - introducing chaining
About the Note to self app
Using naming conventions and String resources
How to get the Note to self code
What we will do and when we will do it
What the user can do
Building the project and gathering resources
Downloading the images
Preparing the String resources
Coding the Note class
Implementing the dialog designs
Coding the dialog boxes
Coding the DialogNewNote class
Coding the DialogShowNote class
Showing our new dialogs
Adding a + icon to the action bar
Summary
Chapter 13: Handling and Displaying Arrays of Data
A random diversion
Handling large amount of data with arrays
Arrays are objects
A simple array example mini app
Getting dynamic with arrays
A dynamic array example
Entering the nth dimension with arrays
A multidimensional array mini app
Array out of bounds exceptions
ArrayLists
The enhanced for loop
Arrays and ArrayLists are polymorphic
ListView and BaseAdapter
The problem with displaying lots of widgets
The solution
How to use ListView and BaseAdapter
Inner classes revisited
FAQ
Summary
Chapter 14: Handling and Displaying Notes in Note To Self
Note To Self continued
Updating onCreate and preparing the UI
Creating a list item for ListView
Improvements in Note To Self
Persistence
Animation
Sound FX
Problems with the design of the code
FAQ
Summary
Chapter 15: Android Intent and Persistence
Good Intents
Switching Activity
Passing data between activities
Adding a settings page to the Note To Self app
Creating SettingsActivity
Designing the Settings screen's layout
Enabling the user to switch to the Settings screen
Persisting data with SharedPreferences
Making the Note To Self app's settings persist
Coding the SettingsActivity class
Coding the MainActivity class
Specifying a parent Activity
More advanced persistence
What is JSON?
Java exceptions - try, catch, and finally
Backing up user data in Note To Self
FAQ
Summary
Chapter 16: UI Animations
Animations in Android
Designing cool animations in XML
Fading in and out
Movement
Scaling or stretching
Controlling the duration
Rotating animations
Repeating animations
Combining animation properties with a set tag
Instantiating animations and controlling them with Java code
More animation features
Listeners
Animation interpolators
The Animations Demo app - introducing SeekBar
Laying out the animation demo
Coding the XML animations
Wiring up the Animations Demo app in Java
Adding animations to Note To Self
Defining the animations in XML
Controlling the animations in Java
FAQ
Summary
Chapter 17: Sound FX and Supporting Different Versions of Android
Supporting multiple versions of Android
Detecting the current Android version
The SoundPool class
Building SoundPool the new way and the old way
Loading sound files into memory
Playing a sound
Stopping a sound
Introducing the Spinner widget
Making sound FX
Laying out Sound Demo UI
Coding the Sound Demo app
Sound FX touches to Note To Self
Deleting a note - introducing OnLongClick
FAQ
Summary
Chapter 18: Design Patterns, Fragments, and the Real World
Introducing the model-view-controller pattern
The model
The view
The controller
The imperfections of Note To Self revisited
Android design guidelines
Real-world apps
The device detection mini app
Configuration qualifiers
Using configuration qualifiers - mini app
The configuration qualifier's summary
Fragments
Fragments have a lifecycle too
onCreate
onCreateView
onAttach and onDetach
onStart, onPause, and onStop
Managing Fragments with FragmentManager
Our first working Fragment mini app
Fragment reality check
FAQ
Summary
Chapter 19: Using Multiple Fragments
Using singletons for the model layer
Inter-Fragment communications - interfaces revisited
The dual-Fragment address book mini app
Getting started
Alias resources
The NameAndAddress class
Creating the communication interface
Explaining the structure of the onListItemSelected method
Explaining the code that starts a new Activity
Explaining the code when the detail Fragment is already present
What do we need to do?
Creating the AddressDetailFragment class and layout
Coding PortraitDetailActivity and the layout
FAQ
Summary
Chapter 20: Paging and Swiping
Building an image gallery/slider app
Implementing the layout
Coding the PagerAdapter class
Coding the MainActivity class
Running the gallery app
Building a Fragment pager/slider app
Coding the SimpleFragment class
fragment_layout
Coding the MainActivity class
The activity_main layout
Running the Fragment slider app
Summary
Chapter 21: Navigation Drawer and Where It's Snap
Introducing the navigation drawer
The Where it's snap app
Preparing the resources
Placeholder code for three Fragments
Coding the MainActivity class and layout
Switching between Fragments
Setting up the drawer
Handling the back button
Summary
Chapter 22: Capturing Images
Capturing images using the camera
The capturing images mini app
Adding the camera permission to the manifest
Defining a simple layout
Coding the MainActivity class
Running the Simple Photo app
Where it's snap - coding the capture Fragment
Creating the layout for the capture Fragment
Coding the capture Fragment
Testing the capture Fragment
Summary
Chapter 23: Using SQLite Databases in Our Apps
Database 101
What is a database?
What is SQL?
What is SQLite?
The SQL syntax primer
The SQLite example code
Creating a table
Inserting data into the database
Retrieving data from the database
Updating the database structure
The Android SQLite API
SQLiteOpenHelper and SQLiteDatabase
Building and executing queries
Database cursors
The database mini app
Implementing the layout
Coding the database class
Coding MainActivity
Running the mini app
Summary
Chapter 24: Adding a Database to Where It's Snap
The Photo class
Handling the SQLite database
Saving a new photo from the capture fragment
Displaying a photo from the database
Preparing the View layout
Coding the ViewFragment class
Coding the communications interface
Coding TitlesFragment
Coding TagsFragment
Coding the fragment communications in MainActivity
Running the app so far
Summary
Chapter 25: Integrating Google Maps and GPS Locations
Global Positioning System
Where in the world - the GPS mini app
Where in the world - implementing a simple layout
Coding the Where in the world mini app
Running the Where in the world mini app
The Google Maps mini app
Preparing to connect to Google Maps
Acquiring an API key
Installing the Google Play services API
Coding the maps_activity layout
Coding MapsActivity
Running the Simple Map app
Summary
Chapter 26: Upgrading SQLite - Adding Locations and Maps
Adding locations and maps to Where it's Snap
Updating the database
Adding member variables to represent location data
Updating the database version
Adding code in onUpgrade to upgrade the database for existing users
Updating the database creation code in onCreate for new users
Updating the addPhoto method to handle GPS coordinates
Updating the Photo class
Updating CaptureFragment
Updating ViewFragment
Adding location permissions
Testing the new map feature
Summary
Chapter 27: Going Local - Hola!
The Localization mini app
Preparing the layout
Preparing the first strings.xml file
Making the app multilingual with the second strings.xml file
Adding a third language
Running the app
Localizing the Where it's snap app
Summary
Chapter 28: Threads, Touches, Drawing, and a Simple Game
Threads
Problems with threads
Drawing with canvas and paint
The Android coordinate system
Android Canvas demo app
Handling touches
A simple game engine
Building a simple game of Pong
Adding sound files to the project
Coding the ball
Coding the paddle
Coding MainActivity
Coding SurfaceView
Coding the update method
Coding the draw method
Lock the screen orientation and make it full-screen
Running the game
Pong enhancements
Summary
Chapter 29: Publishing Apps
Preparing to publish
Creating an app icon
Preparing the required resources
Building the publishable APK file
Publishing the app
Marketing
More to see
Summary
Chapter 30: Before You Go
What next
Keep reading
GitHub
StackOverflow
Android user forums
For further study
Make some apps!
gamecodeschool.com
Goodbye and thank you
Index

Systemvoraussetzungen

Als PDF speichern Als Link merken