Complete Android Programming with KitKat 4.4

Explore the model view controller pattern in Android, where the controller coordinates between the model and the view, with activities acting as controllers and the model encapsulating data.

Explore a model-view-controller demo in a KitKat era Android app, wiring inputs and outputs via a view, a controller, and a model.

Explore how activities map to controllers and layouts to manage views, assign control IDs in layout xml, and access those IDs and string resources via find view by id.

Learn to access resources in code and layouts, reference string resources, and add a new text view below a button in a relative layout.

Learn how intents act as messages to start new activities and pass data within an Android app using extras, manifest setup, and result handling via on activity result.

Launch a detail activity from the main activity using the simplest android intent and startActivity, with text from string resources. Observe the detail activity lifecycle as it opens and returns.

Learn to pass data between Android activities with intents, using a single button handler and putExtra, then retrieve with getStringExtra and display in the detail activity text view.

Demonstrates starting a detail activity for a result using intents, passing data via extras, and returning the choice to the main activity with a request code.

Explore Android user interface layouts, focusing on linear and relative layouts, their orientation, positioning rules, and how margins, padding, gravity, and weight control space and alignment.

Explore Android Studio layout fundamentals, focusing on relative layout, match_parent sizing, padding and margins, and attributes like center horizontal and align start to position views.

Explore relative and linear layouts in Android, and learn how layout_weight and wrap_content influence three button widths, offering equal widths or filled spaces within a parent layout.

Explore fragments in Android as modular UI components with their own lifecycle inside activities, which can be added, removed, and inflated with layouts, and managed on the back stack.

Explore Android controls, distinguishing active and passive elements, and reference them with android:id and find view by id, handle clicks with on click, and register listeners for other events.

Compare Android's onClick attribute with an explicit onClick listener to handle button clicks, using findViewById and text view updates, and note when other events require listeners.

Learn how to attach both on click and on long click listeners to a single Android button, update a text view, and control event propagation with return values.

learn to use string resources from code, manage onClick events for multiple buttons, and localize an Android app with values-fr tuned to device language settings.

Learn how list views render items from arrays, lists, or databases using adapters and list adapters. Bind data with array adapters and handle item clicks within a list activity.

Demonstrates a basic Android list view loading a string array, handling item clicks, and opening a detail screen by passing label and index via an intent bundle.

Demonstrate an Android list view by using an array list of strings with an array adapter, adding entries via a button, and removing items on click with notify dataset changed.

Explore building a list activity with a custom list item layout, using an array adapter to display rainbow colors, and showing a toast on list item click.

Create a custom list view in a list activity using a linear layout with two text views, left and right, managed by a base adapter.

Use a spinner to select a color from a string array via an adapter and set the layout background in Android, with white, red, green, blue, yellow, magenta, and cyan.

Discover how Android uses SQLite for data storage, covering CRUD, tables, rows, columns, and storage classes (null, integer, real, text, blob) with type affinity.

Master the basics of SQLite in Android by creating and dropping tables, inserting, updating, and deleting data, and selecting data with where clauses and order by.

Learn how to use SQLiteOpenHelper to connect to a SQLite database in Android, create and upgrade tables, and perform inserts, updates, and reads via a cursor.

Learn to build a simple Android SQLite database with sequel lite, creating a planets table, inserting initial data, upgrading via version changes, and querying with a cursor and rawQuery.

Use the simple cursor adapter to bind a SQL cursor to an adapter view by mapping data columns to layout elements, using its six-argument constructor and underscore ID requirement.

Build a simple note taker app with a sqlite-like database, adding and deleting notes, and viewing details in a separate activity using a cursor adapter, intents, and results.

Explore how Android services run in the background, including started and bound services, their lifecycle methods, and how an intent service adds threading and auto-stops when done.

Learn how to implement a simple started service in Android KitKat 4.4, using onCreate and onStartCommand, managing lifecycle, passing numbers via an intent to compute and display their sum.

Demonstrate using an intent service to run a long-running task in the background, handle intents with extras, and compare it to a started service to keep the user interface responsive.

Discover how to use a result receiver to return data from service, packaging the receiver in intent bundle as a parcelable, sending results back via onReceiveResult, and handling bundle data.

Learn to use a result receiver with a service that sums two numbers and returns the result to the UI, while managing lifecycle to avoid memory leaks.

Explore how bound services private to an application bind via bind service, with an intent, a service connection, and flags, return a binder, and stop when the last component unbinds.

Explore bound services in Android KitKat 4.4 by building a math service with a binder and manifest entry, and a client that binds and calls add, subtract, multiply, and divide.

Explore implicit intents in Android, contrast with explicit intents, and learn how actions, data, and intent filters in the manifest determine the destination.

Demonstrate an implicit intent that launches a web browser to perform a Google search, building a search URI from user input and starting an activity with action view.

Demonstrate using implicit intents with action view and category default to launch activities in another app, passing data via extras.

Content providers offer data access for sharing with other apps or within your own, via a content resolver and content uris with authority, path, and row id.

Learn how to access the device's contact list using a content provider in an Android app, including manifest permissions, content resolver queries, and cursor-driven name display with next/previous navigation.

Explore Android fragments as self-contained components within an activity and their lifecycle. Learn how to inflate fragment layouts, access their views, and switch, hide, delete, and add fragments.

Demonstrates embedding a fragment in an activity by inflating the fragment layout inside a container, using onCreateView and onResume to set text in the fragment text view.

Learn how activities communicate with their fragments using the fragment manager, perform fragment transactions (add, replace, show, hide), and implement event callbacks with a listener interface attached in on attach.

Demonstrates two fragments in one activity, with a top radio group (red, green, blue) that changes the bottom fragment's background color and clears radio selections on click.

Learn how Android handles orientation changes between portrait and landscape, including automatic layout swapping, activity restart, saving state with a bundle, and overriding on configuration changed with manifest configChanges entry.

This demo shows automatic orientation changes between portrait and landscape in an Android app, and demonstrates how enabling configChanges for orientation or screen size prevents activity destruction and triggers onConfigurationChanged.

Learn to swap portrait and landscape fragments on configuration changes by handling on configuration change, using fragment manager and transactions to replace fragments without recreating the activity.

Master view animation and tween animation in android with xml files to rotate, scale, translate, and alpha using offsets and interpolators, and apply them in code via loadAnimation and startAnimation.

Demonstrates Android view animation (tween) with rotation, scale, and translation; rotates 0–180 degrees and scales to 1.5x, moves right, but snaps back—showing why property animation is needed to change properties.

Explore property animation with value animator and object animator to change any object’s properties over time using start and end values, duration, optional listeners, and animator sets (sequential or simultaneous).

Demonstrates simple property animation using object animator to translate a text view along the y-axis by 100 pixels per click, with 300 ms duration and reset after 600.

Learn to build synchronized and sequential animations in android using animator sets; rotate an image and move it right and left, driven by an on click and source code walkthrough.

Learn to obtain location data in the Android emulator by configuring fine location permission and publishing latitude and longitude to the UI via the location listener, starting and stopping updates.

Explore how the Android sensor api handles motion, environment, and position sensors. Learn to query sensors, implement a sensor event listener, and read x, y, z data.

Learn how to use the accelerometer to publish x, y, z acceleration values and accuracy in an Android app, including sensor manager setup, listener registration, and handling no-sensor scenarios.

Learn to build a step counter service that tracks total steps, vibrates every 1000 steps using the vibrator service, and shows the count in a main activity text view.