• Viacheslav Eremin | Android learning
    (NOTES) NOTES (2019)

    Android learning

    1. Android Boot Camp for Developers using Java, Comprehensive A Beginner's Guide to Creating Your First Android Apps.pdf (516 pages)

    • Voilà! Meet the Android
    • Simplify! The Android User Interface
    • Engage! Android User Input, Variables, and Operations
    • Explore! Icons and Decision-Making Controls
    • Investigate! Android Lists, Arrays, and Web Browsers
    • Jam! Implementing Audio in Android Apps
    • Reveal! Displaying Pictures in a Gallery
    • Design! Using a DatePicker on a Tablet
    • Customize! Navigating with Tabs on a Tablet App
    • Move! Creating Animation
    • Discover! Incorporating Google Maps
    • Finale! Publishing Your Android App

    2. Android Programming for Beginners.pdf (698 pages)

    • The First App
    • Java – First Contact
    • Exploring Android Studio
    • Designing Layouts
    • Real-World Layouts
    • The Life and Times of an Android App
    • Coding in Java Part 1 – Variables, Decisions, and Loops
    • Coding in Java Part 2 – Methods
    • Object-Oriented Programming
    • Everything's a Class
    • Widget Mania
    • Having a Dialogue with the User
    • Handling and Displaying Arrays of Data
    • Handling and Displaying Notes in Note To Self
    • Android Intent and Persistence
    • UI Animations
    • Sound FX and Supporting Different Versions
    • Design Patterns, Fragments, and the Real World
    • Using Multiple Fragments
    • Paging and Swiping
    • Navigation Drawer and Where It's Snap
    • Capturing Images
    • Using SQLite Databases in Our Apps
    • Adding a Database to Where It's Snap
    • Integrating Google Maps and GPS Locations
    • Upgrading SQLite – Adding Locations and Maps

    3. Beginning Android Application Development.pdf (450 pages)

    • Getting started with Android programming
    • Activities and intents
    • Getting to know the Android user interface
    • Designing your uSer interfAce using views
    • Displaying pictures and menus With views
    • Data persistence
    • Content providers
    • Messaging and networking
    • Location-based services
    • Developing Android services
    • Publishing Android applications
    • Using eclipse for Android development
    • Using the Android emulator

    4. Learn Kotlin for Android Development The Next Generation Language For Modern Android Apps Programming.pdf (517 pages)

    • Your First Kotlin Application: Hello Kotlin
    • Classes and Objects: Object Orientation Philosophy
    • Classes at Work: Properties and Functions
    • Classes and Objects: Extended Features
    • Expressions: Operations on Data
    • Comments in Kotlin Files
    • Structural Constructs
    • Exceptions: If Something Goes Wrong
    • Data Containers
    • True, False, and Undecided: Nullability
    • Handling Equality
    • Back to Math: Functional Programming
    • About Type Safety: Generics
    • Adding Hints: Annotations
    • Using the Java and Kotlin APIs
    • The Collections API
    • More APIs
    • Working in Parallel: Multithreading
    • Using External Libraries
    • XML and JSON

    5. Learning Android Application Testing by Paul Blundell - 2015.epub (330 pages)

    • Getting starting with testing
    • Understanding testing with Android SDK
    • Baking with testing recipes
    • Managing your Android testing environment
    • Discovering continuous integration
    • Practicing test-driven development
    • Behavior-driven development
    • Testing and profiling performance
    • Alternative testing tactics

    6. Mastering Android Studio 3.epub (228 pages)

    • Preface
    • Workspace structure
    • UI design
    • UI development
    • Device development
    • Assets and resources
    • Template and Plugins
    • Languages support
    • Testing and profiling
    • Packaging and distribution

    7. packt.android.programming.with.kotlin.for.beginners.2019.epub (648 pages)

    • Getting started with Android and Kotlin
    • Kotlin, XML, and the UI designer
    • Exploring Android studio and the project structure
    • Getting started with Layout and Material Design
    • Beautiful Layouts with Cardview and Scrollview
    • The Android Lifestyle
    • Kotlin Variables, Operators, and Expression
    • Kotlin Decisions and Loops
    • Kotlin Function
    • Object-oriented programming
    • Inheritance in Kotlin
    • Connecting our Kotlin to the UI and Nullability
    • Bringing Android Widgets to life
    • Android Dialog windowHandling data and generate random numbers
    • Adapters and Recyclers
    • Data persistence and sharing
    • Localization
    • Animation and interpolations
    • Drawing graphics
    • Threads and starting the Live drawing apps
    • Particle systems and handling Screen Touches
    • Android sound effects and the Spinner Widget
    • Design patterns, multiple layouts, and Fragments
    • Advanced UI with Paging and Swiping
    • Advanced UI with Navigation Drawer and Fragment
    • Android databases
    • A quick chat before you go
    • Other book you may enjoy

    8. Smyth N. Android Studio 3.6 Development Essentials - Java Edition.epub (768 pages)

    • 1. Introduction
    • 2. Setting up an Android Studio Development Environment
    • 3. Creating an Example Android App in Android Studio
    • 4. Creating an Android Virtual Device (AVD) in Android Studio
    • 5. Using and Configuring the Android Studio AVD Emulator
    • 6. A Tour of the Android Studio User Interface
    • 7. Testing Android Studio Apps on a Physical Android Device
    • 8. The Basics of the Android Studio Code Editor
    • 9. An Overview of the Android Architecture
    • 10. The Anatomy of an Android Application
    • 11. An Overview of Android View Binding
    • 12. Understanding Android Application and Activity Lifecycles
    • 13. Handling Android Activity State Changes
    • 14. Android Activity State Changes by Example
    • 15. Saving and Restoring the State of an Android Activity
    • 16. Understanding Android Views, View Groups and Layouts
    • 17. A Guide to the Android Studio Layout Editor Tool
    • 18. A Guide to the Android ConstraintLayout
    • 19. A Guide to using ConstraintLayout in Android Studio
    • 20. Working with ConstraintLayout Chains and Ratios in Android Studio
    • 21. An Android Studio Layout Editor ConstraintLayout Tutorial
    • 22. Manual XML Layout Design in Android Studio
    • 23. Managing Constraints using Constraint Sets
    • 24. An Android ConstraintSet Tutorial
    • 25. A Guide to using Apply Changes in Android Studio
    • 26. An Overview and Example of Android Event Handling
    • 27. Android Touch and Multi-touch Event Handling
    • 28. Detecting Common Gestures using the Android Gesture Detector Class
    • 29. Implementing Custom Gesture and Pinch Recognition on Android
    • 30. An Introduction to Android Fragments
    • 31. Using Fragments in Android Studio - An Example
    • 32. Modern Android App Architecture with Jetpack
    • 33. An Android Jetpack ViewModel Tutorial
    • 34. An Android Jetpack LiveData Tutorial
    • 35. An Overview of Android Jetpack Data Binding
    • 36. An Android Jetpack Data Binding Tutorial
    • 37. An Android ViewModel Saved State Tutorial
    • 38. Working with Android Lifecycle-Aware Components
    • 39. An Android Jetpack Lifecycle Awareness Tutorial
    • 40. An Overview of the Navigation Architecture Component
    • 41. An Android Jetpack Navigation Component Tutorial
    • 42. Creating and Managing Overflow Menus on Android
    • 43. Animating User Interfaces with the Android Transitions Framework
    • 44. An Android Transition Tutorial using beginDelayedTransition
    • 45. Implementing Android Scene Transitions - A Tutorial
    • 46. Working with the Floating Action Button and Snackbar
    • 47. Creating a Tabbed Interface using the TabLayout Component
    • 48. Working with the RecyclerView and Card View Widgets
    • 49. An Android RecyclerView and Card View Tutorial
    • 50. A Layout Editor Sample Data Tutorial
    • 51. Working with the AppBar and Collapsing Toolbar Layouts
    • 52. An Android Studio Master/Detail Flow Tutorial
    • 53. An Overview of Android Intents
    • 54. Android Explicit Intents - A Worked Example
    • 55. Android Implicit Intents - A Worked Example
    • 56. Android Broadcast Intents and Broadcast Receivers
    • 57. A Basic Overview of Threads and AsyncTasks
    • 58. An Overview of Android Started and Bound Services
    • 59. Implementing an Android Started Service- A Worked Example
    • 60. Android Local Bound Services - A Worked Example
    • 61. Android Remote Bound Services - A Worked Example
    • 62. An Android Notifications Tutorial
    • 63. An Android Direct Reply Notification Tutorial
    • 64. Foldable Devices and Multi-Window Support
    • 65. An Overview of Android SQLite Databases
    • 66. The Android Room Persistence Library
    • 67. An Android TableLayout and TableRow Tutorial
    • 68. An Android Room Database and Repository Tutorial
    • 69. Accessing Cloud Storage using the Android Storage Access Framework
    • 70. An Android Storage Access Framework Example
    • 71. Implementing Video Playback on Android using the VideoView and MediaCo
    • 72. Android Picture-in-Picture Mode
    • 73. An Android Picture-in-Picture Tutorial
    • 74. Making Runtime Permission Requests in Android
    • 75. Android Audio Recording and Playback using MediaPlayer and MediaRecord
    • 76. Working with the Google Maps Android API in Android Studio
    • 77. Printing with the Android Printing Framework
    • 78. An Android HTML and Web Content Printing Example
    • 79. A Guide to Android Custom Document Printing
    • 80. An Introduction to Android App Links
    • 81. An Android Studio App Links Tutorial
    • 82. A Guide to the Android Studio Profiler
    • 83. An Android Biometric Authentication Tutorial
    • 84. Creating, Testing and Uploading an Android App Bundle
    • 85. An Overview of Android Dynamic Feature Modules
    • 86. An Android Studio Dynamic Feature Tutorial
    • 87. An Overview of Gradle in Android Studio

    9. Smyth N. Android Studio 4.2 Development Essentials - Kotlin Edition 2021 (1025 pages)

    1. Introduction
     1.1 Downloading the Code Samples 
     1.2 Feedback 
     1.3 Errata 
    2. Setting up an Android Studio Development Environment
     2.1 System Requirements 
     2.2 Downloading the Android Studio Package 
     2.3 Installing Android Studio 
     2.3.1 Installation on Windows 
     2.3.2 Installation on macOS 
     2.3.3 Installation on Linux 
     2.4 e Android Studio Setup Wizard 
     2.5 Installing Additional Android SDK Packages 
     2.6 Making the Android SDK Tools Command-line Accessible 
     2.6.1 Windows 7 
     2.6.2 Windows 8.1 
     2.6.3 Windows 10 
     2.6.4 Linux 
     2.6.5 macOS 
     2.7 Android Studio Memory Management 
     2.8 Updating Android Studio and the SDK 
     2.9 Summary 
    3. Creating an Example Android App in Android Studio
     3.1 About the Project 
     3.2 Creating a New Android Project 
     3.3 Creating an Activity 
     3.4 Dening the Project and SDK Settings 
     3.5 Modifying the Example Application 
     3.6 Modifying the User Interface 
     3.7 Reviewing the Layout and Resource Files 
     3.8 Adding the Kotlin Extensions Plugin 
     3.9 Adding Interaction 
     3.10 Summary 
    4. Creating an Android Virtual Device (AVD) in Android Studio
     4.1 About Android Virtual Devices 
     4.2 Creating a New AVD 
     4.3 Starting the Emulator 
     4.4 Running the Application in the AVD 
     4.5 Running on Multiple Devices 
     4.6 Stopping a Running Application 
     4.7 Supporting Dark eme 
     4.8 Running the Emulator in a Tool Window 
     4.9 AVD Command-line Creation 
     4.10 Android Virtual Device Conguration Files 
     4.11 Moving and Renaming an Android Virtual Device 
     4.12 Summary 
    5. Using and Configuring the Android Studio AVD Emulator
     5.1 e Emulator Environment 
     5.2 e Emulator Toolbar Options 
     5.3 Working in Zoom Mode 
     5.4 Resizing the Emulator Window 
     5.5 Extended Control Options 
     5.5.1 Location 
     5.5.2 Displays 
     5.5.3 Cellular 
     5.5.4 Battery 
     5.5.5 Camera 
     5.5.6 Phone 
     5.5.7 Directional Pad 
     5.5.8 Microphone 
     5.5.9 Fingerprint 
     5.5.10 Virtual Sensors 
     5.5.11 Snapshots 
     5.5.12 Record and Playback 
     5.5.13 Google Play 
     5.5.14 Settings 
     5.5.15 Help 
     5.6 Working with Snapshots 
     5.7 Conguring Fingerprint Emulation 
     5.8 e Emulator in Tool Window Mode 
     5.9 Summary 
    6. A Tour of the Android Studio User Interface
     6.1 e Welcome Screen 
     6.2 e Main Window 
     6.3 e Tool Windows 
     6.4 Android Studio Keyboard Shortcuts 
     6.5 Switcher and Recent Files Navigation 
     6.6 Changing the Android Studio eme 
     6.7 Summary 
    7. Testing Android Studio Apps on a Physical Android Device
     7.1 An Overview of the Android Debug Bridge (ADB) 
     7.2 Enabling ADB on Android based Devices 
     7.2.1 macOS ADB Conguration 
     7.2.2 Windows ADB Conguration 
     7.2.3 Linux adb Conguration 
     7.3 Testing the adb Connection 
     7.4 Summary 
    8. Basics of the Android Studio Code Editor
     8.1 e Android Studio Editor 
     8.2 Splitting the Editor Window 
     8.3 Code Completion 
     8.4 Statement Completion 
     8.5 Parameter Information 
     8.6 Parameter Name Hints 
     8.7 Code Generation 
     8.8 Code Folding 
     8.9 Quick Documentation Lookup 
     8.10 Code Reformatting 
     8.11 Finding Sample Code 
     8.12 Live Templates 
     8.13 Summary 
    9. An Overview of the Android Architecture
     9.1 e Android Soware Stack 
     9.2 e Linux Kernel 
     9.3 Android Runtime – ART 
     9.4 Android Libraries 
     9.4.1 C/C++ Libraries 
     9.5 Application Framework 
     9.6 Applications 
     9.7 Summary 
    10. Anatomy of an Android Application
     10.1 Android Activities 
     10.2 Android Fragments 
     10.3 Android Intents 
     10.4 Broadcast Intents 
     10.5 Broadcast Receivers 
     10.6 Android Services 
     10.7 Content Providers 
     10.8 e Application Manifest 
     10.9 Application Resources 
     10.10 Application Context 
     10.11 Summary 
    11. An Introduction to Kotlin
     11.1 What is Kotlin? 
     11.2 Kotlin and Java 
     11.3 Converting from Java to Kotlin 
     11.4 Kotlin and Android Studio 
     11.5 Experimenting with Kotlin 
     11.6 Semi-colons in Kotlin 
     11.7 Summary 
    12. Kotlin Data Types,Variables and Nullability
     12.1 Kotlin Data Types 
     12.1.1 Integer Data Types 
     12.1.2 Floating Point Data Types 
     12.1.3 Boolean Data Type 
     12.1.4 Character Data Type 
     12.1.5 String Data Type 
     12.1.6 Escape Sequences 
     12.2 Mutable Variables 
     12.3 Immutable Variables 
     12.4 Declaring Mutable and Immutable Variables 
     12.5 Data Types are Objects 
     12.6 Type Annotations and Type Inference 
     12.7 Nullable Type 
     12.8 e Safe Call Operator 
     12.9 Not-Null Assertion 
     12.10 Nullable Types and the let Function 
     12.11 Late Initialization (lateinit) 
     12.12 e Elvis Operator 
     12.13 Type Casting and Type Checking 
     12.14 Summary 
    13. Kotlin Operators and Expressions
     13.1 Expression Syntax in Kotlin 
     13.2 e Basic Assignment Operator 
     13.3 Kotlin Arithmetic Operators 
     13.4 Augmented Assignment Operators 
     13.5 Increment and Decrement Operators 
     13.6 Equality Operators 
     13.7 Boolean Logical Operators 
     13.8 Range Operator 
     13.9 Bitwise Operators 
     13.9.1 Bitwise Inversion 
     13.9.2 Bitwise AND 
     13.9.3 Bitwise OR 
     13.9.4 Bitwise XOR 
     13.9.5 Bitwise Le Shi 
     13.9.6 Bitwise Right Shi 
     13.10 Summary 
    14. Kotlin Flow Control
     14.1 Looping Flow Control 
     14.1.1 e Kotlin for-in Statement 
     14.1.2 e while Loop 
     14.1.3 e do ... while loop 
     14.1.4 Breaking from Loops 
     14.1.5 e continue Statement 
     14.1.6 Break and Continue Labels 
     14.2 Conditional Flow Control 
     14.2.1 Using the if Expressions 
     14.2.2 Using if ... else … Expressions 
     14.2.3 Using if ... else if ... Expressions 
     14.2.4 Using the when Statement 
     14.3 Summary 
    15. An Overview of Kotlin Functions and Lambdas
     15.1 What is a Function? 
     15.2 How to Declare a Kotlin Function 
     15.3 Calling a Kotlin Function 
     15.4 Single Expression Functions 
     15.5 Local Functions 
     15.6 Handling Return Values 
     15.7 Declaring Default Function Parameters 
     15.8 Variable Number of Function Parameters 
     15.9 Lambda Expressions 
     15.10 Higher-order Functions 
     15.11 Summary 
    16. e Basics of Object Oriented Programming in Kotlin
     16.1 What is an Object? 
     16.2 What is a Class? 
     16.3 Declaring a Kotlin Class 
     16.4 Adding Properties to a Class 
     16.5 Dening Methods 
     16.6 Declaring and Initializing a Class Instance 
     16.7 Primary and Secondary Constructors 
     16.8 Initializer Blocks 
     16.9 Calling Methods and Accessing Properties 
     16.10 Custom Accessors 
     16.11 Nested and Inner Classes 
     16.12 Companion Objects 
     16.13 Summary 
    17. An Introduction to Kotlin Inheritance and Subclassing
     17.1 Inheritance, Classes and Subclasses 
     17.2 Subclassing Syntax 
     17.3 A Kotlin Inheritance Example 
     17.4 Extending the Functionality of a Subclass 
     17.5 Overriding Inherited Methods 
     17.6 Adding a Custom Secondary Constructor 
     17.7 Using the SavingsAccount Class 
     17.8 Summary 
    18. An Overview of Android View Binding
     18.1 Find View by Id and Synthetic Properties 
     18.2 View Binding 
     18.3 Converting the AndroidSample project 
     18.4 Enabling View Binding 
     18.5 Using View Binding 
     18.6 Choosing an Option 
     18.7 View Binding in the Book Examples 
     18.8 Migrating a Project to View Binding 
     18.9 Summary 
    19. Understanding Android Application and Activity Lifecycles
     19.1 Android Applications and Resource Management 
     19.2 Android Process States 
     19.2.1 Foreground Process 
     19.2.2 Visible Process 
     19.2.3 Service Process 
     19.2.4 Background Process 
     19.2.5 Empty Process 
     19.3 Inter-Process Dependencies 
     19.4 e Activity Lifecycle 
     19.5 e Activity Stack 
     19.6 Activity States 
     19.7 Conguration Changes 
     19.8 Handling State Change 
     19.9 Summary 
    20. Handling Android Activity State Changes
     20.1 New vs. Old Lifecycle Techniques 
     20.2 e Activity and Fragment Classes 
     20.3 Dynamic State vs. Persistent State 
     20.4 e Android Lifecycle Methods 
     20.5 Lifetimes 
     20.6 Foldable Devices and Multi-Resume 
     20.7 Disabling Conguration Change Restarts 
     20.8 Lifecycle Method Limitations 
     20.9 Summary 
    21. Android Activity State Changes by Example
     21.1 Creating the State Change Example Project 
     21.2 Designing the User Interface 
     21.3 Overriding the Activity Lifecycle Methods 
     21.4 Filtering the Logcat Panel 
     21.5 Running the Application 
     21.6 Experimenting with the Activity 
     21.7 Summary 
    22. Saving and Restoring the State of an Android Activity
     22.1 Saving Dynamic State 
     22.2 Default Saving of User Interface State 
     22.3 e Bundle Class 
     22.4 Saving the State 
     22.5 Restoring the State 
     22.6 Testing the Application 
     22.7 Summary 
    23. Understanding Android Views, View Groups and Layouts
     23.1 Designing for Dierent Android Devices 
     23.2 Views and View Groups 
     23.3 Android Layout Managers 
     23.4 e View Hierarchy 
     23.5 Creating User Interfaces 
     23.6 Summary 
    24. A Guide to the Android Studio Layout Editor Tool
     24.1 Basic vs. Empty Activity Templates 
     24.2 e Android Studio Layout Editor 
     24.3 Design Mode 
     24.4 e Palette 
     24.5 Design Mode and Layout Views 
     24.6 Night Mode 
     24.7 Code Mode 
     24.8 Split Mode 
     24.9 Setting Attributes 
     24.10 Transforms 
     24.11 Tools Visibility Toggles 
     24.12 Converting Views 
     24.13 Displaying Sample Data 
     24.14 Creating a Custom Device Denition 
     24.15 Changing the Current Device 
     24.16 Layout Validation (Multi Preview) 
     24.17 Summary 
    25. A Guide to the Android ConstraintLayout
     25.1 How ConstraintLayout Works 
     25.1.1 Constraints 
     25.1.2 Margins 
     25.1.3 Opposing Constraints 
     25.1.4 Constraint Bias 
     25.1.5 Chains 
     25.1.6 Chain Styles 
     25.2 Baseline Alignment 
     25.3 Conguring Widget Dimensions 
     25.4 Guideline Helper 
     25.5 Group Helper 
     25.6 Barrier Helper 
     25.7 Flow Helper 
     25.8 Ratios 
     25.9 ConstraintLayout Advantages 
     25.10 ConstraintLayout Availability 
     25.11 Summary 
    26. A Guide to Using ConstraintLayout in Android Studio
     26.1 Design and Layout Views 
     26.2 Autoconnect Mode 
     26.3 Inference Mode 
     26.4 Manipulating Constraints Manually 
     26.5 Adding Constraints in the Inspector 
     26.6 Viewing Constraints in the Attributes Window 
     26.7 Deleting Constraints 
     26.8 Adjusting Constraint Bias 
     26.9 Understanding ConstraintLayout Margins 
     26.10 e Importance of Opposing Constraints and Bias 
     26.11 Conguring Widget Dimensions 
     26.12 Design Time Tools Positioning 
     26.13 Adding Guidelines 
     26.14 Adding Barriers 
     26.15 Adding a Group 
     26.16 Working with the Flow Helper 
     26.17 Widget Group Alignment and Distribution 
     26.18 Converting other Layouts to ConstraintLayout 
     26.19 Summary 
    27. Working with ConstraintLayout Chains and Ratios in Android Studio
     27.1 Creating a Chain 
     27.2 Changing the Chain Style 
     27.3 Spread Inside Chain Style 
     27.4 Packed Chain Style 
     27.5 Packed Chain Style with Bias 
     27.6 Weighted Chain 
     27.7 Working with Ratios 
     27.8 Summary 
    28. An Android Studio Layout Editor ConstraintLayout Tutorial
     28.1 An Android Studio Layout Editor Tool Example 
     28.2 Creating a New Activity 
     28.3 Preparing the Layout Editor Environment 
     28.4 Adding the Widgets to the User Interface 
     28.5 Adding the Constraints 
     28.6 Testing the Layout 
     28.7 Using the Layout Inspector 
     28.8 Summary 
    29. Manual XML Layout Design in Android Studio
     29.1 Manually Creating an XML Layout 
     29.2 Manual XML vs. Visual Layout Design 
     29.3 Summary 
    30. Managing Constraints using Constraint Sets
     30.1 Kotlin Code vs. XML Layout Files 
     30.2 Creating Views 
     30.3 View Attributes 
     30.4 Constraint Sets 
     30.4.1 Establishing Connections 
     30.4.2 Applying Constraints to a Layout 
     30.4.3 Parent Constraint Connections 
     30.4.4 Sizing Constraints 
     30.4.5 Constraint Bias 
     30.4.6 Alignment Constraints 
     30.4.7 Copying and Applying Constraint Sets 
     30.4.8 ConstraintLayout Chains 
     30.4.9 Guidelines 
     30.4.10 Removing Constraints 
     30.4.11 Scaling 
     30.4.12 Rotation 
     30.5 Summary 
    31. An Android ConstraintSet Tutorial
     31.1 Creating the Example Project in Android Studio 
     31.2 Adding Views to an Activity 
     31.3 Setting View Attributes 
     31.4 Creating View IDs 
     31.5 Conguring the Constraint Set 
     31.6 Adding the EditText View 
     31.7 Converting Density Independent Pixels (dp) to Pixels (px) 
     31.8 Summary 
    32. A Guide to using Apply Changes in Android Studio
     32.1 Introducing Apply Changes 
     32.2 Understanding Apply Changes Options 
     32.3 Using Apply Changes 
     32.4 Conguring Apply Changes Fallback Settings 
     32.5 An Apply Changes Tutorial 
     32.6 Using Apply Code Changes 
     32.7 Using Apply Changes and Restart Activity 
     32.8 Using Run App 
     32.9 Summary 
    33. An Overview and Example of Android Event Handling
     33.1 Understanding Android Events 
     33.2 Using the android:onClick Resource 
     33.3 Event Listeners and Callback Methods 
     33.4 An Event Handling Example 
     33.5 Designing the User Interface 
     33.6 e Event Listener and Callback Method 
     33.7 Consuming Events 
     33.8 Summary 
    34. Android Touch and Multi-touch Event Handling
     34.1 Intercepting Touch Events 
     34.2 e MotionEvent Object 
     34.3 Understanding Touch Actions 
     34.4 Handling Multiple Touches 
     34.5 An Example Multi-Touch Application 
     34.6 Designing the Activity User Interface 
     34.7 Implementing the Touch Event Listener 
     34.8 Running the Example Application 
     34.9 Summary 
    35. Detecting Common Gestures Using the Android Gesture Detector Class
     35.1 Implementing Common Gesture Detection 
     35.2 Creating an Example Gesture Detection Project 
     35.3 Implementing the Listener Class 
     35.4 Creating the GestureDetectorCompat Instance 
     35.5 Implementing the onTouchEvent() Method 
     35.6 Testing the Application 
     35.7 Summary 
    36. Implementing Custom Gesture and Pinch Recognition on Android
     36.1 e Android Gesture Builder Application 
     36.2 e GestureOverlayView Class 
     36.3 Detecting Gestures 
     36.4 Identifying Specic Gestures 
     36.5 Installing and Running the Gesture Builder Application 
     36.6 Creating a Gestures File 
     36.7 Creating the Example Project 
     36.8 Extracting the Gestures File from the SD Card 
     36.9 Adding the Gestures File to the Project 
     36.10 Designing the User Interface 
     36.11 Loading the Gestures File 
     36.12 Registering the Event Listener 
     36.13 Implementing the onGesturePerformed Method 
     36.14 Testing the Application 
     36.15 Conguring the GestureOverlayView 
     36.16 Intercepting Gestures 
     36.17 Detecting Pinch Gestures 
     36.18 A Pinch Gesture Example Project 
     36.19 Summary 
    37. An Introduction to Android Fragments
     37.1 What is a Fragment? 
     37.2 Creating a Fragment 
     37.3 Adding a Fragment to an Activity using the Layout XML File 
     37.4 Adding and Managing Fragments in Code 
     37.5 Handling Fragment Events 
     37.6 Implementing Fragment Communication 
     37.7 Summary 
    38. Using Fragments in Android Studio - An Example
     38.1 About the Example Fragment Application 
     38.2 Creating the Example Project 
     38.3 Creating the First Fragment Layout 
     38.4 Migrating a Fragment to View Binding 
     38.5 Adding the Second Fragment 
     38.6 Adding the Fragments to the Activity 
     38.7 Making the Toolbar Fragment Talk to the Activity 
     38.8 Making the Activity Talk to the Text Fragment 
     38.9 Testing the Application 
     38.10 Summary 
    39. Modern Android App Architecture with Jetpack
     39.1 What is Android Jetpack? 
     39.2 e “Old” Architecture 
     39.3 Modern Android Architecture 
     39.4 e ViewModel Component 
     39.5 e LiveData Component 
     39.6 ViewModel Saved State 
     39.7 LiveData and Data Binding 
     39.8 Android Lifecycles 
     39.9 Repository Modules 
     39.10 Summary 
    40. An Android Jetpack ViewModel Tutorial
     40.1 About the Project 
     40.2 Creating the ViewModel Example Project 
     40.3 Reviewing the Project 
     40.3.1 e Main Activity 
     40.3.2 e Content Fragment 
     40.3.3 e ViewModel 
     40.4 Designing the Fragment Layout 
     40.5 Implementing the View Model 
     40.6 Associating the Fragment with the View Model 
     40.7 Modifying the Fragment 
     40.8 Accessing the ViewModel Data 
     40.9 Testing the Project 
     40.10 Summary 
    41. An Android Jetpack LiveData Tutorial
     41.1 LiveData - A Recap 
     41.2 Adding LiveData to the ViewModel 
     41.3 Implementing the Observer 
     41.4 Summary 
    42. An Overview of Android Jetpack Data Binding
     42.1 An Overview of Data Binding 
     42.2 e Key Components of Data Binding 
     42.2.1 e Project Build Conguration 
     42.2.2 e Data Binding Layout File 
     42.2.3 e Layout File Data Element 
     42.2.4 e Binding Classes 
     42.2.5 Data Binding Variable Conguration 
     42.2.6 Binding Expressions (One-Way) 
     42.2.7 Binding Expressions (Two-Way) 
     42.2.8 Event and Listener Bindings 
     42.3 Summary 
    43. An Android Jetpack Data Binding Tutorial
     43.1 Removing the Redundant Code 
     43.2 Enabling Data Binding 
     43.3 Adding the Layout Element 
     43.4 Adding the Data Element to Layout File 
     43.5 Working with the Binding Class 
     43.6 Assigning the ViewModel Instance to the Data Binding Variable 
     43.7 Adding Binding Expressions 
     43.8 Adding the Conversion Method 
     43.9 Adding a Listener Binding 
     43.10 Testing the App 
     43.11 Summary 
    44. An Android ViewModel Saved State Tutorial
     44.1 Understanding ViewModel State Saving 
     44.2 Implementing ViewModel State Saving 
     44.3 Saving and Restoring State 
     44.4 Adding Saved State Support to the ViewModelDemo Project 
     44.5 Summary 
    45. Working with Android Lifecycle-Aware Components
     45.1 Lifecycle Awareness 
     45.2 Lifecycle Owners 
     45.3 Lifecycle Observers 
     45.4 Lifecycle States and Events 
     45.5 Summary 
    46. An Android Jetpack Lifecycle Awareness Tutorial
     46.1 Creating the Example Lifecycle Project 
     46.2 Creating a Lifecycle Observer 
     46.3 Adding the Observer 
     46.4 Testing the Observer 
     46.5 Creating a Lifecycle Owner 
     46.6 Testing the Custom Lifecycle Owner 
     46.7 Summary 
    47. An Overview of the Navigation Architecture Component
     47.1 Understanding Navigation 
     47.2 Declaring a Navigation Host 
     47.3 e Navigation Graph 
     47.4 Accessing the Navigation Controller 
     47.5 Triggering a Navigation Action 
     47.6 Passing Arguments 
     47.7 Summary 
    48. An Android Jetpack Navigation Component Tutorial
     48.1 Creating the NavigationDemo Project 
     48.2 Adding Navigation to the Build Conguration 
     48.3 Creating the Navigation Graph Resource File 
     48.4 Declaring a Navigation Host 
     48.5 Adding Navigation Destinations 
     48.6 Designing the Destination Fragment Layouts 
     48.7 Adding an Action to the Navigation Graph 
     48.8 Implement the OnFragmentInteractionListener 
     48.9 Adding View Binding Support to the Destination Fragments 
     48.10 Triggering the Action 
     48.11 Passing Data Using Safeargs 
     48.12 Summary 
    49. An Introduction to MotionLayout
     49.1 An Overview of MotionLayout 
     49.2 MotionLayout 
     49.3 MotionScene 
     49.4 Conguring ConstraintSets 
     49.5 Custom Attributes 
     49.6 Triggering an Animation 
     49.7 Arc Motion 
     49.8 Keyframes 
     49.8.1 Attribute Keyframes 
     49.8.2 Position Keyframes 
     49.9 Time Linearity 
     49.10 KeyTrigger 
     49.11 Cycle and Time Cycle Keyframes 
     49.12 Starting an Animation from Code 
     49.13 Summary 
    50. An Android MotionLayout Editor Tutorial
     50.1 Creating the MotionLayoutDemo Project 
     50.2 ConstraintLayout to MotionLayout Conversion 
     50.3 Conguring Start and End Constraints 
     50.4 Previewing the MotionLayout Animation 
     50.5 Adding an OnClick Gesture 
     50.6 Adding an Attribute Keyframe to the Transition 
     50.7 Adding a CustomAttribute to a Transition 
     50.8 Adding Position Keyframes 
     50.9 Summary 
    51. A MotionLayout KeyCycle Tutorial
     51.1 An Overview of Cycle Keyframes 
     51.2 Using the Cycle Editor 
     51.3 Creating the KeyCycleDemo Project 
     51.4 Conguring the Start and End Constraints 
     51.5 Creating the Cycles 
     51.6 Previewing the Animation 
     51.7 Adding the KeyFrameSet to the MotionScene 
     51.8 Summary 
    52. Working with the Floating Action Button and Snackbar
     52.1 e Material Design 
     52.2 e Design Library 
     52.3 e Floating Action Button (FAB) 
     52.4 e Snackbar 
     52.5 Creating the Example Project 
     52.6 Reviewing the Project 
     52.7 Removing Navigation Features 
     52.8 Changing the Floating Action Button 
     52.9 Adding an Action to the Snackbar 
     52.10 Summary 
    53. Creating a Tabbed Interface using the TabLayout Component
     53.1 An Introduction to the ViewPager 
     53.2 An Overview of the TabLayout Component 
     53.3 Creating the TabLayoutDemo Project 
     53.4 Creating the First Fragment 
     53.5 Duplicating the Fragments 
     53.6 Adding the TabLayout and ViewPager 
     53.7 Creating the Pager Adapter 
     53.8 Performing the Initialization Tasks 
     53.9 Testing the Application 
     53.10 Customizing the TabLayout 
     53.11 Displaying Icon Tab Items 
     53.12 Summary 
    54. Working with the RecyclerView and CardView Widgets
     54.1 An Overview of the RecyclerView 
     54.2 An Overview of the CardView 
     54.3 Summary 
    55. An Android RecyclerView and CardView Tutorial
     55.1 Creating the CardDemo Project 
     55.2 Modifying the Basic Activity Project 
     55.3 Designing the CardView Layout 
     55.4 Adding the RecyclerView 
     55.5 Adding the Image Files 
     55.6 Creating the RecyclerView Adapter 
     55.7 Initializing the RecyclerView Component 
     55.8 Testing the Application 
     55.9 Responding to Card Selections 
     55.10 Summary 
    56. A Layout Editor Sample Data Tutorial
     56.1 Adding Sample Data to a Project 
     56.2 Using Custom Sample Data 
     56.3 Summary 
    57. Working with the AppBar and Collapsing Toolbar Layouts
     57.1 e Anatomy of an AppBar 
     57.2 e Example Project 
     57.3 Coordinating the RecyclerView and Toolbar 
     57.4 Introducing the Collapsing Toolbar Layout 
     57.5 Changing the Title and Scrim Color 
     57.6 Summary 
    58. An Android Studio Primary/Detail Flow Tutorial
     58.1 e Primary/Detail Flow 
     58.2 Creating a Primary/Detail Flow Activity 
     58.3 Modifying the Primary/Detail Flow Template 
     58.4 Changing the Content Model 
     58.5 Changing the Detail Pane 
     58.6 Modifying the WebsiteDetailFragment Class 
     58.7 Modifying the WebsiteListFragment Class 
     58.8 Adding Manifest Permissions 
     58.9 Running the Application 
     58.10 Summary 
    59. An Overview of Android Intents
     59.1 An Overview of Intents 
     59.2 Explicit Intents 
     59.3 Returning Data from an Activity 
     59.4 Implicit Intents 
     59.5 Using Intent Filters 
     59.6 Checking Intent Availability 
     59.7 Summary 
    60. Android Explicit Intents – A Worked Example
     60.1 Creating the Explicit Intent Example Application 
     60.2 Designing the User Interface Layout for MainActivity 
     60.3 Creating the Second Activity Class 
     60.4 Designing the User Interface Layout for SecondActivity 
     60.5 Reviewing the Application Manifest File 
     60.6 Creating the Intent 
     60.7 Extracting Intent Data 
     60.8 Launching SecondActivity as a Sub-Activity 
     60.9 Returning Data from a Sub-Activity 
     60.10 Testing the Application 
     60.11 Summary 
    61. Android Implicit Intents – A Worked Example
     61.1 Creating the Android Studio Implicit Intent Example Project 
     61.2 Designing the User Interface 
     61.3 Creating the Implicit Intent 
     61.4 Adding a Second Matching Activity 
     61.5 Adding the Web View to the UI 
     61.6 Obtaining the Intent URL 
     61.7 Modifying the MyWebView Project Manifest File 
     61.8 Installing the MyWebView Package on a Device 
     61.9 Testing the Application 
     61.10 Summary 
    62. Android Broadcast Intents and Broadcast Receivers
     62.1 An Overview of Broadcast Intents 
     62.2 An Overview of Broadcast Receivers 
     62.3 Obtaining Results from a Broadcast 
     62.4 Sticky Broadcast Intents 
     62.5 e Broadcast Intent Example 
     62.6 Creating the Example Application 
     62.7 Creating and Sending the Broadcast Intent 
     62.8 Creating the Broadcast Receiver 
     62.9 Registering the Broadcast Receiver 
     62.10 Testing the Broadcast Example 
     62.11 Listening for System Broadcasts 
     62.12 Summary 
    63. An Introduction to Kotlin Coroutines
     63.1 What are Coroutines? 
     63.2 reads vs Coroutines 
     63.3 Coroutine Scope 
     63.4 Suspend Functions 
     63.5 Coroutine Dispatchers 
     63.6 Coroutine Builders 
     63.7 Jobs 
     63.8 Coroutines – Suspending and Resuming 
     63.9 Returning Results from a Coroutine 
     63.10 Using withContext 
     63.11 Coroutine Channel Communication 
     63.12 Summary 
    64. An Android Kotlin Coroutines Tutorial
     64.1 Creating the Coroutine Example Application 
     64.2 Adding Coroutine Support to the Project 
     64.3 Designing the User Interface 
     64.4 Implementing the SeekBar 
     64.5 Adding the Suspend Function 
     64.6 Implementing the launchCoroutines Method 
     64.7 Testing the App 
     64.8 Summary 
    65. An Overview of Android Services
     65.1 Started Services 
     65.2 Intent Service 
     65.3 Bound Service 
     65.4 e Anatomy of a Service 
     65.5 Controlling Destroyed Service Restart Options 
     65.6 Declaring a Service in the Manifest File 
     65.7 Starting a Service Running on System Startup 
     65.8 Summary 
    66. Implementing an Android Started Service – A Worked Example
     66.1 Creating the Example Project 
     66.2 Designing the User Interface 
     66.3 Creating the Service Class 
     66.4 Adding the Service to the Manifest File 
     66.5 Starting the Service 
     66.6 Testing the IntentService Example 
     66.7 Using the Service Class 
     66.8 Creating the New Service 
     66.9 Launching the Service 
     66.10 Running the Application 
     66.11 Using a Coroutine for the Service Task 
     66.12 Summary 
    67. Android Local Bound Services – A Worked Example
     67.1 Understanding Bound Services 
     67.2 Bound Service Interaction Options 
     67.3 A Local Bound Service Example 
     67.4 Adding a Bound Service to the Project 
     67.5 Implementing the Binder 
     67.6 Binding the Client to the Service 
     67.7 Completing the Example 
     67.8 Testing the Application 
     67.9 Summary 
    68. Android Remote Bound Services – A Worked Example
     68.1 Client to Remote Service Communication 
     68.2 Creating the Example Application 
     68.3 Designing the User Interface 
     68.4 Implementing the Remote Bound Service 
     68.5 Conguring a Remote Service in the Manifest File 
     68.6 Launching and Binding to the Remote Service 
     68.7 Sending a Message to the Remote Service 
     68.8 Summary 
    69. An Android Notications Tutorial
     69.1 An Overview of Notications 
     69.2 Creating the NotifyDemo Project 
     69.3 Designing the User Interface 
     69.4 Creating the Second Activity 
     69.5 Creating a Notication Channel 
     69.6 Creating and Issuing a Notication 
     69.7 Launching an Activity from a Notication 
     69.8 Adding Actions to a Notication 
     69.9 Bundled Notications 
     69.10 Summary 
    70. An Android Direct Reply Notication Tutorial
     70.1 Creating the DirectReply Project 
     70.2 Designing the User Interface 
     70.3 Creating the Notication Channel 
     70.4 Building the RemoteInput Object 
     70.5 Creating the PendingIntent 
     70.6 Creating the Reply Action 
     70.7 Receiving Direct Reply Input 
     70.8 Updating the Notication 
     70.9 Summary 
    71. Foldable Devices and Multi-Window Support
     71.1 Foldables and Multi-Window Support 
     71.2 Using a Foldable Emulator 
     71.3 Entering Multi-Window Mode 
     71.4 Enabling and using Freeform Support 
     71.5 Checking for Freeform Support 
     71.6 Enabling Multi-Window Support in an App 
     71.7 Specifying Multi-Window Attributes 
     71.8 Detecting Multi-Window Mode in an Activity 
     71.9 Receiving Multi-Window Notications 
     71.10 Launching an Activity in Multi-Window Mode 
     71.11 Conguring Freeform Activity Size and Position 
     71.12 Summary 
    72. An Overview of Android SQLite Databases
     72.1 Understanding Database Tables 
     72.2 Introducing Database Schema 
     72.3 Columns and Data Types 
     72.4 Database Rows 
     72.5 Introducing Primary Keys 
     72.6 What is SQLite? 
     72.7 Structured Query Language (SQL) 
     72.8 Trying SQLite on an Android Virtual Device (AVD) 
     72.9 e Android Room Persistence Library 
     72.10 Summary 
    73. e Android Room Persistence Library
     73.1 Revisiting Modern App Architecture 
     73.2 Key Elements of Room Database Persistence 
     73.2.1 Repository 
     73.2.2 Room Database 
     73.2.3 Data Access Object (DAO) 
     73.2.4 Entities 
     73.2.5 SQLite Database 
     73.3 Understanding Entities 
     73.4 Data Access Objects 
     73.5 e Room Database 
     73.6 e Repository 
     73.7 In-Memory Databases 
     73.8 Database Inspector 
     73.9 Summary 
    74. An Android TableLayout and TableRow Tutorial
     74.1 e TableLayout and TableRow Layout Views 
     74.2 Creating the Room Database Project 
     74.3 Converting to a LinearLayout 
     74.4 Adding the TableLayout to the User Interface 
     74.5 Conguring the TableRows 
     74.6 Adding the Button Bar to the Layout 
     74.7 Adding the RecyclerView 
     74.8 Adjusting the Layout Margins 
     74.9 Summary 
    75. An Android Room Database and Repository Tutorial
     75.1 About the RoomDemo Project 
     75.2 Modifying the Build Conguration 
     75.3 Building the Entity 
     75.4 Creating the Data Access Object 
     75.5 Adding the Room Database 
     75.6 Adding the Repository 
     75.7 Modifying the ViewModel 
     75.8 Creating the Product Item Layout 
     75.9 Adding the RecyclerView Adapter 
     75.10 Preparing the Main Fragment 
     75.11 Adding the Button Listeners 
     75.12 Adding LiveData Observers 
     75.13 Initializing the RecyclerView 
     75.14 Testing the RoomDemo App 
     75.15 Using the Database Inspector 
     75.16 Summary 
    76. Accessing Cloud Storage using the Android Storage Access Framework
     76.1 e Storage Access Framework 
     76.2 Working with the Storage Access Framework 
     76.3 Filtering Picker File Listings 
     76.4 Handling Intent Results 
     76.5 Reading the Content of a File 
     76.6 Writing Content to a File 
     76.7 Deleting a File 
     76.8 Gaining Persistent Access to a File 
     76.9 Summary 
    77. An Android Storage Access Framework Example
     77.1 About the Storage Access Framework Example 
     77.2 Creating the Storage Access Framework Example 
     77.3 Designing the User Interface 
     77.4 Declaring Request Codes 
     77.5 Creating a New Storage File 
     77.6 e onActivityResult() Method 
     77.7 Saving to a Storage File 
     77.8 Opening and Reading a Storage File 
     77.9 Testing the Storage Access Application 
     77.10 Summary 
    78. Video Playback on Android using the VideoView and MediaController Classes
     78.1 Introducing the Android VideoView Class 
     78.2 Introducing the Android MediaController Class 
     78.3 Creating the Video Playback Example 
     78.4 Designing the VideoPlayer Layout 
     78.5 Downloading the Video File 
     78.6 Conguring the VideoView 
     78.7 Adding the MediaController to the Video View 
     78.8 Setting up the onPreparedListener 
     78.9 Summary 
    79. Android Picture-in-Picture Mode
     79.1 Picture-in-Picture Features 
     79.2 Enabling Picture-in-Picture Mode 
     79.3 Conguring Picture-in-Picture Parameters 
     79.4 Entering Picture-in-Picture Mode 
     79.5 Detecting Picture-in-Picture Mode Changes 
     79.6 Adding Picture-in-Picture Actions 
     79.7 Summary 
    80. An Android Picture-in-Picture Tutorial
     80.1 Adding Picture-in-Picture Support to the Manifest 
     80.2 Adding a Picture-in-Picture Button 
     80.3 Entering Picture-in-Picture Mode 
     80.4 Detecting Picture-in-Picture Mode Changes 
     80.5 Adding a Broadcast Receiver 
     80.6 Adding the PiP Action 
     80.7 Testing the Picture-in-Picture Action 
     80.8 Summary 
    81. Making Runtime Permission Requests in Android
     81.1 Understanding Normal and Dangerous Permissions 
     81.2 Creating the Permissions Example Project 
     81.3 Checking for a Permission 
     81.4 Requesting Permission at Runtime 
     81.5 Providing a Rationale for the Permission Request 
     81.6 Testing the Permissions App 
     81.7 Summary 
    82. Android Audio Recording and Playback using MediaPlayer and MediaRecorder
     82.1 Playing Audio 
     82.2 Recording Audio and Video using the MediaRecorder Class 
     82.3 About the Example Project 
     82.4 Creating the AudioApp Project 
     82.5 Designing the User Interface 
     82.6 Checking for Microphone Availability 
     82.7 Initializing the Activity 
     82.8 Implementing the recordAudio() Method 
     82.9 Implementing the stopAudio() Method 
     82.10 Implementing the playAudio() method 
     82.11 Conguring and Requesting Permissions 
     82.12 Testing the Application 
     82.13 Summary 
    83. Printing with the Android Printing Framework
     83.1 e Android Printing Architecture 
     83.2 e Print Service Plugins 
     83.3 Google Cloud Print 
     83.4 Printing to Google Drive 
     83.5 Save as PDF 
     83.6 Printing from Android Devices 
     83.7 Options for Building Print Support into Android Apps 
     83.7.1 Image Printing 
     83.7.2 Creating and Printing HTML Content 
     83.7.3 Printing a Web Page 
     83.7.4 Printing a Custom Document 
     83.8 Summary 
    84. An Android HTML and Web Content Printing Example
     84.1 Creating the HTML Printing Example Application 
     84.2 Printing Dynamic HTML Content 
     84.3 Creating the Web Page Printing Example 
     84.4 Removing the Floating Action Button 
     84.5 Removing Navigation Features 
     84.6 Designing the User Interface Layout 
     84.7 Accessing the WebView from the Main Activity 
     84.8 Loading the Web Page into the WebView 
     84.9 Adding the Print Menu Option 
     84.10 Summary 
    85. A Guide to Android Custom Document Printing
     85.1 An Overview of Android Custom Document Printing 
     85.1.1 Custom Print Adapters 
     85.2 Preparing the Custom Document Printing Project 
     85.3 Creating the Custom Print Adapter 
     85.4 Implementing the onLayout() Callback Method 
     85.5 Implementing the onWrite() Callback Method 
     85.6 Checking a Page is in Range 
     85.7 Drawing the Content on the Page Canvas 
     85.8 Starting the Print Job 
     85.9 Testing the Application 
     85.10 Summary 
    86. An Introduction to Android App Links
     86.1 An Overview of Android App Links 
     86.2 App Link Intent Filters 
     86.3 Handling App Link Intents 
     86.4 Associating the App with a Website 
     86.5 Summary 
    87. An Android Studio App Links Tutorial
     87.1 About the Example App 
     87.2 e Database Schema 
     87.3 Loading and Running the Project 
     87.4 Adding the URL Mapping 
     87.5 Adding the Intent Filter 
     87.6 Adding Intent Handling Code 
     87.7 Testing the App Link 
     87.8 Associating an App Link with a Web Site 
     87.9 Summary 
    88. A Guide to the Android Studio Proler
     88.1 Accessing the Android Proler 
     88.2 Enabling Advanced Proling 
     88.3 e Android Proler Tool Window 
     88.4 e Sessions Panel 
     88.5 e CPU Proler 
     88.6 Memory Proler 
     88.7 Network Proler 
     88.8 Energy Proler 
     88.9 Summary 
    89. An Android Biometric Authentication Tutorial
     89.1 An Overview of Biometric Authentication 
     89.2 Creating the Biometric Authentication Project 
     89.3 Conguring Device Fingerprint Authentication 
     89.4 Adding the Biometric Permission to the Manifest File 
     89.5 Designing the User Interface 
     89.6 Adding a Toast Convenience Method 
     89.7 Checking the Security Settings 
     89.8 Conguring the Authentication Callbacks 
     89.9 Adding the CancellationSignal 
     89.10 Starting the Biometric Prompt 
     89.11 Testing the Project 
     89.12 Summary 
    90. Creating, Testing and Uploading an Android App Bundle
     90.1 e Release Preparation Process 
     90.2 Android App Bundles 
     90.3 Register for a Google Play Developer Console Account 
     90.4 Conguring the App in the Console 
     90.5 Enabling Google Play App Signing 
     90.6 Creating a Keystore File 
     90.7 Creating the Android App Bundle 
     90.8 Generating Test APK Files 
     90.9 Uploading the App Bundle to the Google Play Developer Console 
     90.10 Exploring the App Bundle 
     90.11 Managing Testers 
     90.12 Rolling the App Out for Testing 
     90.13 Uploading New App Bundle Revisions 
     90.14 Analyzing the App Bundle File 
     90.15 Summary 
    91. An Overview of Android Dynamic Feature Modules
     91.1 An Overview of Dynamic Feature Modules 
     91.2 Dynamic Feature Module Architecture 
     91.3 Creating a Dynamic Feature Module 
     91.4 Converting an Existing Module for Dynamic Delivery 
     91.5 Working with Dynamic Feature Modules 
     91.6 Handling Large Dynamic Feature Modules 
     91.7 Summary 
    92. An Android Studio Dynamic Feature Tutorial
     92.1 Creating the DynamicFeature Project 
     92.2 Adding Dynamic Feature Support to the Project 
     92.3 Designing the Base Activity User Interface 
     92.4 Adding the Dynamic Feature Module 
     92.5 Reviewing the Dynamic Feature Module 
     92.6 Adding the Dynamic Feature Activity 
     92.7 Implementing the launchIntent() Method 
     92.8 Uploading the App Bundle for Testing 
     92.9 Implementing the installFeature() Method 
     92.10 Adding the Update Listener 
     92.11 Handling Large Downloads 
     92.12 Using Deferred Installation 
     92.13 Removing a Dynamic Module 
     92.14 Summary 
    93. An Overview of Gradle in Android Studio
     93.1 An Overview of Gradle 
     93.2 Gradle and Android Studio 
     93.2.1 Sensible Defaults 
     93.2.2 Dependencies 
     93.2.3 Build Variants 
     93.2.4 Manifest Entries 
     93.2.5 APK Signing 
     93.2.6 ProGuard Support 
     93.3 e Top-level Gradle Build File 
     93.4 Module Level Gradle Build Files 
     93.5 Conguring Signing Settings in the Build File 
     93.6 Running Gradle Tasks from the Command-line 
     93.7 Summary 

    10. Spath P. Learn Java for Android Development.4ed 2020.pdf (860 pages)

    • Chapter 1: Getting Started with Java
    • Chapter 2: Learning Language Fundamentals
    • Chapter 3: Discovering Classes and Objects
    • Chapter A Discovering Inheritance, Polymorphism, and Interfaces
    • Chapter 5: Mastering Advanced Language Features, Part 1
    • Chapter 6: Mastering Advanced Language Features, Part 2
    • Chapter 7: Exploring the Basic APIs, Part 1
    • Chapter 8 Exploring the Basic APIs, Part 2
    • Chapter 9: Exploring the Collections Framework
    • Chapter 10: Functional Programming
    • Chapter 11: Exploring the Concurrency Utilities
    • Chapter 12: Performing Classic I/O
    • Chapter 13: Accessing Networks
    • Chapter 14: Migrating to New I/O
    • Chapter 15: Accessing Databases
    • Chapter 16: Working with XML and EON Documents
    • Chapter 17: Date and Time
    • Appendix A Solutions to Exercises

    11. FIREBASE_COOKBOOK.pdf (276 pages)

    • Chapter 1: Firebase - Getting Started
    • Chapter 2: Firebase Real-Time Database
    • Chapter 3: File Management with Firebase Storage
    • Chapter 4: Firebase Authentication
    • Chapter 5: Securing Application Flow with Firebase Rules
    • Chapter 6: Progressive Applications Powered by Firebase
    • Chapter 7: Firebase Admin SDK
    • Chapter 8: Extend Firebase with Cloud Functions
    • Chapter 9: We're Done, Let's Deploy
    • Chapter 10: Integrating Firebase with NativeScript
    • Chapter 11: Integrating Firebase with Android/10S Natively
    • Chapter 12: Hack Application's Growth
    • Chapter 13: Adding Analytics and Maximizing Earnings
    • Chapter 14: Firebase Cloud FireStore

    12. Android Application Programming with OpenCV.pdf (130 pages)

    • Chapter 1: Setting Up OpenCV
    • Chapter 2: Working with Camera Frames
    • Chapter 3: Applying Image Effects
    • Chapter 4: Recognizing and Tracking Images
    • Chapter 5: Combining Image Tracking with 3D Rendering

    13. Android Security Cookbook.pdf (350 pages)

    • Android Development Tools
    • Engaging with Application Security
    • Android Security Assessment Tools
    • Exploiting Applications
    • Protecting Applications
    • Reverse Engineering Applications
    • Secure Networking
    • Native Exploitation and Analysis
    • Encryption and Developing Device

    14. Android Security - Attacks And Defenses.epub (260 pages)

    • Introduction
    • Android architecture
    • Android application architecture
    • Android (in) security
    • Pen testing Android
    • Reverse engineering Android applications
    • Modifying the behavior of Android applications without source codeHacking Android
    • Security Android for the enterprise environment
    • Browser security and future threat landscape

    15. XDA Developers' Android Hacker's Toolkit The Complete Guide to Rooting, ROMs and Theming (EPUB).epub (112 pages)

    Part I: What You Need to Know

    Chapter 1: Android OS Internals: Understanding How Your
     Device Starts 
     The Penguin Down Below 
     How Your Android Device Starts 
     Adding a Custom Bootloader 
     Understanding the Bootloader Process 
     Custom Recoveries: The Holy Grail 
    Chapter 2: Rooting Your Android Device
     Why Should You Root? 
     Increasing the Service Life of the Device 
     Fixing OEM Defects 
     Increasing Capability 
     Customizing the Device 
     Backing Up Data 
     Contact Information 
     Applications and Their 
     Data  Data on the SD Card 
     How You Can Root and Leave Your 
     OEM's Control  OEM Flash Software 
     Native Fastboot Flash 
     Scripted and One-Click Methods 
     Rooting Two Devices 
     Nexus One  HTC Thunderbolt 
     The Root of It All 
    Chapter 3: The Right Tool for the Job
     Ready, Set, . . . Wait I Have to Have What?  
     Connecting a Phone to a Computer 
     Hacking Tools 
     USB Cables 
     USB Debugging 
     What's Driving This Thing? 
     Using the Android Debug Bridge 
     Checking Device Connectivity 
     Restarting the ADB Service 
     Copying Files to and from Your Device 
     Rebooting a Device 
     The Power of Fastboot 
     Unlocking a Device 
     Updating a Device 
     Flashing a Device 
     Rebooting a Device 
     Harnessing the Power of the Penguin with ADB Shell 
     File System Navigation 
     File Management 
     File Access Permissions 
     Redirection and Piping 
     BusyBox: Giving the Penguin Back Its Power 
     The dd Command 
     The echo Command 
     The md5sum Command 
    Chapter 4: Rooting and Installing a Custom Recovery
     How to Use Exploits 
     Exploit Scripts 
     Exploit Applications 
     Using a Script or Application on a Device 
     Hacking Utilities 
     OEM Tools 
     Developer Utilities 
     Image Files 
     Recovery Mode 
     What Is Recovery Mode? 
     Make It All So Easy: Get A Custom Recovery! 
     Using ClockworkMod Recovery 
     Rebooting the Device 
     Updating a Device from the SD Card 
     Resetting a Device to Factory Condition 
     Wiping the Cache 
     Installing a Zip File from the SD Card 
     Backing Up and Restoring a Device 
     Mounting Partitions and Managing Storage 
     Advanced Functions 
     Backup and Disaster Recovery 
     Precautions for Success and Data Recovery 
     Backing Up Applications 
     Backing Up Through a Recovery Process 
     Backing Up Through an Application 
     What Happens if It Goes Really Wrong? 
    Chapter 5: Theming: Digital Cosmetic Surgery
     Changing the Look and Feel of Android 
     Theming the Launcher 
     Theming with an Add-on Launcher 
     Tools Used in Theming 
     Android SDK Eclipse 
     A ROM of Your Choice 
     Update.zip Creator 
     The Editing Process 
     Walkthrough for Creating Theme Files 
     Walkthrough for Creating a Flashable ZIP File 
    Chapter 6: You've Become Superuser: Now What?
     Popular Multi-Device Custom ROMs 
     Android Open Kang Project 
     Kernel Tweaks 
     Backlight Notifications 
     Voodoo Enhancements 
     Performance and Battery Life Tweaks 
     Root Applications 
     Adfree Android 
     Chainfire 3D 
     Titanium Backup 
     Part II: Manufacturer Guidelines and Device-Specific Guides 
    Chapter 7: HTC EVO 3D: A Locked Device
     Obtaining Temporary Root 
     Using S-OFF and Permanent Root Requirements 
     Running the Revolutionary Tool 
     Installing a Custom Recovery 
     Installing the Superuser Binary 
     Installing a SuperUser Application 
    Chapter 8: Nexus One: An Unlockable Device
     Root Methods Available 
     Resources Required for this Walkthrough 
     Placing the Nexus One in Fastboot Mode 
     Flashing a Boot Partition 
     Getting Full Root Access 
     Installing a Custom Recovery 
    Chapter 9: HTC ThunderBolt: A Tightly Locked Device
     Root Methods Available 
     Resources Required for this Walkthrough 
     Pushing Files to the Device 
     Gaining Temporary Root 
     Checking a File's MD5 Signature 
     Writing the Temporary Bootloader 
     Downgrading the Firmware 
     Gaining Temporary Root to Unlock the MMC 
     Rewriting the Bootloader 
     Upgrading the Firmware 
    Chapter 10: Droid Charge: Flashing with ODIN
     Resources Required for this Walkthrough 
     Connecting the Device to ODIN 
     Flashing the Device 
    Chapter 11: Nexus S: An Unlocked Device
     Connecting the Device to a PC 
     Resources Required for this Walkthrough 
     Unlocking the Device 
     Flashing the Device with a Recovery 
     Flashing the Device with the SuperUser application 
    Chapter 12: Motorola Xoom: An Unlocked Honeycomb Tablet
     Resources Required for this Walkthrough 
     Pushing the Root File to the SD Card 
     Unlocking the Xoom 
     Flashing the Device with a Recovery 
     Flashing the Device with a Universal Root 
    Chapter 13: Nook Color: Rooting with a Bootable SD Card
     Resources Required for this Walkthrough 
     Creating a Bootable SD Card 
     Booting the Device from the SD Card 
     Making the Device More Usable 
    Appendix A: Setting Up Android SDK and ADB Tools

    16. Android Apps for Absolute Beginners (500 pages)

    Chapter 1: An Introduction to Android 7
     The History of the Android OS: An Impressive Growth  
     Advantage Android 70: How Can Android Benefit Me?   
     The Scope of This Book   
     What Is Covered in This Book   
     What Is Not Covered in This Book   
     What’s New in Android Nougat: Powerful New Features  
     Android Apps for the Google Chrome OS: Custom Pointer API   
     Power and CPU Optimization: Sustained Performance Mode API   
     Seamless Updates: Background Installation to Secondary Partition   
     Multiple Concurrent Windows: Run Two Android Apps at Once   
     Picture in a Picture: Watch Video or TV in an Android TV HD iTV Set   
     Change Display Density: Adjusting Pixel Per Inch (PPI) via Slider   
     Keyboard Themes: Customize Onscreen Keyboard Using Skins  
     Enhanced Doze Mode: Control Android  Device Resting States   
     OpenJDK: Moving Android Java from Oracle Java to OpenJDK   
     The Data Plan Saver: Sync Only When Connected to a Wi-Fi Portal   
     The Future of Android: 3D, VR, AR, OpenGL, and Vulkan   
     Khronos Vulkan: i3D Rendering Engine That Replaces OpenGL ES  
     Vulkan for Android: Leading-Edge i3D Performance for Android    
     OpenGL ES for Android: Desktop i3D Performance for Android    
    Chapter 2: Setting Up an Android Studio Development System
     Assembling Your Android 7 Development Workstation   
     Android Development Workstation: Hardware Foundation   
     Android Development Workstation: Software Foundation   
     Java 8: Download and Install a Foundation for Android   
     Android Studio: Download and Install Android Studio 2   
     Open Source New Media Content Software: UI and UX   
     New Media Software: Download and Installation Work Process   
     Other Affordable New Media Software Readers Should Know About   
    Chapter 3: An Introduction to the Android Studio Integrated
     Development Environment   
     Android Application Structure: Java, XML, and Assets   
     Android 7 Platform Structure: A Collection of Open Technologies   
     Android 7 Executable Structure: Compiled Runtime Java Bytecode   
     Creating Android 7 Apps: Android Studio’s New Project  
     The Android Studio Welcome Menu: Creating a New Android 7 App   
     Exploring Your Android Studio Project: The Android App Structure  
     Android Resource: Project Folder Hierarchy for Assets   
     Android Drawables: Images or Illustration That Draws on the Screen   
     Android User Interface Design Layout: Asset to Design UI Layout   
     Android Menu Design: Asset to Define Menu Structure and Options  
     Android Data Values: Assets to Define Fixed Application Constants   
     Android Anim Folder: Assets Defining Vector or Tween Animation   
     Android Animator: Assets for User Interface Property Animation   
     Android Raw Folder: Pre-Optimized Video and Audio Asset Files   
     Android XML: Arbitrary XML and Configurations  
     Updating Android Studio: Upgrading an SDK over Time   
    Chapter 4: Introduction to XML: Defining Android Apps, UI Design, and Constants
     Extensible Markup Language: XML Overview   
     XML Naming Schema: Tag and Parameter Repository   
     XML Syntax: Containers, Brackets, and Nesting   
     XML Referencing: Chain XML Constructs Together  
     XML Constants: Adding New Constants Using XML   
     XML Dimensions: Editing Dimensions Using XML  
     Alternate XML Resource: Dimensions for Tablets   
     XML Styles: Editing Styles or Themes Using XML  
     XML Colors: Define Application Color Using XML  
     Configuring an App Using XML: Android Manifest   
     UI Design Editor: XML Markup Generation   
    Chapter 5: Introduction to Java: Objects, Methods, Classes, and Interfaces
     The Three Versions, or Editions, of Java   
     A Foundation of OOP Constructs: An Object   
     Some Programming Terms: Variable, Method, and Constant  
     Java Constructs: Create Your Own Objects   
     The Java Class: Java Code Structure Container   
     The Java Method: Java Code Function Definition   
     Constructor Methods: The Java Object Blueprint   
     Instantiating Objects: The Java “new” Keyword   
     Extend an Object’s Structure: Java Inheritance   
     Java Interfaces: Defining Class Usage Patterns   
     Logical Collection of Classes: Using a Package   
     The API  
     Modifiers: Data Type, Access, Inheritance   
     Java Access Modifiers: Four Levels of Access   
     Non-Access Modifiers: Static, Final, and Abstract   
     Analyzing Your MainActivityjava Class  
     The AppCompatActivity Class: Spans OS Versions   
    Chapter 6: Android User Interface Design: Using Activity, View, and ViewGroup Classes
     How Activity, View, and ViewGroup Classes Interrelate   
     The ViewGroup Class: A Known Direct Subclass of View   
     The View Class: A Foundation of User Interface Design   
     The Activity Class: A User Interface Design Container   
     Creating UI Design from Scratch   
     Add a CheckBox User Interface Element to your Design   
     Add a TextView User Interface Element for Your Title   
     Add a Button User Interface Element for Interactivity   
     Squashing Bugs (Removing Errors) in the Design Editor   
     Eliminate Any Remaining Errors Using the XML Text Editor  
    Chapter 7: Making Apps Interactive: Events and Intents
     About Intent Objects: The Android Intent Class   
     Intent Types: Explicit Intent versus Implicit Intent   
     IntentFilter: Construct an Implicit Intent Definition   
     Instantiating an Intent Object: Passing App Context   
     Explaining Context: The Android Context Class  
     Event Processing: Using Events with Event Listeners   
     Events: Turning Device User Interaction into Events  
     Event Listener: Java Methods Process UI Widget Events   
     Event Handler: Java Methods Process Global Event Type  
     Creating a Second Activity: The UniverseActivity Class   
     Adding Event Listeners to the Activity Button Objects   
     Adding Intent Processing to your Event Handling  
     Emulating Hardware: Creating an AVD to Test Your App   
     Running the Application: Building the App Using Gradle   
    Chapter 8: Android Design Patterns: UI Design Paradigms
     Android Design Patterns: Ensuring App Visual Quality   
     Material Design: i3D Animated User Experience Designs   
     Hardware Devices: Code Design Patterns Across Devices   
     Pure Android: Application Design Branding Conformance   
     Creating a Sliding Drawer: UI Only When Users Need It   
     Creating Menu Structures for a UI Design: The Android Menu Interface   
     Deprecated Java Code: Researching Replacement APIs   
    Chapter 9: Android Graphic Design: Making UI Designs Visual
     Imaging Concepts, Formats, and Techniques   
     The Foundation of Digital Images: The Pixel   
     The Shape of a Digital Image: The Aspect Ratio   
     Coloring Your Digital Images: RGB Color Theory   
     Image Compositing Transparency: Alpha Channels   
     Algorithmic Image Compositing: Blending Modes   
     Masking Digital Imagery: Using Alpha Channels   
     Smoothing Edges: The Concept of Anti-Aliasing   
     Optimizing Digital Images: Compress and Dither   
     Using Indexed Color Imagery: Dithering Pixels   
     Android Image Formats: Lossless versus Lossy   
     Creating Android NinePatchDrawable Assets   
     Installing the Draw 9-Patch Source PNG32 Image   
     Exploring Android Studio’s 9-Patch Editor   
     Using Your NinePatchDrawable Asset in Android  
     Using NinePatchDrawable Assets in an App  
     Creating Multi-state PNG32 Image Assets   
     The ImageButton Class: Multi-state Button   
     The States: Normal, Pressed, Focused, Hovered   
     Creating Android Multi-state ImageButtons   
    Chapter 10: Android Animation: Image and Procedural Animation
     Frame Animation: Concepts and Techniques  
     Frame Animation: Cels, Frames, and Terminology   
     Android Image Format: PNG, GIF, JPG, WebP, BMP   
     Optimizing Frames: Color Depth and Frame Count   
     Animation Resolution: Pixels Add to File Size!  
     Frame Animation: Using AnimationDrawable   
     Creating Frame Animation: XML Frame Definition   
     Creating Frame Animation in XML and Java   
     Create the XML Frame Animation Definition File   
     Create ImageView and AnimationDrawable Objects  
     Android Tween Animation: Vector Concepts   
     Procedural Concepts: Rotate, Scale, Translate   
     Procedural Data Values: Ranges and Pivot Point   
     Procedural Animation Compositing: Alpha Values   
     Procedural Timing: Using Duration and Offsets   
     Procedural Loops: RepeatCount and RepeatMode  
     Android Animation Class: Tween Animation   
     Creating Tween Animation Using XML Markup  
     Create an /anim Folder: Tween Animation Assets  
     Android ScaleAnimation Class: Animated Scaling   
     The Scale Transform: Configuration Parameters   
     Android AnimationSet Class: Transform Grouping   
     AnimationSet Container: Groups and Subgroups  
     Java Code: Tying Two Animation Types Together   
     Complex Animation: Android Interpolators   
     Creating Complex Animation Using XML Markup   
     Android Interpolator Interface: Motion Curves  
     Java Code: Two Widgets Use the Tween Animation   
     Procedural Animation or Frame Animation?   
     The Animator Class: Parameter Animation   
    Chapter 11: Digital Video: Streaming Video, MediaPlayer, and MediaController Classes
     Creating a Video App: FullscreenActivity   
     The FrameLayout Class: Framing DV Content   
     FrameLayoutLayoutParams Nested Class: Gravity   
     The VideoView Class: A VideoPlayer Widget   
     The VideoView Lifecycle: Video Playback Stages   
     Create a VideoView Layout Design with your XML   
     Digital Video Concepts: Bitrates and Codecs   
     Digital Video in Android: MPEG4 H and WebM   
     Digital Video Compression: Bitrate and Streams   
     Digital Video Optimization: Codec and Settings   
     Creating Digital Video Content: Terragen4   
     Digital Video Compression: Sorenson Squeeze 11   
     Creating a Digital Video Folder: Raw Resources   
     The Uri Class: Referencing the Video Data   
     The Uriparse() Method: Loading Your VideoView   
     Android MediaPlayer: VideoPlayback Engine   
     Android MediaController: A VideoTransport   
     Add a Video Transport UI Using MediaController   
     Loop Digital Video: Using OnPrepareListener  
     Streaming Digital Video: Using HTTP URL in URI  
    Chapter 12: Digital Audio: Sequencing Audio Using SoundPool
     Audio Waves: History, Concepts, and Theory   
     Foundation of Analog Audio: Sound Waves of Air   
     Digital Audio: Samples, Resolution, and Frequency   
     Digital Attributes: HD, Stream, and Bitrate   
     Android Digital Audio: Digital Audio Formats   
     Digital Audio Optimization: Device Compatible   
     Audio Sequencing: Concepts and Principles   
     Audio Synthesis: Concepts and Principles   
     Raw Audio Data Optimization: Memory Footprint   
     Digital Audio Synthesis and Sequencing Caveats  
     Audacity 2: Creating Digital Audio Assets   
     Audacity : Installing Software and Codecs   
     Free Audio: Locate DigitalAudioSequencer Audio   
     Digital Audio Optimization: Concepts and Formats   
     DigitalAudioSequencer: ScrollingActivity   
     Android SoundPool: Digital Audio Engine   
     Add SoundPool Engine to DigitalAudioSequencer   
     Android AudioAttributes: Configuring SoundPool   
     Configuring a SoundPool Using AudioAttributes   
    Chapter 13: Android Services and Threads: Background Processing
     Android’s Service Class: Characteristics   
     Controlling Your Service: Privacy and Priority   
     Processes or Threads: Foundational Information   
     Spawn a Process: android:process XML Parameter   
     The Process Life Cycle: Keeping a Process Alive  
     Thread Caveats: Don’t Interfere with UI Thread   
     Should Android Apps Use Services or Threads?   
     Creating a Service: AmbientAudioService   
     Configuring AndroidManifest to add a   
     Service: Background Processing Services   
     Configure AmbientAudioService: Play Audio   
     Starting a Service: Using startService( )   
    Chapter 14: Android Content Providers: Datastore Concepts
     Overview of Android Content Providers: Sharable Data   
     Database Fundamentals: Concepts and Terms   
     SQLite: An Open Source Database Engine   
     Android’s Built-In SQLite DBMS Content Providers   
     Android 15 Contacts Database Contact Provider   
     Deprecated Database Structures: Software Upgrades   
     The Android MediaStore Content Providers   
     The Android CalendarContract Content Providers   
     Referencing the Content Provider: Using a Content URI   
     Creating a Basic Activity: The SQLiteProvider Project   
     Examining and Testing Your SQLiteProvider Bootstrap  
     Configuring the Manifest: Uses SDK and Permissions   
     Creating Your Dummy Contact Database Using an AVD   
     RelativeLayout: Create Morphing User Interface Design   
     Creating Your RelativeLayout UI for MainActivity  
     Transform the MainActivity Class for Database Access   
     Creating Your Custom listContacts() Database Access Method   
     Writing to a Database: Using the ContentValues Object   

    17. Babic F. Android Animations by Tutorials 2021 (374 pages)

    • 1. Android Animations by Tutorials
    • 2. Book License
    • 3. Before You Begin
    • 4. What You Need
    • 5. Book Source Code & Forums
    • 6. Dedications
    • 7. About the Team
    • 8. Introduction
    • 9. Section I: View & Property Animations
    • 10. Chapter 1: Value & Object Animators
    • 11. Chapter 2: Animating Custom Views
    • 12. Chapter 3: XML Animations
    • 13. Section II: Screen Transitions
    • 14. Chapter 4: Animating Activity & Fragment Transitions With XML
    • 15. Chapter 5: Transition Framework
    • 16. Chapter 6: Element Transitions
    • 17. Section III: List & Gesture Animations
    • 18. Chapter 7: Basic List Animations
    • 19. Chapter 8: ItemTouchHelper Animations
    • 20. Chapter 9: Animate Scroll Gestures
    • 21. Section IV: Jetpack Compose Animations
    • 22. Chapter 10: Jetpack Compose Animations

    18. Margain P., Kamal F. Android App Distribution 2022 (374 pages)

    • Chapter 1: The Perfect Build
        What to expect from the release process 
        Tools for Release 
        In an ideal world, what would "the perfect build" look like?    
        Releasing pain points 
        Concepts & Terminology  
        Getting the sample project  
        Key points 
        Where to go from here? 
    • Chapter 2: App Store Quick Start
        Code cleanup 
        Building a release version  
        Checking your file size  
        Release testing 
        Creating your Google Play Store listing 
        Main store listing 
        Releasing your app 
        Key points 
        Where to go from here? 
    • Chapter 3: Preparing for Release: Test Tracks
        Play Console overview  
        Key points 
        Where to go from here? 
    • Chapter 4: Strategies for Release
        Version codes 
        Open test track 
        Pre-launch report 
        Rollout & quality 
        Release to production  
        Publishing API 
        Making use of the Google toolsets 
        Production release 
        Production release 
        Other publishing methods 
        Key points 
        Where to go from here?                                       
    • Chapter 5: Permissions
        App manifest permissions 
        Asking for permission 
        Updating Podplay to search by location 
        Finding background location use 
        Simplifying multiple permission requests with Android Jetpack   
        Key points 
        Where to go from here?                                        
    • Chapter 6: Security Best Practices
        Data storage domains 
        Securely storing data 
        Securing the Organized Simple Note app 
        Key points  
        Where to go from here?                                       
    • Chapter 7: Optimizing App Size & Obfusticating the APK
        Why is optimization important? 
        Best practices for reducing your app size 
        APK Analyzer 
        Other improvements you can do with the analysis 
        Optimizing images 
        Making changes in your images 
        Unused resources 
        Enabling Proguard / R8 
        Size reductions to make directly in your code 
        Going one step further in optimization 
        Key points                                                    
    • Chapter 8: Adding Features Dynamically
        What are dynamic features? 
        Delivering dynamic modules 
        Feature flagging 
        Key points 
        Where to go from here?                                        
    • Chapter 9: Build Variants: Implementing Build Types
        Switching build types in Android Studio 
        Implementing build types in your app 
        Gradle DSL reference 
        Release build type 
        Key points                                                                          
    • Chapter 10: Publishing in the Real World
        What can you do with flavors? 
        Creating flavors 
        Key points                                                                         
    • Chapter 11: Automation Tools for Your Local Environment
        What is automation? 
        Why automate my process? 
        Building the app via command line 
        Introduction to Fastlane 
        Creating a Fastfile 
        Running tests 
        Using Screengrab 
        Deploying beta builds 
        Deploying to production 
        Uploading your app to the Play Console 
        Key points 
        Where to go from here?                                                               
    • Chapter 12: Continuous Integration & Build Servers
        The benefits of CI 
        GitHub Actions 
        Key points 
        Where to go from here?                                                               
    • Chapter 13: Getting Top Ratings & Avoiding Negative Reviews: Gathering In-App Feedback
        Responding to Google Play comments in the dashboard 
        Case studies: in-app feedback 
        Building an in-app feedback mechanism 
        Key points 
        Where to go from here?                                                             
    • Chapter 14: Monitoring & Improving App Performance: Android Vitals
        Understanding Android Vitals 
        Exploring the dashboard 
        Reviewing pre-launch reports 
        Using Android vitals to understand your app's power consumption 
        Understanding your app's performance 
        Key points 
        Where to go from here? 

    19. Mastering Android Studio(263 pages)

    Chapter 1 ◾ Introduction to Android Studio
     The User Interface  
     Tool Windows  
     Style and Formatting  
     Version Control Basics  
     Gradle Build System  
     Build Variants  
     Multiple Android Application Package 
     Resource Shrinking  
     Managing Dependencies  
     Debug and Profile Tools  
     Performance Profilers  
     Heap Dump  
     Memory Profiler  
     Data File Access  
     Code Inspections  
     Annotations in Android Studio  
     Log Messages  
     Sign in to Your Developer Account  
    Chapter 2 ◾ Getting Started with Android
     Chrome OS  
     Customizing Your VM Options  
     Customizing Your IDE Properties  
     Configuring the IDE for Low-Memory 
     Setting the JDK Version  
     Proxy Settings  
     Android Plugin for Gradle HTTP Proxy 
     Sensible Defaults  
     Build Variants  
     Manifest Entries  
     ProGuard Support  
     Changing Default Source Set Configurations  
     Managing Libraries and Dependencies  
     Creating Different Versions of Your App  
     Configuring Instrumentation Manifest 
     Configuring Gradle Test Options  
     Android App Module  
     Feature Module  
     Library Module  
     Google Cloud Module  
     Project Files  
     Project Structure Settings  
     Choosing Your Project  
     Configuring Your Project  
     Import an Existing Project  
     Feature Module Build Configuration  
     Establish a Relationship to the Base Module  
     Specify Additional ProGuard Rules  
     Deploy Your App  
     Use Feature Modules for Custom Delivery  
     Building a URI for a Resource  
     Considerations for Feature Modules  
    Chapter 3 ◾ Android Studio Basics
     Splitting the Action Bar  
     Hiding the Action Bar  
     Overlaying the Action Bar  
     Layout Position  
     Types of Android Layout  
     Using UI Elements in the XML File  
     Inspect Your Layout  
     Revise Your Layout  
     Use Lint  
     Creating a Re-Usable Layout  
     Use the <include> Tag  
     Use the <merge> Tag  
     String Array  
     Quantity Strings (Plurals)  
     Handling Special Characters  
     Formatting Strings  
     The Basic Approach  
     Fully Customized Components  
     Extend onDraw() and onMeasure()  
     Subclass a View  
     Define Custom Attributes  
     Apply Custom Attributes  
     Add Properties and Events  
     Design for Accessibility  
    Chapter 4 ◾ Android Studio Tools
     Installing the Android SDK (Automated Way)  
     Installing for Ubuntu Linux  
     Installing via Homebrew  
     Installing the Android SDK (Manual Way)  
     Installing via the GUI  
     Installing via the Command Line  
     Anatomy of the Android SDK  
     Using the ADB  
     The Android Emulator  
     Install and Add Files  
     Using the SDK Independently  
     System Images  
     Storage Area  
     Creating an AVD  
     Creating a Hardware Profile  
     Gradle Plugins  
     Navigation Graph  
     Adding a New Comment  
     Add a Javadoc Using Context Actions  
     Disable Automatic Comments  
     Fix a Javadoc  
     Render Javadocs  
     Render Javadocs by Default  
     Generate a Javadoc Reference  
     View Javadocs in the Editor  
    Chapter 5 ◾ Debugging
     Debug Window Frames  
     Inspect Variables  
     View and Change Resource Value Display 
     About Run/Debug Configurations  
     Default Run/Debug Configuration  
     Symbol Directories  
     LLDB Startup Commands  
     LLDB Post Attach Commands  
     Logging: Target Channels  
     Miscellaneous Tab  
     Dalvik Debug Monitor Server (DDMS)  
     Hierarchy Viewer  
     Pixel Perfect  
     Network Traffic Tool  
     Navigating and Searching Within Studio  
     Viewing Layouts  
     Design Tools: Layout Editor  
     Design Tools: Navigation Editor  
     Writing Code  
     Build and Run  
     Version Control/Local History  
     Compile Options  
     Link Options  
     Environment Variables  
     Android Studio Configuration Environment 
     Emulator Environment Variables  
     adb Environment Variables  
     ADB Logcat Environment Variables  
     How to Set Environment Variables  

    20. Moore K., Mota C. Kotlin Multiplatform by Tutorials 2022 (400 pages)

    • Chapter 1: Introduction
        What is Kotlin Multiplatform?  
        Setting up your environment  
        Creating your first project  
        Key points 
        Where to go from here? 
    • Chapter 2: Getting Started
        Getting to know Gradle  
        Shared build file 
        Android build file 
        Find Time 
        Business logic 
        Key points 
        Where to go from here? 
    • Chapter 3: Developing UI: Android Jetpack Compose
        UI frameworks 
        Jetpack Compose 
        Time finder 
        Time Zone screen 
        Find Meeting Time screen  
        Key points 
        Where to go from here? 
    • Chapter 4: Developing UI: iOS SwiftUl
        Getting to know SwiftUl  
        Key points 
        Where to go from here? 
    • Chapter 5: Developing UI: Compose Multiplatform
        Getting to know Compose Multiplatform  
        Creating a desktop app  
        Shared UI 
        Key points 
        Where to go from here? 
    ► Chapter 6: Connect to Platform-Specific API
        Reusing code between platforms 
        Say hello to Organize 
        Updating the Platform class 
        Updating the UI 
        Key points 
    • Chapter 7: App Architecture
        Design patterns 
        Sharing business logic 
        Creating Reminders section 
        Sharing tests and UI 
        Key points 
    • Chapter 8: Testing
        Setting up the dependencies 
        Writing tests for RemindersViewModel  
        Writing tests for Platform 
        UI tests 
        Key points  
        Where to go from here? 
    • Chapter 9: Dependency Injection
        Advantages of dependency injection  
        Automated DI vs. manual DI 
        Setting up Koin 
        Using Koin in each platform 
        Updating AboutViewModel 
        Key points 
        Where to go from here? 
    • Chapter 10: Data Persistence
        Key-Value storage 
        Key points  
        Where to go from here? 
    • Chapter 11: Serialization
        The need for serialization 
        Project overview 
        Application features 
        Adding serialization to your Gradle configuration  
        Different serialization formats 
        Creating a custom serializer  
        Serializing/deserializing new data 
        Serializable vs. Parcelable  
        Implementing Parcelize in KMP 
        Key points 
        Where to go from here?  
    • Chapter 12: Networking
        The need for a common networking library 
        Using Ktor 
        Adding Ktor 
        Connecting to the API with Ktor 
        Retrieving content 
        Adding headers to your request 
        Uploading files 
        Challenge: Send your package name in a request header   
        Key points 
        Where to go from here? 
    • Chapter 13: Concurrency
        The need for structured concurrency 
        Understanding kotlinx.coroutines 
        Structured concurrency in iOS  
        Using kotlinx.coroutines  
        Working with kotlinx.coroutines 
        New Kotlin/Native memory model 
        Key points 
        Where to go from here?  
    • Chapter 14: Creating Your KMP Library
        Migrating an existing feature to Multiplatform 
        Publishing your KMP library  
        Key points 
        Where to go from here?  
       Chapter 15: Conclusion 
    • Appendix A: Kotlin: A Primer for Swift Developers
        Kotlin and Swift: Comparing both languages 
        Kotlin and Swift syntax table  
        Where to go from here? 
    • Appendix B: Debugging Your Shared Code From Xcode
        Debugging the shared module 
        Where to go from here? 
    • Appendix C: Sharing Your Compose UI Between Android & Desktop
        Updating your project structure 
        Sharing your UI code 
        Migrating Your Android UI code to multiplatform 
        Compose Multiplatform  
        Using third-party libraries  
        Handling resources 
        What's missing? 
        Where to go from here? 

    21. Pierre-Olivier L. Programming Android with Kotlin...(Final) 2022 (459 pages)

    • 1. Kotlin Essentials
       • The Kotlin Type System  
          Primitive Types  
          Null Safety 
          The Unit Type  
          Function Types  
       • Variables and Functions  
          Extension Functions 
       • Classes 
          Class Initialization  
          lateinit Properties  
          Lazy Properties  
          Companion Objects 
          Data Classes 
          Enum Classes 
          Sealed Classes  
         Visibility Modifiers  
    • 2. The Kotlin Collections Framework
       • Collection Basics  
          Java Interoperability 
          Overloaded Operators 
          Creating Containers 
       • Functional Programming 
          Functional Versus Procedural: A Simple Example  
          Functional Android 
        • Kotlin Transformation Functions  
          The Boolean Functions  
          Filter Functions 
          Iterators Versus Sequences 
       • An Example 
          The Problem 
          The Implementation 
    • 3. Android Fundamentals
       • The Android Stack 
          System Services 
          Android Runtime Environment  
       • The Android Application Environment  
          Intents and Intent Filters  
       • Android Application Components: The Building Blocks  
          The Activity and Its Friends  
          Content Providers 
          Broadcast Receivers 
       • Android Application Architectures  
          MVC: The Foundation 
          The Local Model 
       • Android Patterns 
    • 4. Concurrency in Android
       • Thread Safety 
         The Android Threading Model  
         Dropped Frames 
         Memory Leaks 
       • Tools for Managing Threads 
          Executors and ExecutorServices 
       • Tools for Managing Jobs 
    • 5. Thread Safety
         An Example of a Thread Issue 
       • Invariants  
          Thread-Safe Collections 
         Thread Confinement 
         Thread Contention 
         Blocking Call Versus Nonblocking Call 
         Work Queues 
         Back Pressure 
    • 6. Handling Concurrency Using Callbacks
         Example-of-Purchase Feature 
       • Creating the App 
          Implement the Logic 
         Limitations of the Threading Model 
    • 7. Coroutines Concepts
       • What Exactly Is a Coroutine? 
          Your First Coroutine 
          The async Coroutine Builder 
         A Quick Detour About Structured Concurrency 
         The Parent-Child Relationship in Structured Concurrency  
         CoroutineScope and CoroutineContext 
         Suspending Functions 
         Suspending Functions Under the Hood 
         Using Coroutines and Suspending Functions: A Practical Example  
         Don't Be Mistaken About the suspend Modifier 
    • 8. Structured Concurrency with Coroutines
      • Suspending Functions  
          Set the Scene 
          Traditional Approach Using java.util.concurrent.ExecutorService  
          A Reminder About HandlerThread 
          Using Suspending Functions and Coroutines 
          Summary of Suspending Functions Versus Traditional Threading 
       • Cancellation 
          Coroutine Lifecycle 
          Cancelling a Coroutine 
          Cancelling a Task Delegated to a Third-Party Library 
          Coroutines That Are Cooperative with Cancellation 
          delay Is Cancellable  
          Handling Cancellation  
          Causes of Cancellation 
         supervisorScope Builder  
         Parallel Decomposition  
         Automatic Cancellation 
       • Exception Handling 
          Unhandled Versus Exposed Exceptions 
          Exposed Exceptions  
          Unhandled Exceptions  
         Closing Thoughts 
    • 9. Channels
       • Channels Overview 
          Rendezvous Channel  
          Unlimited Channel 
          Conflated Channel 
          Buffered Channel 
          Channel Producers 
       • Communicating Sequential Processes 
          Model and Architecture  
          A First Implementation  
          The select Expression  
          Putting It All Together  
          Fan-Out and Fan-In  
          Performance Test 
          Back Pressure 
          Similarities with the Actor Model 
          Execution Is Sequential Inside a Process 
          Final Thoughts 
         Deadlock in CSP 
         Limitations of Channels  
         Channels Are Hot 
    • 10. Flows
       • An Introduction to Flows  
          A More Realistic Example 
          Terminal Operators 
       • Examples of Cold Flow Usage 
          Use Case #1: Interface with a Callback-Based API 
          Use Case #2: Concurrently Transform a Stream of Values  
          What Happens in Case of Error? 
          Final Thoughts 
          Use Case #3: Create a Custom Operator 
       • Error Handling 
          The try/catch Block 
          Separation of Concern Is Important 
          Exception Transparency Violation 
          The catch Operator  
          Materialize Your Exceptions 
       • Hot Flows with SharedFlow  
          Create a SharedFlow  
          Register a Subscriber  
          Send Values to the SharedFlow 
          Using SharedFlow to Stream Data 
          Using SharedFlow as an Event Bus 
          StateFlow: A Specialized SharedFlow 
          An Example of StateFlow Usage 
    • 11. Performance Considerations with Android Profiling Tools
       • Android Profiler 
          Network Profiler  
          CPU Profiler 
          Energy Profiler 
          Memory Profiler 
         Detecting Memory Leaks with LeakCanary 
    • 12. Trimming Down Resource Consumption with Performance Optimizations
        Achieving Flatter View Hierarchy with ConstraintLayout 
        Reducing Programmatic Draws with Drawables 
        Minimizing Asset Payload in Network Calls 
        Bitmap Pooling and Caching 
        Reducing Unnecessary Work 
        Using Static Functions 
        Minification and Obfuscation with R8 and ProGuard 

    22. Reactive Programming with Kotlin by Alex Sullivan (601 pages)

    • Reactive Programming with Koltin
    • Book License
    • Book Source Code & Forums
    • What You Need
    • Book Updates
    • About the Cover
    • Section I: Getting Started with RxJava
    • Chapter 1: Hello, RxJava!
    • Chapter 2: Observables
    • Chapter 3: Subjects
    • Chapter 4: Observables & Subjects in Practice
    • Section II: Operators & Best Practices
    • Chapter 5: Filtering Operators
    • Chapter 6: Filtering Operators in Practice
    • Chapter 7: Transforming Operators
    • Chapter 8: Transforming Operators in Practice
    • Chapter 9: Combining Operators
    • Chapter 10: Combining Operators in Practice
    • Chapter 11: Time-Based Operators
    • Section III: Intermediate RxJava
    • Chapter 12: Error Handling in Practice
    • Chapter 13: Intro to Schedulers
    • Chapter 14: Flowables & Backpressure
    • Chapter 15: Testing RxJava Code
    • Chapter 16: Creating Custom Reactive Extensions
    • Section IV: RxJava Community Cookbook
    • Chapter 17: RxBindings
    • Chapter 18: Retrofit
    • Chapter 19: RxPreferences
    • Chapter 20: RxPermissions
    • Section V: Putting It All Together
    • Chapter 21: RxJava & Jetpack
    • Chapter 22: Building a Complete RxJava App

    23. Android Programming with Kotlin for Professionals (80 pages)

    Chapter 1: Getting started with Kotlin
     Section 1.1: Hello World  
     Section 1.2: Hello World using a Companion Object  
     Section 1.3: Hello World using an Object Declaration  
     Section 1.4: Main methods using varargs  
     Section 1.5: Compile and Run Kotlin Code in Command Line  
     Section 1.6: Reading input from Command Line  
    Chapter 2: Basics of Kotlin
     Section 2.1: Basic examples  
    Chapter 3: Strings
     Section 3.1: String Equality  
     Section 3.2: String Literals  
     Section 3.3: Elements of String  
     Section 3.4: String Templates  
    Chapter 4: Arrays
     Section 4.1: Generic Arrays  
     Section 4.2: Arrays of Primitives  
     Section 4.3: Create an array  
     Section 4.4: Create an array using a closure  
     Section 4.5: Create an uninitialized array  
     Section 4.6: Extensions  
     Section 4.7: Iterate Array  
    Chapter 5: Collections
     Section 5.1: Using list  
     Section 5.2: Using map  
     Section 5.3: Using set  
    Chapter 6: Enum
     Section 6.1: Initialization  
     Section 6.2: Functions and Properties in enums  
     Section 6.3: Simple enum  
     Section 6.4: Mutability  
    Chapter 7: Functions
     Section 7.1: Function References  
     Section 7.2: Basic Functions  
     Section 7.3: Inline Functions  
     Section 7.4: Lambda Functions  
     Section 7.5: Operator functions  
     Section 7.6: Functions Taking Other Functions  
     Section 7.7: Shorthand Functions  
    Chapter 8: Vararg Parameters in Functions
     Section 8.1: Basics: Using the vararg keyword  
     Section 8.2: Spread Operator: Passing arrays into vararg functions  
    Chapter 9: Conditional Statements
     Section 9.1: When-statement argument matching  
     Section 9.2: When-statement as expression  
     Section 9.3: Standard if-statement  
     Section 9.4: If-statement as an expression  
     Section 9.5: When-statement instead of if-else-if chains  
     Section 9.6: When-statement with enums  
    Chapter 10: Loops in Kotlin
     Section 10.1: Looping over iterables  
     Section 10.2: Repeat an action x times  
     Section 10.3: Break and continue  
     Section 10.4: Iterating over a Map in kotlin  
     Section 10.5: Recursion  
     Section 10.6: While Loops  
     Section 10.7: Functional constructs for iteration  
    Chapter 11: Ranges
     Section 11.1: Integral Type Ranges  
     Section 11.2: downTo() function 
     Section 11.3: step() function  
     Section 11.4: until function  
    Chapter 12: Regex
     Section 12.1: Idioms for Regex Matching in When Expression  
     Section 12.2: Introduction to regular expressions in Kotlin  
    Chapter 13: Basic Lambdas
     Section 13.1: Lambda as parameter to filter function  
     Section 13.2: Lambda for benchmarking a function call  
     Section 13.3: Lambda passed as a variable  
    Chapter 14: Null Safety
     Section 14.1: Smart casts  
     Section 14.2: Assertion  
     Section 14.3: Eliminate nulls from an Iterable and array  
     Section 14.4: Null Coalescing / Elvis Operator  
     Section 14.5: Nullable and Non-Nullable types  
     Section 14.6: Elvis Operator (?:)  
     Section 14.7: Safe call operator  
    Chapter 15: Class Delegation
     Section 15.1: Delegate a method to another class  
    Chapter 16: Class Inheritance
     Section 16.1: Basics: the 'open' keyword  
     Section 16.2: Inheriting fields from a class  
     Section 16.3: Inheriting methods from a class  
     Section 16.4: Overriding properties and methods  
    Chapter 17: Visibility Modifiers
     Section 17.1: Code Sample  
     Chapter 18: Generics  
     Section 18.1: Declaration-site variance  
     Section 18.2: Use-site variance  
    Chapter 19: Interfaces
     Section 19.1: Interface with default implementations  
     Section 19.2: Properties in Interfaces  
     Section 19.3: super keyword  
     Section 19.4: Basic Interface  
     Section 19.5: Conflicts when Implementing Multiple Interfaces with Default Implementations  
    Chapter 20: Singleton objects
     Section 20.1: Use as replacement of static methods/fields of java  
     Section 20.2: Use as a singleton  
    Chapter 21: coroutines
     Section 21.1: Simple coroutine which delay's 1 second but not blocks  
    Chapter 22: Annotations
     Section 22.1: Meta-annotations  
     Section 22.2: Declaring an annotation  
    Chapter 23: Type aliases
     Section 23.1: Function type  
     Section 23.2: Generic type  
    Chapter 24: Type-Safe Builders
     Section 24.1: Type-safe tree structure builder  
    Chapter 25: Delegated properties
     Section 25.1: Observable properties  
     Section 25.2: Custom delegation  
     Section 25.3: Lazy initialization  
     Section 25.4: Map-backed properties  
     Section 25.5: Delegate Can be used as a layer to reduce boilerplate  
    Chapter 26: Reflection
     Section 26.1: Referencing a class  
     Section 26.2: Inter-operating with Java reflection  
     Section 26.3: Referencing a function  
     Section 26.4: Getting values of all properties of a class  
     Section 26.5: Setting values of all properties of a class  
    Chapter 27: Extension Methods
     Section 27.1: Potential Pitfall: Extensions are Resolved Statically  
     Section 27.2: Top-Level Extensions  
     Section 27.3: Lazy extension property workaround  
     Section 27.4: Sample extending Java 7+ Path class  
     Section 27.5: Sample extending long to render a human readable string  
     Section 27.6: Sample extending Java 8 Temporal classes to render an ISO formatted string  
     Section 27.7: Using extension functions to improve readability  
     Section 27.8: Extension functions to Companion Objects (appearance of Static functions)  
     Section 27.9: Extensions for easier reference View from code  
    Chapter 28: DSL Building
     Section 28.1: Infix approach to build DSL  
     Section 28.2: Using operators with lambdas  
     Section 28.3: Overriding invoke method to build DSL  
     Section 28.4: Using extensions with lambdas  
    Chapter 29: Idioms
     Section 29.1: Serializable and serialVersionUid in Kotlin  
     Section 29.2: Delegate to a class without providing it in the public constructor  
     Section 29.3: Use let or also to simplify working with nullable objects  
     Section 29.4: Use apply to initialize objects or to achieve method chaining  
     Section 29.5: Fluent methods in Kotlin  
     Section 29.6: Filtering a list  
     Section 29.7: Creating DTOs (POJOs/POCOs)  
    Chapter 30: RecyclerView in Kotlin
     Section 30.1: Main class and Adapter  
    Chapter 31: logging in kotlin
     Section 31.1: kotlin.logging  
    Chapter 32: Exceptions
     Section 32.1: Catching exception with try-catch-finally  
    Chapter 33: JUnit
     Section 33.1: Rules  
    Chapter 34: Kotlin Android Extensions
     Section 34.1: Using Views  
     Section 34.2: Configuration  
     Section 34.3: Painful listener for getting notice, when the view is completely drawn now is so simple and awesome with Kotlin's extension  
     Section 34.4: Product flavors  
    Chapter 35: Kotlin for Java Developers
     Section 35.1: Declaring Variables  
     Section 35.2: Quick Facts 
     Section 35.3: Equality & Identity  
     Section 35.4: IF, TRY and others are expressions, not statements  
    Chapter 36: Java 8 Stream Equivalents
     Section 36.1: Accumulate names in a List  
     Section 36.2: Collect example #5 - find people of legal age, output formatted string  
     Section 36.3: Collect example #6 - group people by age, print age and names together  
     Section 36.4: Different Kinds of Streams #7 - lazily iterate Doubles, map to Int, map to String, print each  
     Section 36.5: Counting items in a list after filter is applied  
     Section 36.6: Convert elements to strings and concatenate them, separated by commas  
     Section 36.7: Compute sum of salaries of employee  
     Section 36.8: Group employees by department  
     Section 36.9: Compute sum of salaries by department  
     Section 36.10: Partition students into passing and failing  
     Section 36.11: Names of male members  
     Section 36.12: Group names of members in roster by gender  
     Section 36.13: Filter a list to another list  
     Section 36.14: Finding shortest string a list 
     Section 36.15: Different Kinds of Streams #2 - lazily using first item if exists  
     Section 36.16: Different Kinds of Streams #3 - iterate a range of Integers  
     Section 36.17: Different Kinds of Streams #4 - iterate an array, map the values, calculate the average  
     Section 36.18: Different Kinds of Streams #5 - lazily iterate a list of strings, map the values, convert to Int, find max  
     Section 36.19: Different Kinds of Streams #6 - lazily iterate a stream of Ints, map the values, print results  
     Section 36.20: How streams work - filter, upper case, then sort a list  
     Section 36.21: Different Kinds of Streams #1 - eager using first item if it exists  
     Section 36.22: Collect example #7a - Map names, join together with delimiter  
     Section 36.23: Collect example #7b - Collect with SummarizingInt  
    Chapter 37: Kotlin Caveats
     Section 37.1: Calling a toString() on a nullable type  
    Appendix A: Configuring Kotlin build
     Section A.1: Gradle configuration  
     Section A.2: Using Android Studio  
     Section A.3: Migrating from Gradle using Groovy script to Kotlin script  

    25. Modern Android 13 Development Cookbook By Madona S. Wambua

    26. Faisal Z. Android Debugging by Tutorials 2022

    27. Wambua M. Modern Android 13 Development Cookbook 2023

    28. Jetpack Compose 1.4 Essentials

    29. Han Q. The Android Malware Handbook. Detection...Analysis by Human..Machine 2023

    30. Hacking Your Mobile Device Android Hacked Iphone Hacked Camera Hacked Ethical Hacking

    25. 50 Android Hacks

    1. Android App Development For Beginners Make a full app!

    • 1. Getting Started (8 video)
    • 2. Build the app! (6 video)

    2. Android App Development with Java Essential Training - Lynda.com

    • 00 Introduction (4 video)
    • 01 Getting Started (8 video)
    • 02 Android App Fundamentals (9 video
    • 03 The User Interface and Controls (8 video
    • 04 Graphics and Styling (4 video
    • 05 Supporting Multiple Screens (2 video
    • 06 Animation and Graphics (3 video
    • 07 Menus and Dialogs (6 video
    • 08 Notifications and Toast (2 video
    • 09 Working with Media (3 video
    • 10 Preferences and Data Storage (5 video
    • 11 Locations and Maps (2 video
    • 12 Creating a Home Screen Widget (2 video
    • 13 Publishing Your App (4 video
    • 14 Conclusion (2 video
    • Exercise Files

    3. Android Apps with Kotlin Build Your First App

    • 01.Course Overview (1 video)
    • 02.Creating and Running a Kotlin App with Android Studio (8 video)
    • 03.Describing Types with Kotlin (13 video)
    • 04.Understanding Activities and Activity Layout Interaction (11 video)
    • 05.Developing a Multi-screen User Experience (12 video)
    • 06.Using Options Menus and Action Bar Actions (13 video)
    • 07.Understanding Activity Lifecycle (12 video)
    • Exercise Files

    4. Android Developer's Portfolio Masterclass - Build real Apps

    • 1. Getting Started (4 video)
    • 2. Build Your Portfolio App - Brand Yourself as Android Developer (9 video)
    • 3. Build Your Portfolio - Motivational App (9 video)
    • 4. Build Your Portfolio - Build and Android Game (9 video)
    • 5. Advanced Drawing on Screen (6 video)
    • 6. Build Your Portfolio - Build Pikasso - Doodlz App (9 video)
    • 7. Build Your Android Portfolio - Weather App (19 video)
    • 8. Build Your Portfolio - Android Sensors (8 video)
    • 9. Build Your Portfolio - Breathe App (8 video)
    • 10. BONUS Section - Java Refresher (9 video)
    • 11. Installing Android Studio - Setup Development Environment (3 video)
    • 12. BONUS II - More Courses by Paulo (19 video)

    5. Android Development Data Binding

    • 01 Simplify your data-driven layouts.mp4
    • 02 What you should know.mp4
    • 03 Getting set up.mp4
    • 04 What is data binding.mp4
    • 05 Doing things the old way.mp4
    • 06 Setting up your project.mp4
    • 07 Create binding layout.mp4
    • 08 Create databound activity.mp4
    • 09 The binding expression language.mp4
    • 10 Using binding expressions.mp4
    • 11 Challenge String concatenation expression.mp4
    • 12 Solution String concatenation expression.mp4
    • 13 Overview of observables.mp4
    • 14 Binding to observables.mp4
    • 15 Binding to ViewModels.mp4
    • 16 Using binding adapters.mp4
    • 17 Two-way binding syntax.mp4
    • 18 Using converters.mp4
    • 19 Challenge Color binding adapter.mp4
    • 20 Solution Color binding adapter.mp4
    • 21 Next steps.mp4

    6 .Android Fundamentals - Fragments

    • 01.Course Overview (1 video)
    • 02.Introduction (3 video)
    • 03.Adding the Fragment to an Activity (5 video)
    • 04.Exploring Fragment Lifecycle (5 video)
    • 05.Playing Around with Fragment Transactions (6 video)
    • 06.Sending Data to a Fragment from Parent Activity (6 video)
    • 07.Understanding Communication Flow from Fragment to Activity (5 video)
    • 08.Understanding Inter-fragment Communication (5 video)
    • 09.Enabling the Back Button with Backstack (6 video)
    • 10.Providing Stability to Fragment on Screen Rotation (8 video)

    7. Android Studio Essential Training

    • 01 Introduction (2 video)
    • 02 1 Getting Started (9 video)
    • 03 2 Set Up the Development Environment (5 video)
    • 04 3 Use Software Version Control (4 video)
    • 05 4 Build Run and Debug Apps (6 video)
    • 06 5 Explore the User Interface (4 video)
    • 07 6 Manage Project Dependencies (3 video)
    • 08 7 Edit Code and Layout Files (8 video)
    • 09 Conclusion (1 video)
    • Ex_Files_Android_Studio_EssT.zip

    8. android-studio-from-scratch-build-mobile-apps

    • 01 Introduction to Android (5 video)
    • 02 The first application (11 video)
    • 03 ToDoEkspert - process of creating application (13 video)
    • 04 Saving and sending data - HTTP and DB (20 video)

    9. Android.App.Development.with.Java.Essential.Training

    • 00 Introduction (4 video)
    • 01 Getting Started (8 video)
    • 02 Android App Fundamentals (9 video)
    • 03 The User Interface and Controls (6 video)
    • 04 Graphics and Styling (4 video)
    • 05 Supporting Multiple Screens (2 video)
    • 06 Animation and Graphics (3 video)
    • 07 Menus and Dialogs (5 video)
    • 08 Notifications and Toast (2 video)
    • 09 Working with Media (3 video)
    • 10 Preferences and Data Storage (5 video)
    • 11 Locations and Maps (2 video)
    • 12 Creating a Home Screen Widget (2 video)
    • 13 Publishing Your App (4 video)
    • 14 Conclusion (2 video)
    • Exercise Files

    10 .Androis Video Course

    • 1. Starting to develop.. About new Android Studio version...mp4
    • 2. Splash Screen (Entrance Screen).mp4
    • 3. Adding main tabs...mp4
    • 4. Menu icons.mp4
    • 5. Floating button.mp4

    11. Become a Expert In Java Go Beginner To Advance

    • 1. Introduction (28 video)
    • 2. Java Object Oriented (18 video)
    • 3. Java Data Structure (13 video)
    • 4. Java Swing (38 video)
    • 5. Java Layout Manager (6 video)
    • 6. Make Apps With Java Swing (2 video)

    12. Complete Android Development with Kotlin Masterclass

    • 1. Introduction (4 video)
    • 2. How to Get the Needed Tools (3 video)
    • 3. Build Your First Android App in Kotlin(Hello World App) (4 video)
    • 4. Create a Happy New Year Card App (8 video)
    • 5. Challenge - Create a Happy Birthday Card (3 video)
    • 6. Introduction to Graphics and Layout Scaling (4 video)
    • 7. Mail App (7 video)
    • 8. Dice App(Introduction to Kotlin) (6 video)
    • 9. Kotlin for Beginners Part1 (Variables & Data Types) (9 video)
    • 10. Kotlin for Beginners Part2(Logical & Comparison Operators) (3 video)
    • 11. Kotlin for Beginners Part3(Control Flows & Null-Safety) (8 video)
    • 12. Calculator App (7 video)
    • 13. Guess My Number Game App (7 video)
    • 14. Challenge Create a BMI App (4 video)
    • 15. NumberList App(Playing Audio) (8 video)
    • 16. Widget Practice (8 video)
    • 17. Kotlin for Intermediates(Part1) (3 video)
    • 18. Kotlin for Intermediates(Part2) (7 video)
    • 19. Dictionary App (14 video)
    • 20. News App(Challenge) (7 video)
    • 21. Introduction to ConstraintLayout (6 video)
    • 22. Fitness App - Fragments & Navigation Component (8 video)
    • 23. Advanced Kotlin (4 video)
    • 24. My Diary App - SQLite & RecyclerView (14 video)
    • 25. Movie Rental App - Advance ConstraintLayout (6 video)
    • 26. MusicPlayer App - MediaPlayer , Read from Local Storage & Interface (8 video)
    • 27. BookStore App(ViewPager,Grid,NavigationDrawer,Toolbar,Intents&SharedPreference ) (16 video)
    • 28. Chat App(Firebase, Google SignIn, RealTime Database, Storage, Cloud Messaging) (13 video)
    • 29. Animation(ConstraintSet, PlaceHolder & Circular Positioning) (6 video)
    • 30. Firebase Machine Learning (7 video)

    13. Complete Firebase Tutorial for Android App Development

    • 1. Introduction.mp4
    • 2. What is Firebase.mp4
    • 3. Firebase setup.mp4
    • 4. Note Application using Firebase.mp4
    • 5. Authentication using firebase.mp4
    • 6. Realtime Database.mp4
    • 7. FCM.mp4
    • 8. Crashlytics.mp4
    • 9. BONUS.mp4

    14. Create Android Application using Block Programming

    • 1. Introduction (7 video)
    • 2. Introduction to MIT App Inventor Design Interface (9 video)
    • 3. Complex User Interface components and Block Code Deep Dive (5 video)
    • 4. Develop Tic Tac Toe Game (9 video)

    15. Fashion App From Sketch to Android Studio

    • 01 Warming Up (2 video)
    • 02 Sketch Class (8 video)
    • 03 Android XML Class (5 video)
    • 04 Android Java Class (5 video)
    • 05 Developer Short-Class (2 video)

    16. Implementing Picture In Picture Mode In Android

    • (7 video)

    17. Kotlin for Android & Java Developers

    • 1 - Introduction (3 video)
    • 2 - Get Ready (5 video)
    • 3 - Kotlin Basics (16 video)
    • 4 - Functional Programming (16 video)
    • 5 - Object-Orientation in Kotlin (23 video)
    • 6 - Kotlin for Android -- Fundamentals (6 video)
    • 7 - Kotlin for Android -- Implement a RecyclerView (6 video)
    • 8 - Kotlin for Android -- Let Users Create Habits (8 video)
    • 9 - Kotlin for Android -- Use SQLite the Kotlin Way! (12 video)

    18. Kotlin for Android & Java Developers_ Clean Code on Android

    • 1 - Introduction (3 video)
    • 2 - Get Ready (5 video)
    • 3 - Kotlin Basics (13 video)
    • 4 - Functional Programming (16 video)
    • 5 - Object-Orientation in Kotlin (22 video)
    • 6 - Fundamentals (6 video)
    • 7 - Implement a RecyclerView (6 video)
    • 8 - Let Users Create Habits (9 video)
    • 9 - Use SQLite the Kotlin Way! (11 video)

    19. Modern Android app using Kotlin, MVVM, Dagger2, RxJava &more

    • 1. Introduction (2 video)
    • 2. MVVM Architecture (7 video)
    • 3. Retrofit (6 video)
    • 4. Dependency Injection (4 video)
    • 5. Unit Testing (5 video)
    • 6. Conclusion

    20. Python For Android Hacking Crash Course Trojan Perspective

    • 01 Start Here - Watch me first (5 video)
    • 02 Home Lab Setup (4 video)
    • 03 Building a Simple GUI Interface (4 video)
    • 04 Your First SSH Botnet (21 video)
    • 05 Breaking Bad on Rooted Devices (8 video)

    21. The Complete Android & Java Developer Course - Build 21 Apps

    • 1. Introduction (2 video)
    • 2. Windows PC - Install and Setup Software for Android App Development (3 video)
    • 3. MAC OSX - Install and Setup (2 video)
    • 4. Android Resources and Theoretical Guidelines ( video)
    • 5. Learn Java Programming From Scratch! (12 video)
    • 6. Java Advanced Concepts (8 video)
    • 7. Java Advanced Concepts 2 - Inheritance and Data Structures (6 video)
    • 8. Java Programming Advanced Concepts - Inheritance and Data Structure (1 video)
    • 9. Android App Development Tools (9 video)
    • 10. Designing App Visuals - How To Use Views in AndroidJava Development (8 video)
    • 11. Designing App Visuals 2 (11 video)
    • 12. Debugging (3 video)
    • 13. What Are Activities And How to work with Navigation - Java Android (8 video)
    • 14. Recycler Views - Listviews alternative - Introduction (7 video)
    • 15. User Interface - Android Layouts - XML (5 video)
    • 16. Android Media Player (11 video)
    • 17. Storage in Android - Shared Preferences, Internal Storage, SQLite Database (9 video)
    • 18. Android Sqlite Database - Part 2 - Build a Grocery List App (14 video)
    • 19. Storage in Android 2 - Shared Preferences, Internal Storage, SQLite Database (5 video)
    • 20. Connecting to the World - Introduction to HTTP Requests - Consuming JSON Data (15 video)
    • 21. Firebase - Cloud Based Application Development (19 video)
    • 22. Where Am I - Using Google Maps and Geocoding and Location Manager (8 video)
    • 23. Let's Build a Map-Based App - Earthquake Watcher (11 video)
    • 24. Let's Build a Messaging App With Parse (What'sApp Clone) (11 video)
    • 25. UploadPublish Your App to Google Play (6 video)
    • 26. Bonus (5 video)
    • 27. Bonus Material and Archived Content - Still Valid and Useful (4 video)
    • 28. Mac Setup (5 video)
    • 29. Learn Java Programming From Scratch (6 video)
    • 30. Java Advanced Concepts (8 video)
    • 31. Java Advanced Concepts 2 - Inheritance and Data Structures (9 video)
    • 32. Let's Start Android Development (8 video)
    • 33. Designing the Interface - How to User Views in Android (7 video)
    • 34. Android User Interface Part 2 (7 video)
    • 35. Introduction to Activities in Android (9 video)
    • 36. RecyclerView (Alternative to Listviews) - Core Android Components (7 video)
    • 37. User Interface - Android Layouts XLM Layouts (8 video)
    • 38. Android Media - Images, Animations, Sounds, Music (10 video)
    • 39. Android Storage - Shared Preferences, Internal Storage, Sqlite Database (8 video)
    • 40. Old-Connecting to the World - Connecting to the Internet (7 video)

    22. The Complete Android Developer Course - Build 14 Apps

    • 01 What Does The Course Cover (3 video)
    • 02 Introduction To Android Studio (12 video)
    • 03 Java Deep Dive (11 video)
    • 04 Media Images, Video and Sound (11 video)
    • 05 Advanced Android Features (14 video)
    • 06 Maps Geolocation (11 video)
    • 07 Permanent Data Storage (11 video)
    • 08 Instagram Clone (12 video)
    • 09 Uber Clone (8 video)
    • 10 Flappy Bird Clone (9 video)
    • 11 The Extras (7 video)
    • 12 Android Wear Mini-Course (9 video)
    • 13 Submitting Your App To Google Play (2 video)
    • 14 Setting Up A Marketing Website (4 video)
    • 15 Twitter Clone (6 video)
    • 16 Snapchat Clone (6 video)
    • 17 Where do you go from here

    23. The Complete Android Developer Course 2019

    • 1. Introduction (5 video)
    • 2. Kotlin For Android From Zero to Hero (18 video)
    • 3. Start Work With Android studio (8 video)
    • 4. Android Studio With KotlinBasic (3 video)
    • 5. Android Design section (7 video)
    • 6. Images in Android (3 video)
    • 7. Understand the World of Android (7 video)
    • 8. Animation in Android (3 video)
    • 9. Audios in Android (2 video)
    • 10. Videos in Android (3 video)
    • 11. Android Quiz App (2 video)
    • 12. Android Code Editor (4 video)
    • 13. Android Libraries (6 video)
    • 14. Android List View (6 video)
    • 15. Build an App With ListView (5 video)
    • 16. Advanced Android Features (6 video)
    • 17. Errors in Android (8 video)
    • 18. Android RecylcerView (5 video)
    • 19. Build an App With RecyclerView (6 video)
    • 20. Advanced Project with ReyclcerView and Custom Functionality (6 video)
    • 21. Searching Skills in Android (Better Programmer Mind) (8 video)
    • 22. Fragments With Advanced Functionality (8 video)
    • 23. Advanced Fragment With ViewPager in Android (3 video)
    • 24. SqlLite Database in Android (7 video)
    • 25. Git and Github in Android VCS (8 video)
    • 26. Android With Google Firebase (15 video)
    • 27. Online School With Firebase (9 video)
    • 28. Android Resourses (7 video)
    • 29. Android Quizzes Fro Me ( video)
    • 30. Let us Start With Java For Android (7 video)
    • 31. Android Motivation Videos (3 video)
    • 32. Thank You And Good Bye

    24. The Complete Android Kotlin Developer Course

    • 01 Introduction and Setup the environment (3 video)
    • 02 Variables (8 video)
    • 03 Operations and Priorities (6 video)
    • 04 Decision Making (7 video)
    • 05 Loop Control (5 video)
    • 06 Collections and Strings (8 video)
    • 07 Functions (4 video)
    • 08 Object Oriented Programming (17 video)
    • 09 StorageFiles (3 video)
    • 10 Multi Threading (2 video)
    • 11 Android Startup (2 video)
    • 12 Find my age App (4 video)
    • 13 Complete Tic Tac toy game (7 video)
    • 14 Calculator app (9 video)
    • 15 Pockemon game in Android (7 video)
    • 16 Zoo App (7 video)
    • 17 Restaurant menu (4 video)
    • 18 Web services Find City Sunrise time App (6 video)
    • 19 Sqlite database My Notes App (12 video)
    • 20 introduction To firebase (2 video)
    • 21 Firebase Online Tic tac toy game (11 video)
    • 22 Firebase Twitter and Facebook App (11 video)
    • 23 Media Player for play online and Local songs App (5 video)
    • 24 Complete Alarm app (8 video)
    • 25 Sensors Apps (2 video)
    • 26 Firebase Find my phone App (17 video)
    • 27 Twitter App using MySql and PHP web service (21 video)
    • 28 Build Web Services with Node.js and C ( 2video)
    • 29 Publish App to Store (3 video)

    25. The Comprehensive 2019 Android Development Masterclass

    • 1. Welcome (1 video)
    • 2. Install Android Studio on Windows Machine (2 video)
    • 3. Introduction (2 video)
    • 4. Deep Dive into Java Programming Language (18 video)
    • 5. Introduction to Object Oriented Programming in Java (6 video)
    • 6. Java Inheritance (5 video)
    • 7. Java Data Structures (5 video)
    • 8. Android Development - Let the fun Begin! (9 video)
    • 9. For the Curious - Android Ins and Outs (3 video)
    • 10. Build a Quiz App - MVC Architecture (7 video)
    • 11. CHALLENGE Improve the Quiz App (1 video)
    • 12. CHALLENGE SOLUTION Quiz App Improvements (2 video)
    • 13. Understanding Android Activities and Life Cycles (7 video)
    • 14. Connecting our Apps to the Web - JSON, API's, Network Services, Parsing JSON (6 video)
    • 15. Build a Trivia App (11 video)
    • 16. Running Android Apps on Physical Device (1 video)
    • 17. Persistence in Android - Shared Preferences (2 video)
    • 18. CHALLENGE - Improve Trivia app ( video)
    • 19. CHALLENGE SOLUTION - Improve Trivia app (8 video)
    • 20. Persistence in Android - Database (8 video)
    • 21. Android Listviews and RecyclerView Widgets (10 video)
    • 22. Build a Baby Needs App (15 video)
    • 23. Android ROOM - Alternative Database (10 video)
    • 24. Android Location and Maps (13 video)
    • 25. Build an EarthQuake App (10 video)
    • 26. Android Media - Playing Sounds and Videos (10 video)
    • 27. Android Animations (2 video)
    • 28. Android Material Design and Themes (8 video)
    • 29. Understanding Android Intents (4 video)
    • 30. Android Fragments - An Introduction (11 video)
    • 31. Introduction to Realtime Databases - Firebase and Firestore (12 video)
    • 32. Build a Journal App with Firestore (23 video)
    • 33. Drawing on Canvas in Android (6 video)
    • 34. Android Machine Learning ML Kit - Face Detection (12 video)
    • 35. Android Vocabulary - Tools and Resources (1 video)
    • 36. Learn to Help Yourself as an Android Developer (1 video)
    • 37. Monetizing Your Android Apps (2 video)
    • 38. Creating Launcher Icons (1 video)
    • 39. Publishing Your Apps on Google Play (10 video)
    • 40. The App Development Process (1 video)
    • 41. What's Next
    • 42. Bonus)

    <00>  <01>  <02>  <03>  <04>  <05>  <06>  <07>  <08>  <09>  <10>  <11>  <12>  <13>  <14>  <15>  <16>  <17>  <18>  <19>  <20>  <21>  <22>  <23