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 Errata2. 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 Summary3. 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 Summary4. 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 Summary5. 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 Summary6. 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 Summary7. 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 Summary8. 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 Summary9. 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 Summary10. 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 Summary11. 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 Summary12. 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 Summary13. 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 Summary14. 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 Summary15. 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 Summary16. 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 Summary17. 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 Summary18. 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 Summary19. 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 Summary20. 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 Summary21. 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 Summary22. 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 Summary23. 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 Summary24. 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 Summary25. 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 Summary26. 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 Summary27. 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 Summary28. 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 Summary29. Manual XML Layout Design in Android Studio
29.1 Manually Creating an XML Layout 29.2 Manual XML vs. Visual Layout Design 29.3 Summary30. 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 Summary31. 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 Summary32. 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 Summary33. 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 Summary34. 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 Summary35. 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 Summary36. 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 Summary37. 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 Summary38. 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 Summary39. 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 Summary40. 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 Summary41. An Android Jetpack LiveData Tutorial
41.1 LiveData - A Recap 41.2 Adding LiveData to the ViewModel 41.3 Implementing the Observer 41.4 Summary42. 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 Summary43. 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 Summary44. 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 Summary45. 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 Summary46. 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 Summary47. 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 Summary48. 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 Summary49. 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 Summary50. 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 Summary51. 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 Summary52. 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 Summary53. 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 Summary54. Working with the RecyclerView and CardView Widgets
54.1 An Overview of the RecyclerView 54.2 An Overview of the CardView 54.3 Summary55. 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 Summary56. A Layout Editor Sample Data Tutorial
56.1 Adding Sample Data to a Project 56.2 Using Custom Sample Data 56.3 Summary57. 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 Summary58. 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 Summary59. 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 Summary60. 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 Summary61. 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 Summary62. 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 Summary63. 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 Summary64. 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 Summary65. 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 Summary66. 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 Summary67. 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 Summary68. 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 Summary69. 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 Summary70. 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 Summary71. 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 Summary72. 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 Summary73. 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 Summary74. 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 Summary75. 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 Summary76. 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 Summary77. 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 Summary78. 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 Summary79. 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 Summary80. 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 Summary81. 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 Summary82. 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 Summary83. 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 Summary84. 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 Summary85. 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 Summary86. 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 Summary87. 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 Summary88. 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 Summary89. 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 Summary90. 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 Summary91. 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 Summary92. 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 Summary93. 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 YourDevice Starts The Penguin Down Below How Your Android Device Starts Bootstrapping Adding a Custom Bootloader Understanding the Bootloader Process Custom Recoveries: The Holy GrailChapter 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 Exploits Native Fastboot Flash Scripted and One-Click Methods Rooting Two Devices Nexus One HTC Thunderbolt The Root of It AllChapter 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 Concatenation BusyBox: Giving the Penguin Back Its Power The dd Command The echo Command The md5sum CommandChapter 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 APKManager Android SDK Eclipse A ROM of Your Choice 7-Zip Paint.NET Update.zip Creator Amend2Edify The Editing Process Walkthrough for Creating Theme Files Walkthrough for Creating a Flashable ZIP FileChapter 6: You've Become Superuser: Now What?
Popular Multi-Device Custom ROMs CyanogenMod Android Open Kang Project VillainROM Kernel Tweaks Backlight Notifications Voodoo Enhancements Performance and Battery Life Tweaks Root Applications SetCPU Adfree Android Chainfire 3D Titanium Backup Part II: Manufacturer Guidelines and Device-Specific GuidesChapter 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 ApplicationChapter 8: Nexus One: An Unlockable Device
Root Methods Available Resources Required for this Walkthrough Walkthrough Placing the Nexus One in Fastboot Mode Flashing a Boot Partition Getting Full Root Access Installing a Custom RecoveryChapter 9: HTC ThunderBolt: A Tightly Locked Device
Root Methods Available Resources Required for this Walkthrough 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 FirmwareChapter 10: Droid Charge: Flashing with ODIN
Resources Required for this Walkthrough Walkthrough Connecting the Device to ODIN Flashing the Device TroubleshootingChapter 11: Nexus S: An Unlocked Device
Connecting the Device to a PC Resources Required for this Walkthrough Walkthrough Unlocking the Device Flashing the Device with a Recovery Flashing the Device with the SuperUser applicationChapter 12: Motorola Xoom: An Unlocked Honeycomb Tablet
Resources Required for this Walkthrough Walkthrough Pushing the Root File to the SD Card Unlocking the Xoom Flashing the Device with a Recovery Flashing the Device with a Universal RootChapter 13: Nook Color: Rooting with a Bootable SD Card
Resources Required for this Walkthrough Walkthrough Creating a Bootable SD Card Booting the Device from the SD Card Making the Device More UsableAppendix 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 SummaryChapter 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 SummaryChapter 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 SummaryChapter 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 SummaryChapter 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 SummaryChapter 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 SummaryChapter 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 SummaryChapter 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 SummaryChapter 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 SummaryChapter 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 SummaryChapter 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 SummaryChapter 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 SummaryChapter 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 aChapter 14: Android Content Providers: Datastore ConceptsService: Background Processing Services Configure AmbientAudioService: Play Audio Starting a Service: Using startService( ) Summary
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 Summary
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 Versioning 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 Post-production Other publishing methods Key points Where to go from here?• Chapter 5: Permissions
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 Challenge Key points Where to go from here?• Chapter 7: Optimizing App Size & Obfusticating the APK
Why is optimization important? Terminology 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
WHAT IS ANDROID STUDIO MAJOR FEATURES The User Interface Tool Windows Navigation Style and Formatting Version Control Basics Gradle Build System Build Variants Multiple Android Application Package Support 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 A BRIEF HISTORY OF ANDROID STUDIO ADVANTAGES OF ANDROID DEVELOPMENT DISADVANTAGES OF ANDROID DEVELOPMENT EXPLORING ANDROID STUDIOChapter 2 ◾ Getting Started with Android
Studio INSTALLATION AND CONFIGURATION Windows Mac Linux Chrome OS Customizing Your VM Options Customizing Your IDE Properties Configuring the IDE for Low-Memory Machines Setting the JDK Version Proxy Settings Android Plugin for Gradle HTTP Proxy Settings THE USE OF GRADLE BUILD SCRIPTS Sensible Defaults Dependencies Build Variants Manifest Entries ProGuard Support Changing Default Source Set Configurations Managing Libraries and Dependencies Creating Different Versions of Your App Configuring Instrumentation Manifest Settings Configuring Gradle Test Options WORKING WITH PROJECTS Modules 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 ModulesChapter 3 ◾ Android Studio Basics
ANDROID STUDIO UI TERMS AND FOLDERS Splitting the Action Bar Hiding the Action Bar Overlaying the Action Bar LAYOUTS 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 STRINGS String String Array Quantity Strings (Plurals) Handling Special Characters Formatting Strings VIEWS 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 AccessibilityChapter 4 ◾ Android Studio Tools
THE SDK MANAGER 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 Snapshots Using the SDK Independently THE AVD MANAGER System Images Storage Area Skin Creating an AVD Creating a Hardware Profile THE NAVIGATION EDITOR Gradle Plugins Navigation Graph Action NavHostFragment NavigationController SafeArgs GENERATING A JAVADOC 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 TroubleshootChapter 5 ◾ Debugging
RUNNING AND DEBUGGING Debug Window Frames Inspect Variables View and Change Resource Value Display Format About Run/Debug Configurations Default Run/Debug Configuration Symbol Directories LLDB Startup Commands LLDB Post Attach Commands Logging: Target Channels Miscellaneous Tab ANDROID DEVICE MONITOR Dalvik Debug Monitor Server (DDMS) Traceview Systrace Hierarchy Viewer Pixel Perfect Network Traffic Tool IMPORTANT SHORTCUTS AND BUTTON TECHNIQUES General Navigating and Searching Within Studio Viewing Layouts Design Tools: Layout Editor Design Tools: Navigation Editor Writing Code Build and Run Debugging Refactoring Version Control/Local History Compile Options Link Options Environment Variables Android Studio Configuration Environment Variables Emulator Environment Variables adb Environment Variables ADB Logcat Environment Variables How to Set Environment Variables APPRAISAL, INDEX
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 BuildSrc Shared build file Android build file Find Time Business logic Challenge 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 Challenge Key points• Chapter 7: App Architecture
Design patterns Sharing business logic Creating Reminders section Sharing tests and UI Challenge Key points• Chapter 8: Testing
Setting up the dependencies Writing tests for RemindersViewModel Writing tests for Platform UI tests Challenge 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 Testing Key points Where to go from here?• Chapter 10: Data Persistence
Key-Value storage Database Challenge 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 Testing Challenges 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 Plugins Retrieving content Adding headers to your request Uploading files Testing Challenge 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 Challenge Key points Where to go from here?• Chapter 14: Creating Your KMP Library
Migrating an existing feature to Multiplatform Publishing your KMP library Challenges 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 Generics • Variables and Functions Variables Lambdas Extension Functions • Classes Class Initialization Properties lateinit Properties Lazy Properties Delegates Companion Objects Data Classes Enum Classes Sealed Classes Visibility Modifiers Summary• 2. The Kotlin Collections Framework
• Collection Basics Java Interoperability Mutability Overloaded Operators Creating Containers • Functional Programming Functional Versus Procedural: A Simple Example Functional Android • Kotlin Transformation Functions The Boolean Functions Filter Functions Map flatMap Grouping Iterators Versus Sequences • An Example The Problem The Implementation Summary• 3. Android Fundamentals
• The Android Stack Hardware Kernel System Services Android Runtime Environment Applications • The Android Application Environment Intents and Intent Filters Context • Android Application Components: The Building Blocks The Activity and Its Friends Services Content Providers Broadcast Receivers • Android Application Architectures MVC: The Foundation Widgets The Local Model • Android Patterns Model—View—Intent Model—View—Presenter Model—View—ViewModel Summary• 4. Concurrency in Android
• Thread Safety Atomicity Visibility The Android Threading Model Dropped Frames Memory Leaks • Tools for Managing Threads Looper/Handler Executors and ExecutorServices • Tools for Managing Jobs JobScheduler WorkManager Summary• 5. Thread Safety
An Example of a Thread Issue • Invariants Mutexes Thread-Safe Collections Thread Confinement Thread Contention Blocking Call Versus Nonblocking Call Work Queues Back Pressure Summary• 6. Handling Concurrency Using Callbacks
Example-of-Purchase Feature • Creating the App View-Model View Implement the Logic Discussion Limitations of the Threading Model Summary• 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 Summary• 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 Supervision supervisorScope Builder Parallel Decomposition Automatic Cancellation • Exception Handling Unhandled Versus Exposed Exceptions Exposed Exceptions Unhandled Exceptions Summary 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 TL;DR Limitations of Channels Channels Are Hot Summary• 10. Flows
• An Introduction to Flows A More Realistic Example Operators 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 Usage • 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 Summary• 11. Performance Considerations with Android Profiling Tools
• Android Profiler Network Profiler CPU Profiler Energy Profiler Memory Profiler Detecting Memory Leaks with LeakCanary Summary• 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 Summary
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 LineChapter 2: Basics of Kotlin
Section 2.1: Basic examplesChapter 3: Strings
Section 3.1: String Equality Section 3.2: String Literals Section 3.3: Elements of String Section 3.4: String TemplatesChapter 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 ArrayChapter 5: Collections
Section 5.1: Using list Section 5.2: Using map Section 5.3: Using setChapter 6: Enum
Section 6.1: Initialization Section 6.2: Functions and Properties in enums Section 6.3: Simple enum Section 6.4: MutabilityChapter 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 FunctionsChapter 8: Vararg Parameters in Functions
Section 8.1: Basics: Using the vararg keyword Section 8.2: Spread Operator: Passing arrays into vararg functionsChapter 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 enumsChapter 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 iterationChapter 11: Ranges
Section 11.1: Integral Type Ranges Section 11.2: downTo() function Section 11.3: step() function Section 11.4: until functionChapter 12: Regex
Section 12.1: Idioms for Regex Matching in When Expression Section 12.2: Introduction to regular expressions in KotlinChapter 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 variableChapter 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 operatorChapter 15: Class Delegation
Section 15.1: Delegate a method to another classChapter 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 methodsChapter 17: Visibility Modifiers
Section 17.1: Code Sample Chapter 18: Generics Section 18.1: Declaration-site variance Section 18.2: Use-site varianceChapter 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 ImplementationsChapter 20: Singleton objects
Section 20.1: Use as replacement of static methods/fields of java Section 20.2: Use as a singletonChapter 21: coroutines
Section 21.1: Simple coroutine which delay's 1 second but not blocksChapter 22: Annotations
Section 22.1: Meta-annotations Section 22.2: Declaring an annotationChapter 23: Type aliases
Section 23.1: Function type Section 23.2: Generic typeChapter 24: Type-Safe Builders
Section 24.1: Type-safe tree structure builderChapter 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 boilerplateChapter 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 classChapter 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 codeChapter 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 lambdasChapter 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 AdapterChapter 31: logging in kotlin
Section 31.1: kotlin.loggingChapter 32: Exceptions
Section 32.1: Catching exception with try-catch-finallyChapter 33: JUnit
Section 33.1: RulesChapter 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 flavorsChapter 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 statementsChapter 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 SummarizingIntChapter 37: Kotlin Caveats
Section 37.1: Calling a toString() on a nullable typeAppendix 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)
- (2019) Android books
- (2021) Android Masterclass lecture from Paulo Dictone
- (2020) My Android Handbook
- (2020) Kotlin Syntax
- (2021) How to debug Android frontend
- (2022) Android ADB
- (2019) Android Studio Requirements (vmx|sse|svm CPU flags)
- (2020) Up and running Android studio
- (2021) How to build application server based on push notification from Firebase
- (2021) Retrofit test with interceptor, clear communication and show data to TextView
- (2020) https://developers.google.com/admob/android/quick-start
Comments (
)
Link to this page:
//www.vb-net.com/AndroidBook/Index.htm
<SITEMAP> <MVC> <ASP> <NET> <DATA> <KIOSK> <FLEX> <SQL> <NOTES> <LINUX> <MONO> <FREEWARE> <DOCS> <ENG> <CHAT ME> <ABOUT ME> < THANKS ME> |