Android App Development Masterclass using Kotlin

Install Android Studio on Windows 64-bit, verify system type, and follow the setup wizard. Learn how to configure HAXM, RAM allocation, and note 32-bit deprecation.

Download and install Android Studio on mac, run the setup wizard, enable Android Virtual Device and SDK, and configure HAXM memory for faster emulation.

Install Android Studio on Linux and configure virtualization with KVM for Android emulators; verify 64-bit Linux, download the latest Android Studio from the official source, and run studio.sh.

Configure Android Studio with the SDK Manager to install Android 29 SDK platform, add Intel x86 and Google Play system images, and avoid spaces in the SDK path.

Configure Android Studio for easier use by sticking to the stable channel, enabling auto import on the fly, showing line numbers and method separators, and adjusting code folding.

Enable VT-x or AMD-V in the BIOS to speed up emulators and allow HAXM to run on Windows or Mac. Be sure to note changes and reboot.

Launch your first Android app, create a project, run it on an Android virtual device with an emulator, set up a real device, and learn Android Studio templates.

Explore how Android Studio templates shape project setup and language choices for Kotlin or Java. Compare basic activity and empty activity templates, and learn to modify or remove template features.

Explore creating a new Android Studio project with the basic activity template, compare it to the empty activity template, and understand content_main.xml and activity_main.xml layouts.

Create your first android app in android studio with kotlin, using a hello world project, a unique package name, a generated layout, an empty activity, and minimum API 17.

Navigate Android Studio, configure the layout editor with design and blueprint views, and learn XML attributes and constraint layouts while selecting API versions.

Run your android app on the emulator via Android Studio and the AVD Manager, starting Hello World on a virtual device and monitoring Logcat.

Connect a real Android device to Android Studio, enable developer options and USB debugging, and verify the device appears as connected for testing.

Set up and run pure Kotlin code in Android Studio or IntelliJ, convert Java to Kotlin, and use the Kotlin tutorial project to build a hello world program.

Learn Kotlin fundamentals by writing a simple main function, using print and println to output strings and pass arguments, while handling syntax rules and common Android Studio errors.

Declare Kotlin variables with types, assign values, and print results to understand strings, integers, and basic arithmetic.

Learn Kotlin naming rules, camel case, and refactoring techniques in Android Studio to write clearer, correctly typed code; explore variables, types, and arithmetic with int and double.

Master Kotlin string manipulation by using concatenation and string interpolation to embed weeks, years, and fruits in strings, and learn escaping and handling symbols like the dollar sign.

Master Kotlin variable declarations by using val for immutable values, var for changeable ones, and leveraging type inference to reduce redundant explicit types.

Master conditional logic in Kotlin with if statements and boolean expressions, learn to use else and else if, and explore input driven decisions and simple voting age checks.

Explore Kotlin classes in Android app development: define a Player class with name, lives, level, and score using a primary constructor, create instances, and show properties.

Explore Kotlin classes and objects by using a template to create multiple player instances with name, lives, level, score, and weapon; learn dot notation to access and modify them.

Create a dynamic inventory system in Kotlin by defining a Loot class and LootType enum, then use an ArrayList to store multiple Loot items in the player's inventory.

Explore managing a player inventory with an array list in Kotlin, using add and get to handle loot, display output with a custom toString, and refine printing by overriding toString.

Override the toString methods in the loot and weapon classes to reveal properties, then test by running the program to show red potion details and weapon damage.

Master Kotlin for loops and ranges to iterate over lists and numbers, using for each, until, down to, and step, plus modulus to filter divisible values by three and five.

Learn how encapsulation with private inventory in Kotlin shields data from external code, exposing controlled access via getloot and droploot while keeping main decoupled from storage details.

Master Kotlin function overloading and default parameters by implementing drop loot variants, and use removeIf to update inventory based on item name for enhanced code flexibility.

Explore Kotlin inheritance by defining a base class and subclasses, using open to enable extension, and implementing properties and methods like take damage in a game example.

Override the toString function to print enemy properties and test an enemy instance. Extend the enemy class with a Troll subclass using inherited take damage and constructor logic.

Create a vampire subclass of enemy in Kotlin, override take damage to halve damage using super, and explore Kotlin’s class hierarchy from Any to Enemy to Vampire.

Master Kotlin while loops, conditions, and control flow with break and continue, demonstrated through Dracula's lives, dodges, and random events.

Explore Kotlin for loops to iterate over collections and ranges, sum loot values into a total score, and understand type-safe accumulation while comparing with while loops.

