book

How to Build Android Apps with Kotlin

Name: How to Build Android Apps with Kotlin
ISBN: 9781838984113

by Alex Forrester, Eran Boudjnah, Alexandru Dumbravan, Jomar Tigcal, Gaurav Chandorkar, Kaushal Dhruw

February 2021

Intermediate to advanced

794 pages

15h 5m

English

Packt Publishing

Read now

Unlock full access

How to Build Android Apps with Kotlin
Preface
About the BookABOUT THE AUTHORSAudienceAbout the ChaptersConventionsBefore You BeginMinimum Hardware RequirementsSoftware RequirementsInstallation and SetupInstalling the Code BundleGet in touchPlease leave a review
1. Creating Your First App
IntroductionCreating an Android Project with Android StudioExercise 1.01: Creating an Android Studio Project for Your AppSetting Up a Virtual Device and Running Your AppExercise 1.02: Setting Up a Virtual Device and Running Your App on ItThe Android ManifestExercise 1.03: Configuring the Android Manifest Internet PermissionUsing Gradle to Build, Configure, and Manage App DependenciesProject-Level build.gradle fileApp-Level build.gradleExercise 1.04: Exploring how Material Design is used to theme an app Android Application StructureExercise 1.05: Adding Interactive UI Elements to Display a Bespoke Greeting to the UserAccessing Views in layout filesFurther Input ValidationActivity 1.01: Producing an App to Create RGB ColorsSummary
2. Building User Screen Flows
IntroductionThe Activity LifecycleExercise 2.01: Logging the Activity CallbacksSaving and Restoring the Activity StateExercise 2.02: Saving and Restoring the State in LayoutsExercise 2.03: Saving and Restoring the State with CallbacksActivity Interaction with IntentsExercise 2.04: An Introduction to IntentsExercise 2.05: Retrieving a Result from an Activity Intents, Tasks, and Launch ModesExercise 2.06: Setting the Launch Mode of an ActivityActivity 2.01: Creating a Login FormSummary
3. Developing the UI with Fragments
IntroductionThe Fragment LifecycleonAttachonCreateonCreateViewonViewCreatedonActivityCreatedonStartonResumeonPauseonStoponDestroyViewonDestroyonDetachExercise 3.01: Adding a Basic Fragment and the Fragment LifecycleExercise 3.02: Adding Fragments Statically to an ActivityStatic Fragments and Dual-Pane LayoutsExercise 3.03: Dual-Pane Layouts with Static FragmentsDynamic FragmentsExercise 3.04: Adding Fragments Dynamically to an ActivityJetpack NavigationExercise 3.05: Adding a Jetpack Navigation GraphActivity 3.01: Creating a Quiz on the PlanetsSummary
4. Building App Navigation
IntroductionNavigation OverviewNavigation DrawerExercise 4.01: Creating an App with a Navigation DrawerBottom NavigationExercise 4.02: Adding Bottom Navigation to Your AppTabbed NavigationExercise 4.03: Using Tabs for App NavigationActivity 4.01: Building Primary and Secondary App NavigationSummary
5. Essential Libraries: Retrofit, Moshi, and Glide
IntroductionFetching Data from a Network EndpointExercise 5.01: Reading Data from an APIParsing a JSON ResponseExercise 5.02: Extracting the Image URL from the API ResponseLoading Images from a Remote URLExercise 5.03: Loading the Image from the Obtained URLActivity 5.01: Displaying the Current WeatherSummary
6. RecyclerView
IntroductionAdding RecyclerView to Our LayoutExercise 6.01: Adding an Empty RecyclerView to Your Main ActivityPopulating the RecyclerViewExercise 6.02: Populating Your RecyclerViewResponding to Clicks in RecyclerViewExercise 6.03: Responding to ClicksSupporting Different Item TypesExercise 6.04: Adding Titles to RecyclerViewSwiping to Remove ItemsExercise 6.05: Adding Swipe to Delete FunctionalityAdding Items InteractivelyExercise 6.06: Implementing an "Add A Cat" ButtonActivity 6.01: Managing a List of ItemsSummary
7. Android Permissions and Google Maps
IntroductionRequesting Permissions from the UserExercise 7.01: Requesting the Location PermissionShowing a Map of the User's LocationExercise 7.02: Obtaining the User's Current LocationMap Clicks and Custom MarkersExercise 7.03: Adding a Custom Marker Where the Map Was ClickedActivity 7.01: Creating an App to Find the Location of a Parked CarSummary
8. Services, WorkManager, and Notifications
IntroductionStarting a Background Task Using WorkManagerExercise 8.01: Executing Background Work with the WorkManager ClassBackground Operations Noticeable to the User – Using a Foreground ServiceExercise 8.02: Tracking Your SCA's Work with a Foreground ServiceActivity 8.01: Reminder to Drink WaterSummary

