Android - professional mobile development

Explore Android fragments, their lifecycle and transactions, including using the support library for older devices, managing fragment managers, back stack, and dialog fragments for flexible, tablet-friendly user interfaces.

Explore fragment fundamentals and advanced features by implementing list and details fragments, handling fragment transactions, adapters, and inter-fragment communication within a single activity.

Implement a news item click via a news details fragment and fragment transactions, display details in the activity, and add the transaction to the back stack with an arguments bundle.

Explore fragment back stack management in Android, using fragment manager and transactions to navigate a Gmail-like list and detail views, with two fragment containers, visibility controls, and back button behavior.

Learn to create custom views on Android that encapsulate display logic for a model, extend a view or FrameLayout, inflate with tag merge, and bind data in one place.

Create a custom news description widget to render title and body in list and details views, then optimize with merge and proper layout inflator.

Learn to use Eskew light database on Android with a helper class that handles create, upgrade, downgrade, and safe read/write operations via content values, cursors, and transactions.

Implement a SQLite database for the news app by building a helper, defining a news table with id, title, and body, and using a contract and cursor converter to query.

Declare a new class as a dependency to parse database results and return a list, using an async task and adapter filler, then close the cursor and database.

Explore refactoring Android async tasks into separate classes, implement a news available listener to notify fragments, and manage database upgrades with transactions and a read flag to highlight read messages.

Manage read and unread news states in the news adapter by adjusting text color and marking items as read with an async task and database updates, plus content provider integration.

Explore Android content providers as a standard data sharing mechanism. Learn how content resolver, content observers, and sync adapters enable automatic data access, updates, and synchronization.

Guide to building an Android content provider backed by Eskew open helper, registered in the manifest, exposing data via content resolver and loaded with a cursor loader and cursor adapter.

Bind a view holder retrieved from the tag to display title and body fields. Configure a content provider with a URI matcher and use a loader to query news data.

Implement a single-item data loader using a content resolver and cursor for the news details fragment, adapting the UI to display the selected news by id and fix column errors.

Learn to build a news app using a content provider and content resolver to update data, notify observers, and refresh lists with cursor wrappers and batch operations.

Explore how to use content provider operations with apply batch, add transactions for safety and speed, and leverage content resolver and Uri matcher to insert, update, and delete data.

Explore Android asynchronous operations with AsyncTask, covering doInBackground, onPostExecute, onProgressUpdate, progress dialogs, inner classes, and handling results, exceptions, and UI thread constraints.

Implement a custom async task using an async result to distinguish exceptions from results. Improve UI reliability with progress dialogs, exception handling, and lifecycle-safe task management via a loader.

Learn to implement and manage loaders in a fragment to fetch news from a database via a News Service, handle multiple loaders, and add an unread count loader.

Learn to run two loaders in a single Android fragment with separate callbacks and private inner classes, and manage unread counts and news lists using distinct loader IDs.

Explore asynchronous loading with loaders, implement exception handling via try-catch and a dedicated load in another thread, and ensure data is captured as sync results for reliable user interface updates.

Explore Android services and broadcast receivers, including start and bind service lifecycles, intents, and threading, with communication to the main thread, and learn about ordered broadcasts and push notifications.

Practice android services and broadcast receivers by building a custom service, testing on start command behavior, start sticky vs not sticky, and using an intense service with broadcasts.

Implement and register broadcast receivers and services, observing toast messages on the main thread. Explore multiple receivers and actions, and integrate with content providers, observers, and binding for real-time updates.

Bind Android services with binder objects and service connections to coordinate item changes using ordered broadcasts. Implement a notification broadcast receiver to show alerts when new items are added.

Implement a notification broadcast receiver and news details activity triggered by implicit intents, using fragments and a content provider with mime types.

Explore how the Android action bar standardizes navigation using action bar Sherlock and the support library, with tabs, fragments, view pager, and styling resources.

Create a view pager with a fragment state pager adapter to show news and agenda fragments, and sync the action bar tabs with page changes.

Learn to implement and customize the Android action bar in a multi-fragment app, including share actions, up navigation, menu handling, and styling for compatibility across versions.

Explore Android gesture handling by turning a snake game from keyboard to touch screen control, detailing on touch events, motion events, and direction logic for a responsive game.

Learn to implement snake game mechanics in Android: update snake head with bitmap tiles, collision detection with walls and obstacles, dynamic blocks, and random oranges with safe placement.

Learn to apply dependency injection in Android with robo juice, improving testability and reducing coupling using inject annotations, modules, singleton patterns, and constructor or setter injection.

Explains dependency injection with the Roebourne framework for Android, replacing manual view binding with injection annotations and refactoring fragments and adapters for a streamlined view pager workflow.

Refactor an Android news app with Roboguice for dependency injection, inject database and context into fragments and services, and use a runner and event manager for background tasks.

Discover Android dependency injection patterns with a context singleton event manager, modules, named providers, lazy evaluation, and RoboJuice to inject across activities, intents, and services.

Demonstrates creating an agenda table in the conference app database using a database contract, content provider with Uri matcher, an agenda adapter, and a cursor wrapper for a four-text-view layout.

Create and insert a sample view into the list using an adapter layout, inflate with RoboJuice, bind with a view holder, and initialize the agenda via apply batch.

Master practical Android development by implementing content providers and SQLite helpers, handling MIME types, loaders, services, broadcast receivers, and modern tooling like RoboGuice and Action Bar Sherlock.