Learn how the do-while loop guarantees code execution at least once by testing the condition at the end, unlike the while loop. See practical Kotlin examples for Android app development.

Implement a single item drop in the kotlin player class by rewriting dropLoot to remove items by name with a for loop, handling returns, and testing with duplicates.

Set up a playground Android Studio project and explore ConstraintLayout and LinearLayout, while practicing with the Layout Designer and ImageView, handling resources and Kotlin and Java options.

Master Android Studio's layout designer by using Android view, design and blueprint surfaces, and applying constraints to position an image view with drawable assets.

Learn to position an image view with constraints in Android Studio, using constraint handles, margins, and bias to center or edge-align widgets, then explore scale type and fixed layouts.

Explore Android image scaling by testing scaleType options (none, matrix, fitXY, fitStart, fitCenter, centerCrop) in ImageView, and understand the difference between widget positioning and content alignment.

Explore how inner lines in a widget define width and height behavior, switching between fixed, match_constraints, and wrap_content while using srcCompat, fitXY, and a 100x100 ball image.

Explore cross-device compatibility by designing responsive layouts with constraint layout, using dp and sp instead of px, and previewing on multiple devices to ensure consistent visuals.

Master constraint layout by learning to align widgets, delete and create constraints, and use match_constraints and centreCrop to build responsive Android layouts.

Explore baseline constraints in Android Studio to align OK and Cancel buttons, anchor them to the bottom right, and use text baseline alignment for consistent button layouts.

Constrain the EditText bottom to the Cancel button to prevent overlap, switch wrap_content to match_constraint with a fixed height in landscape mode, and set width to match_constraint using constraint handles.

Enable vertical scrolling for Android edit texts to prevent keyboard overlap and add scroll indicators. Configure constraints for rtl support with start and end attributes, test portrait and landscape layouts.

Set up an Android project with Kotlin support and API 17, then design the button counter app layout using constraints, margins, and anchors to place text, button, and text view.

Constrain a text view in a constraint layout, set match_constraint, and apply 16dp margins; enable vertical scrollbars with right and end indicators for responsive portrait and landscape layouts.

Explore how main activity code in kotlin extends appcompatactivity, inflates activity_main layout via setContentView, and manages bundles and orientation changes within the android app framework.

Learn how to bind UI widgets—an EditText, a Button, and a TextView—from the layout using findViewById after setContentView, and understand how the Android R class and IDs connect to code.

Run and test your Android app on an emulator, verify button taps update a textView, ensure scrolling works, clear text, fix three issues, and prepare for orientation changes.

Learn to retrieve text from an EditText via its text property and append it to a TextView, using Kotlin patterns and Android Studio updates to convert Java examples.

Explore Android app development with Kotlin by refining variables, managing view scope, and clearing an editText on button click using text.clear() or setText("").

Resolve outdated Kotlin runtime warnings by manually updating the Kotlin version in the secondary Gradle file, syncing the project, and verifying plugin compatibility while preparing to discuss the activity lifecycle.

Understand how Android saves and restores activity state during configuration changes with savedInstanceState and Bundle, and how editText input is preserved while TextView is not.

Learn to use the logcat pane in Android Studio to monitor app behavior, filter logs by app and tag, and track events like onCreate, button clicks, and device rotation.

Learn to log activity lifecycle events with Android Studio by generating override methods and inserting log statements for onCreate, onStart, onRestoreInstanceState, onSaveInstanceState, onResume, onPause, onStop, onRestart, and onDestroy.

Explore the Android activity lifecycle and how rotation and screen locking affect onPause, onSaveInstanceState, onStop, onDestroy, and onRestoreInstanceState, with logcat debugging.

Master saving and restoring state in Android apps by using onSaveInstanceState and onRestoreInstanceState with bundles and keys. Understand how rotation and lifecycle events affect text and view content.

Create a basic calculator to practice advanced layouts and grouped widgets with a shared OnClickListener, featuring two-line display and portrait versus landscape adaptation in Android Studio with Kotlin.

Design a calculator user interface by adding a top edit text for results (number signed), arranging a 4x4 button grid with constraint layout, 8dp margins, and baseline constraints for movement.

Apply advanced constraint layout to align and organize calculator buttons, assign ids and symbols, adjust margins and wrap content, and coordinate text views for operation display and numeric input.

Constrain the newNumber and operation views, set 18 sp text and decimals, and manage focus with focusable attributes and a tools workaround, while previewing portrait and landscape layouts.