9. Unit Tests and Integration Tests with JUnit, Mockito, and Espresso
IntroductionJUnitAndroid Studio Testing TipsMockitomockito-kotlinExercise 9.01: Testing the Sum of NumbersIntegration TestsRobolectricEspressoExercise 9.02: Double IntegrationUI Tests Exercise 9.03: Random Waiting TimesTest-Driven DevelopmentExercise 9.04: Using TDD to Calculate the Sum of NumbersActivity 9.01: Developing with TDDSummary
10. Android Architecture Components
IntroductionViewModel and LiveDataViewModelLiveDataExercise 10.01: Creating a Layout with Configuration ChangesExercise 10.02: Adding a ViewModelExercise 10.03: Sharing our ViewModel between the FragmentsExercise 10.04: Adding LiveDataRoomEntitiesDAOSetting Up the DatabaseThird-Party FrameworksExercise 10.05: Making a Little RoomCustomizing Life CyclesExercise 10.06: Reinventing the WheelActivity 10.01: Shopping Notes AppSummary
11. Persisting Data
IntroductionRepositoryExercise 11.01: Creating a RepositoryExercise 11.02: Adding Error HandlingPreferencesSharedPreferencesExercise 11.03: Wrapping SharedPreferencesPreferenceFragmentExercise 11.04: Customized SettingsFilesInternal StorageExternal StorageFileProviderStorage Access Framework (SAF)Asset FilesExercise 11.05: Copying FilesScoped StorageCamera and Media StorageExercise 11.06: Taking PhotosActivity 11.01: Dog DownloaderSummary
12. Dependency Injection with Dagger and Koin
IntroductionManual DIExercise 12.01: Manual InjectionDaggerConsumersProvidersConnectorsQualifiersScopesSubcomponentsExercise 12.02: Dagger InjectionDagger AndroidExercise 12.03: Changing InjectorsKoinExercise 12.04: Koin InjectionActivity 12.01: Injected RepositoriesActivity 12.02: Koin-Injected RepositoriesSummary
13. RxJava and Coroutines
IntroductionRxJavaObservables, Observers, and OperatorsSchedulersAdding RxJava to Your ProjectUsing RxJava in an Android ProjectExercise 13.01: Using RxJava in an Android ProjectModifying Data with RxJava OperatorsExercise 13.02: Using RxJava OperatorsCoroutinesCreating CoroutinesAdding Coroutines to Your ProjectExercise 13.03: Using Coroutines in an Android AppTransforming LiveDataExercise 13.04: LiveData TransformationsCoroutines Channels and FlowsRxJava versus CoroutinesActivity 13.01: Creating a TV Guide AppSummary
14. Architecture Patterns
IntroductionMVVMData BindingExercise 14.01: Using Data Binding in an Android ProjectRetrofit and MoshiThe Repository PatternExercise 14.02: Using Repository with Room in an Android ProjectWorkManagerExercise 14.03: Adding WorkManager to an Android ProjectActivity 14.01: Revisiting the TV Guide AppSummary
15. Animations and Transitions with CoordinatorLayout and MotionLayout
IntroductionActivity TransitionsAdding Activity Transitions through XMLAdding Activity Transitions through CodeStarting an Activity with an Activity TransitionExercise 15.01: Creating Activity Transitions in an AppAdding a Shared Element TransitionStarting an Activity with the Shared Element TransitionExercise 15.02: Creating the Shared Element TransitionAnimations with CoordinatorLayoutAnimations with MotionLayoutAdding MotionLayoutCreating Animations with MotionLayoutExercise 15.03: Adding Animations with MotionLayoutThe Motion EditorDebugging MotionLayoutModifying the MotionLayout PathExercise 15.04: Modifying the Animation Path with KeyframesActivity 15.01: Password GeneratorSummary
16. Launching Your App on Google Play
IntroductionPreparing Your Apps for ReleaseVersioning AppsCreating a KeystoreExercise 16.01: Creating a Keystore in Android StudioStoring the Keystore and PasswordsSigning Your Apps for ReleaseExercise 16.02: Creating a Signed APKAndroid App BundleExercise 16.03: Creating a Signed App BundleApp Signing by Google PlayCreating a Developer AccountUploading an App to Google PlayCreating a Store ListingApp DetailsGraphic AssetsPreparing the ReleaseAPK/App BundleRolling Out a ReleaseManaging App ReleasesRelease TracksFeedback Channel and Opt-in LinkInternal TestingClosed TestingOpen TestingStaged RolloutsManaged PublishingActivity 16.01: Publishing an AppSummary

Content preview from How to Build Android Apps with Kotlin

9. Unit Tests and Integration Tests with JUnit, Mockito, and Espresso

Overview

In this chapter, you will learn about testing on the Android platform and how to create unit tests, integration tests, and UI tests. You will see how to create each of these types of tests, analyze how it runs, and work with frameworks such as JUnit, Mockito, Robolectric, and Espresso. You will also learn about test-driven development, a software development practice that prioritizes tests over implementation. By the end of this chapter, you will be able to combine your new testing skills to work on a realistic project.

Introduction

In previous chapters, you learned about how to load background data and display it in the UI and how to set up API calls to retrieve ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

How to Build Android Apps with Kotlin - Second Edition

Publisher Resources

ISBN: 9781838984113

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

How to Build Android Apps with Kotlin

by Alex Forrester, Eran Boudjnah, Alexandru Dumbravan, Jomar Tigcal, Gaurav Chandorkar, Kaushal Dhruw

9. Unit Tests and Integration Tests with JUnit, Mockito, and Espresso

Introduction

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.