Create a landscape-specific layout for the Android calculator by duplicating the portrait layout, adjusting constraints between the two edit text widgets in Android Studio, and previewing changes in the emulator.

Use Android Studio's diff tool to compare XML layout files, reformat code, and align widget order to spot and merge layout differences, constraints, and margins across portrait layouts.

Learn to compare directory trees in Android Studio by matching project structures, focusing on res and Java folders, and using the diff tool at the packaged levels.

Implement calculator logic in Kotlin by wiring number input buttons with OnClickListener instances, initializing widgets, and handling pending operations in MainActivity.

implement and test calculator button event handlers in kotlin, wiring digit and operation buttons, enforce a single decimal point, and scaffold a dummy perform operation to validate user interaction.

Implement performOperation in Kotlin to manage operand1 and operand2, track pending operations, handle equals, and safely produce NaN on division by zero.

Prevent crashes in a Kotlin Android calculator by validating input, converting strings to doubles, and handling NumberFormatException with a try/catch. Improve state management and code clarity through refactoring.

Learn how to preserve app state during configuration changes in a Kotlin-based Android calculator by saving and restoring pending operations and operands with onSaveInstanceState and onRestoreInstanceState.

Explore Kotlin Android extensions for cleaner widget access by importing synthetic properties and using cached view references, replacing boilerplate find view by id with lazy or late init techniques.

Center groups of widgets in constraint layout with vertical guidelines to anchor a key widget. Learn to split button groups around the guideline and apply baseline constraints.

Add a negate button to the Android calculator in landscape layout, centering the grid. Copy an existing button, rename to button neg, set text to neg, and apply 12sp.

Learn to implement the Kotlin negate button by updating the input field with a negative value using onClickListener and proper error handling for empty or invalid inputs.

Explore adding a negate button to the portrait layout using constraint layout, aligning buttons via a central column, baselines, and edge constraints, with minimal margin adjustments.

Downloads the top 10 free apps RSS feed, parses XML to extract title and summary, and displays entries in a list via a custom adapter and ListView.

Learn to download an RSS feed on a background thread with AsyncTask in Kotlin, preventing UI freezes by offloading work from the main thread and updating the UI on completion.

Convert the inner AsyncTask to a static nested class via Kotlin's companion object to prevent leaks, then log with Log.d in onCreate, doInBackground, onPostExecute, and execute.

Learn to download an RSS feed in Android using Kotlin by executing a background task with AsyncTask, handling vararg URLs and HTTP connections with buffered readers and error logging.

Learn to read data from HTTP connections with input streams and buffered readers in Kotlin, and handle exceptions like malformed URLs and missing internet permissions in Android.

Learn to enable internet access by declaring the internet permission in the manifest, catch security exceptions, and use logcat filters to diagnose network errors.

Streamline Kotlin code by consolidating verbose catch blocks with a when expression and embracing functional stream reading using buffered.reader and readText.

Explore how Kotlin extension functions simplify android download code by replacing verbose Java logic with a single line using URL.readText, and manage resources safely with use.

Parse an rss xml feed in Kotlin by creating a FeedEntry class and a parse function that uses xmlPullParser to extract name, artist, release date, summary, and image URL.

Use the XmlPullParser with a reader to stream XML data and parse start tag, text, and end tag events, building FeedEntry objects from name, artist, releaseDate, summary, and image.

Run the app and diagnose with logcat, fix a null cast using the safe call operator while parsing xml with a pull parser, and build dynamic feed entries for display.

Display parsed feed data on Android devices using a ListView with an ArrayAdapter, replacing the default TextView and creating a list item layout for dynamic scrolling.

Adapt the array adapter for a list view by wiring the DownloadData async task, passing context and list view, and using delegates.notNull to prevent leaks during UI updates.

Use ListView with ArrayAdapter, override toString for readable data, and handle AsyncTask cancellation on destroy with by lazy initialization for downloadData.

Create a custom adapter for ListView that displays a ConstraintLayout row with tvName, tvArtist, and tvSummary arranged one below the other and growing to fit content, using list_record.xml and list_item.xml.

Build a dynamic Kotlin feed adapter by extending ArrayAdapter with a FeedEntry list. Inflate list_record.xml, bind name, artist, and summary, and note planned view holder optimization.

Optimize a custom ListView adapter by reusing convertView to avoid new view inflation, profile memory with the Android profiler, and reduce usage toward the upcoming ViewHolder pattern.

Learn how to implement the view holder pattern in Android list views using Kotlin to improve getView efficiency, reduce findViewById calls, and achieve smoother scrolling.

Design and implement a dynamic Android menu by creating a menu resource and adding items such as free apps, paid apps, and songs using the menu designer.

Inflate the feeds menu in onCreateOptionsMenu and handle item selections in onOptionsItemSelected to update feed URLs and run a DownloadData AsyncTask, using Kotlin with safe calls for nullables.

Create and manage Kotlin menu items to toggle top 10 and top 25 feeds, store url and limit as class fields, format urls, and preserve state across orientation changes.

Implement a refresh option in the Android menu and track the feed URL to prevent unnecessary downloads. Save the URL and limit across rotations with onSaveInstanceState and restore in onCreate.

Set up an Android Studio project, download and integrate the YouTube Android Player API jar, and configure dependencies and project structure using the libs folder and Gradle.

Learn to launch a new activity from your app by creating YouTubeActivity, extending YouTubeBaseActivity, implementing YouTubePlayer.OnInitializedListener, and adding a YouTubePlayerView programmatically in Kotlin.

Learn to add UI widgets programmatically in Kotlin by inflating layouts, casting to ConstraintLayout, and using layoutParams to insert a button and a YouTubePlayerView.

Obtain a Google API key for the YouTube Data API, restrict it to Android apps with the SHA1 fingerprint, then apply it in your Kotlin app.

Store the Google API key as a string resource named google_api_key in a values file (keys.xml) and use string resources in code to avoid hard-coded keys and improve security.

Initialize the YouTubePlayerView with your Google API key in onCreate, implement YouTubePlayer.OnInitializedListener, and handle success or failure using a toast or recoverable error dialog via YouTubeInitializationResult.

Implement robust handling of YouTube Player initialization in Kotlin, including requesting internet permission, logging parameter types in onInitializationSuccess, showing a toast, and cueVideo when not restored.

Attach a playback event listener and a state change listener to the YouTube Player to respond to playing, paused, stopped, ad started, and video ended events, with toast feedback.

Enhance the Android YouTube player by switching from cueVideo to loadVideo for auto play on app start and ensure playback across orientation changes, using logcat for debugging timing and callbacks.

Add a main screen with two buttons to play a single video or a playlist, and learn how one Android activity starts another using constrained layouts and IDs.

Implement onClickListeners and launch the YouTube standalone player via intents for video and playlist in a manually created Kotlin activity, using setContentView with activity_standalone.

Explore how intents drive inter-activity communication in Android, including creating video and playlist intents with YouTubeStandalonePlayer, wiring buttons, and updating the manifest.

Configure video and playlist intents with the YouTube Standalone Player to autoplay from the start, using timeMillis, autoplay, and lightboxMode, and explore orientation-aware playback behavior.

Learn to improve the user experience after errors by presenting a recoverable error dialog and handling fixes with startActivityForResult and onActivityResult, such as enabling the YouTube app.

Learn to build a Flickr browser app with material design, downloading JSON data, and displaying results in a RecyclerView with search and detailed image views.

Develop an Android app that searches Flickr's public feed without authentication using tags, explores all and any tag modes, and retrieves JSON data, with browser testing tips.

Explore json data handling via url parameters, validate with json lint, and fix jsonp issues by using no json callback; apply lang parameters to view feeds in German and Chinese.

Create a Flickr Browser app in Android Studio, set up a basic activity, and use a Kotlin companion object to define a log tag for logcat debugging.

Download json data from Flickr using a Kotlin async task. Implement GetRawData to fetch on a background thread and manage download status with an enum and robust error handling.

learn to decouple the download class from parsing logic and implement a download completion callback to the calling activity, enabling json data handling in your Kotlin app.

Master kotlin callbacks for asynchronous data handling in android by implementing an onDownloadComplete interface and wiring getRawData to call back into MainActivity via setDownloadCompleteListener.

Parse downloaded json data in Kotlin with get flickr json data, create photo objects, and feed a RecyclerView via an adapter using a view holder.

Create the GetFlickerJsonData Kotlin class to parse Flickr json data asynchronously, implement OnDataAvailable and OnError callbacks, and extract photo fields from items, including replacing m.jpg with b.jpg.

Parse json data into photo objects, accumulate them in a photo list, and return them via onDataAvailable while logging progress and handling errors with onError and task cancellation.

Build dynamic Flickr API URLs in Kotlin by constructing a URI with tags, language, and match criteria, enabling a user search feature for photos.

Design the Flickr browser interface for Android using Kotlin, featuring a RecyclerView of JSON data, a photo details activity, and a search activity with toolbars.

Design recycler view items with a thumbnail image and title in a horizontal linear layout, using margins, padding, and weight to balance space and a placeholder drawable.

Explore adjust view bounds for image views to preserve aspect ratio, and examine how image view and layout_height choices, wrap_content or match_parent, affect the recycler view layout.

Create search and photo details activities using basic activity templates, configure the manifest for parent navigation, and switch the photo details layout to a scroll view for your app.

Implement nested layouts inside a scroll view using a card view and a vertical linear layout. Configure content padding, card corner radius, margins, and scrolling behavior for an Android UI.

Implement a custom Flickr photo recycler view adapter in Kotlin, wiring photo data to a RecyclerView with a ViewHolder, and loading thumbnails as you scroll.

Learn to load remote images in a RecyclerView with Picasso. Add the dependency, use the view context to load URLs, and apply placeholders, error images, and caching for better performance.

Connect the recycler view to display data by wiring the adapter in onCreate, configure a linear layout manager, and load images with Picasso that update from placeholders to thumbnails.

Develop a custom RecyclerItemClickListener in Kotlin to detect item taps using a SimpleOnItemTouchListener and a gesture detector, then wire it to the RecyclerView and main activity.

Explore how the gesture detector handles touch events in a RecyclerView, wiring onInterceptTouchEvent to onTouchEvent and triggering item click and long-click via onSingleTapUp and onLongPress.

Launch the photo details activity from a recycler view click using intents, share toolbar logic via a base activity, and pass the selected photo with a consistent transfer key.

Learn to pass serializable objects between activities using putExtra, implement java.io.Serializable in Kotlin, add a serialVersionUID, and compare with parcelable for Android data transfer.

Retrieve photo details from the intent and populate title, tags, and author. Load the image with Picasso using the full photo URL and a placeholder.

Explore parcelable and serializable in Android, see how Android Studio generates parcelable, and learn when to test both for performance to choose the right object passing in bundles.

Explore Material Design principles introduced with Android Lollipop, and see how color palettes, density independent pixels, drawers, and toolbars shape interactive Android UI across versions.

Explore material design color guidelines and hex codes to craft a cohesive Android app theme with primary and accent colors for toolbars and status bars.

Discover how to maintain backward compatibility in Android apps using the AppCompat library and Material Design on older versions, with min SDK guidance and steps for the Flickr Browser app.

Apply material design styling to the Flickr app by using Android themes like AppTheme and AppTheme.NoActionBar, and adjust colors in colors.xml and styles.xml.

Learn to override style properties in styles.xml and create version-specific styles (values-v23) to adapt colors, card backgrounds, and status bar across Android versions.

Learn how Android namespaces and prefixes govern styles and resources across API levels, using AppCompat, v23 styles, and android:color vs @color for attributes like colorBackgroundFloating and colorPrimary.

Explore material design styling by swapping color palettes and using descriptive color names in styles.xml, then apply cross-version consistency with v21 and v23 themes and navigation bar color.

Explore how adjustViewBounds makes images fit while preserving aspect ratio across API levels, test across emulators, and compare layout behavior of image in a CardView with scrollable content.

Replace hardcoded text with string resources to enable localization and reuse across layouts. Learn to add content descriptions for accessibility and reference strings from strings.xml to streamline Android development.

Learn to replace hardcoded text with string resources and placeholders in Android Kotlin apps. Use placeholders, getString, and numbering to format dynamic text and support multilingual word order.

Launch search functionality by wiring onOptionsItemSelected to start searchActivity, inflate the search menu, and configure a searchable.xml with a label and hint.

Configure searchable information by linking searchable.xml to the activity via manifest meta data and adding a search intent filter. Bind a search manager to the toolbar search view.

Learn to handle SearchView events with OnQueryTextListener and onQueryTextSubmit, using setOnQueryTextListener to capture queries and return them to MainActivity, finishing the search activity to filter Flickr photos.

Store search queries with shared preferences from search to main activity using a common key and putString/getString; finish on cancel and show empty results when none match.

Enhance user feedback in Android apps by showing a placeholder image and a 'no photos match your criteria' message when no photos match a search, using RecyclerView and string resources.

Learn how Android apps store data with SQLite and SQL, query relational data, and use cursors, content providers, and content resolvers, with a basic app example.

Explore how relational database systems power android apps using sqlite, learn core sql operations—select, insert, update, delete—and understand tables, rows, and fields for basic storage and retrieval.

Learn essential database terminology for Android development with Kotlin: understand tables, fields, and rows, and explore joins, normalization, and views in SQLite, plus comparing flat-file and relational databases.

Set up the Windows command line to access SQLite and adb by configuring the Android SDK platform-tools in your path, verify adb works, and prepare SQLite access for Android development.

Set up the Android SDK for command-line use on Mac, add the platform-tools to your path, and verify SQLite and ADB access from the terminal.

Configure ubuntu linux to access sqlite3 and adb by adding the Android SDK path to your profile, enabling command-line use of sqlite3 and adb.

Learn to use sqlite3 from the command line to create databases and tables, define columns, insert data, and query with select, using headers and semicolon rules.

Learn to modify data in SQLite using update and delete commands, with where clauses to target specific rows in Android, and back up or restore databases via the SQLite shell.

learn sqlite data querying with select statements, view-based reusable queries, and joins to link tables, while recognizing primary keys and not null constraints.

Learn to order data with order by, handle case with collate no case, group results by artist or album, and join songs, albums, and artists using inner joins.

Explore advanced data retrieval in SQLite by composing joins across songs, albums, and artists, using where and order by clauses, and sculpting multi-line queries ready for Android Studio integration.

Master SQLite wildcard searches using like and percent, explore views as virtual tables, create and manage views, and optimize queries with case handling and column naming.

Learn backing up and restoring sqlite databases in java, and practice sql queries with where clauses, aggregates, and views. Apply renaming, duplicates handling, and count functions to reinforce sqlite concepts.

Learn to integrate a basic SQLite database in an Android app with Kotlin by using openOrCreateDatabase, MODE_PRIVATE, and executing SQL statements to create tables, insert, delete, and query data.

Learn to create a SQLite table named contacts with id, name, phone, and email, then insert test data using execSQL and ContentValues in Kotlin, and log results with logcat.

Learn to retrieve data with a cursor in Android SQLite using Kotlin, rawQuery, moveToFirst, and moveToNext, then read columns and log results.

Explore the android file system to locate your app's sqlite database under /data/data, and inspect it via adb and sqlite3 on a rooted emulator.

Discover how content providers enable structured data access in Android using SQLite, lifecycle-aware patterns, and CursorLoader to manage a contacts database, adding, editing, deleting, and displaying records.

Configure Android emulators across API 21 and API 23+ to test a content provider, creating test contacts and handling Google API permissions in Marshmallow and later.

Explore accessing contacts via a content provider and displaying them in a ListView within an android kotlin app, including android studio project setup, user interface layout, and permissions.

Learn how to access Android contacts data in Kotlin using ContactsContract and ContentResolver, querying display_name_primary via a content resolver cursor and understanding projection, selection, and sort order.

Explore how the ContentResolver coordinates data access from ContentProviders to an app, using a URI-driven request and layered abstraction to fetch contacts efficiently.

Fetch contacts using the content resolver and content provider via a cursor, store them in a list, and display with array adapter in a list view, with read contacts permission.

Master runtime permission handling for Android 6.0+ by requesting dangerous permissions at runtime with manifest declarations and ContextCompat checks, focusing on read contacts.

Master runtime permission handling for Android API 23 and above by using checkSelfPermission, requestPermissions, and onRequestPermissionsResult for the READ_CONTACTS permission, including denial flows.

Test Android permission flows for reading contacts across API levels, from grant to denial, including don't ask again, and disable the floating action button when needed.

Learn to manage contacts permission for an Android app by enabling or disabling the floating action button and showing a Snackbar when permission is denied, using Material Design snackbars.

Discover how snackbars provide unobtrusive feedback as a Material Design alternative to toasts, with an indefinite length. Add actionable links to trigger permission requests and guide users to app settings.

Learn to handle denied permissions in Android by using snackbar prompts and ActivityCompat.ShouldShowRequestPermissionRationale to either re-request or open app settings with an Intent and Uri.fromParts('package', this.packageName, null).

Identify and fix Android state management issues by avoiding stored permission state; check permission status on demand, not in a field, to prevent stale data after settings changes.

Eliminate redundant state by removing the readGranted flag and relying on runtime permission checks for read contacts, using ContextCompat.checkSelfPermission to drive permission flow and testing.

Develop and run test scripts to cover Android permissions in app not installed and other scenarios, include API level 23, permission dialog, and revocation handling.