Xamarin.Forms Projects: Build multiplatform mobile apps and a game from scratch using C# and Visual Studio 2019

Cover
Title Page
Copyright and Credits
Dedication
About Packt
Foreword
Contributors
Table of Contents
Preface
Chapter 1: Introduction to Xamarin
Native applications
Xamarin and Mono
Code sharing
Using existing knowledge
Xamarin platforms
Xamarin.iOS
Xamarin.Android
Xamarin.Mac
Xamarin.Forms
The architecture of Xamarin.Forms 
Defining a UI using XAML
Defining a Label control
Creating a page in XAML
Creating a page in C#
XAML or C#?
Xamarin.Forms versus traditional Xamarin
When to use Xamarin.Forms
Setting up a development machine
Setting up a Mac
Installing Xcode
Installing Visual Studio
Configuring the Android emulator
Setting up a Windows machine
Installing Xamarin for Visual Studio
Pairing Visual Studio with a Mac
Configuring an Android emulator and hardware acceleration
Configuring UWP developer mode
Xamarin productivity tooling
Xamarin Hot Restart
Xamarin XAML Hot Reload
Summary
Chapter 2: Building Our First Xamarin.Forms App
Technical requirements
An overview of the project
Beginning the project
Setting up the project
Creating the new project
Examining the files
DoToo
DoToo.Android
DoToo.iOS
DoToo.UWP
Updating the Xamarin.Forms packages
Removing the MainPage file
Creating a repository and a TodoItem model
Defining a to-do list item
Creating a repository and its interface
Connecting SQLite to persist data
Adding the SQLite NuGet package
Updating the TodoItem class
Creating a connection to the SQLite database
Implementing the GetItems(), AddItems(), and UpdateItems() methods
Using MVVM – creating views and ViewModel
Defining a ViewModel base class
Introducing PropertyChanged.Fody 
Creating the MainViewModel
Creating the TodoItemViewModel
Creating the ItemViewModel class
Creating the MainView view
Creating the ItemView view
Wiring up a dependency injection through Autofac
Adding a reference to Autofac
Creating the resolver
Creating the bootstrapper
Adding a bootstrapper on iOS
Adding a bootstrapper in Android
Adding a bootstrapper in UWP
Making the app run
Adding data bindings
Navigating from MainView to ItemView to add a new item
Adding new items to the list
Binding ListView in MainView
Creating a ValueConverter object for the item status
Using ValueConverter
Navigating to an item using a command
Marking an item as complete using a command
Creating the filter toggle function using a command
Laying out the contents
Setting an application-wide background color
Laying out the MainView and ListView items
The filter button
Touching up ListView
Summary
Chapter 3: Building a News App Using Xamarin.Forms Shell
Technical requirements
Project overview
Getting started
Building the news app
Setting up the project
Creating the new project
Updating Xamarin.Forms packages
Creating the structure of the app
Creating the ViewModel base class
Recapping on Quick PropertyChanged.Fody 
Implementing INotifyPropertyChanged
Adding a reference to PropertyChanged.Fody
Creating a FodyWeaver file
Creating the HeadlinesViewModel class
Creating the HeadlinesView
Creating the ArticleItem
Creating the ArticleView
Creating the AboutView
Wiring up dependency injection through Autofac
Adding a reference to Autofac
Creating the resolver
Creating the bootstrapper
Initializing the bootstrapper
Downloading and configuring Font Awesome
Downloading Font Awesome
Adding Font Awesome to Info.plist on iOS
Adding the font to a static resource
Defining some icons in the resource dictionary
Defining the shell
Creating the MainShell file 
Defining the basic structure
Adding the MainShell type to the container
Making the app run
Creating the news service
Obtaining an API key
Creating the models
Creating a service class
Creating the NewsScope enum
Enabling C# 8
Creating the NewsService class
Wiring up the NewsService class
Extending the HeadlinesViewModel class
Extending the HeadlinesView
Extending the ContentView of the ArticleItem
Adding to the bootstrapper
Adding a ContentTemplate attribute
Handling navigation
Creating the navigation service
Creating the INavigation interface
Implementing the INavigation interface using Shell
Adding the INavigation interface to the ViewModel class
Navigating using routes
Finalizing the ItemSelected command
Extending the ArticleView to receive query data
Extending the ArticleView with a WebView
Registering the route
Summary
Chapter 4: A Matchmaking App with a Rich UX Using Animations
Technical requirements
Project overview
Creating the matchmaking app
Creating the project
Creating the new project
Updating the Xamarin.Forms NuGet packages
Designing the MainPage file
Creating the Swiper control
Creating the control
Defining the main grid
Adding a content view for the photo
Creating the DescriptionGenerator class
Creating a picture class
Binding the picture to the control
Setting the source
Controlling the loading label
Handling pan gestures
Testing the control
Creating decision zones
Extending the grid
Adding the StackLayout for liking photos
Adding the StackLayout for denying photos
Determining the screen size
Adding a clamp function
Adding code to calculate the state
Defining a method for calculating the state 
Wiring up the pan state check
Adding exit logic
Checking if the image should exit
Removing the image
Updating PanCompleted
Adding events to the control
Declaring two events
Raising the events
Wiring up the Swiper control
Adding images
Adding initial photos
Making the call from the constructor
Adding count labels
Subscribing to events
Adding methods to update the GUI and respond to events
Wiring up events
Summary
Chapter 5: Building a Photo Gallery App Using CollectionView and CarouselView
Technical requirements
Project overview
Building the photo gallery app
Importing photos
Importing photos from the iOS photo gallery
Importing photos from the Android photo gallery
Writing the app-initializing code
Creating a shell
Creating a base view model
Creating a bootstrapper and a resolver
Creating the bootstrapper
Creating the gallery view
Creating the ViewModel
Creating the view
Loading photos incrementally
Saving favorites
Creating the carousels
Creating the view model for the favorite photos
Creating the view model for the latest photos
Showing the favorites photos
Summary
Chapter 6: Building a Location Tracking App Using GPS and Maps
Technical requirements
Project overview
Building the MeTracker app
Creating a repository to save the locations of our users
Creating a model for the location data
Creating the repository
Xamarin.Essentials
Creating a service for location tracking
Setting up the app logic
Creating a view with a map
Creating a ViewModel
Creating a resolver 
Creating the bootstrapper
Creating the iOS bootstrapper
Creating the Android bootstrapper
Setting the MainPage
Background location tracking on iOS
Enabling location updates in the background
Getting permissions to use the location of the user
Subscribing to location updates
Background location tracking with Android
Adding the required permissions to use the location of the user
Creating a background job
Scheduling a background job
Subscribing to location updates
Creating a heat map
Adding the GetAll method to LocationRepository
Preparing the data for visualization
Creating custom renderers
Creating a custom control for the map
Creating a custom renderer to extend the map in the iOS app
Creating a custom renderer to extend the map in the Android app
Refreshing the map when resuming the app
Summary
Chapter 7: Building a Weather App for Multiple Form Factors
Technical requirements
Project overview
Building the weather app
Creating models for the weather data
Adding the weather API models manually
Adding the app-specific models
Adding the ForecastItem model
Adding the Forecast model
Creating a service to fetch the weather data
Configuring the applications so they use location services
Configuring the iOS app so that it uses location services
Configuring the Android app so that it uses location services
Configuring the UWP app so that it uses location services
Creating the ViewModel class
Getting the weather data
Grouping the weather data
Creating a Resolver
Creating a bootstrapper
Creating the view for tablets and desktop computers
Using FlexLayout
Adding a toolbar item to refresh the weather data
Adding a loading indicator
Setting a background image
Creating the view for phones
Using a grouped CollectionView
Adding pull to refresh functionality
Navigating to different views based on the form factor
Handling states with VisualStateManager
Creating a behavior to set state changes
Summary
Chapter 8: Setting Up a Backend for a Chat App Using Azure Services
Technical requirements
Understanding the different Azure serverless services
Azure SignalR Service
Azure Functions
Azure Blob storage
Azure Cognitive Services
Project overview
Building the serverless backend
Creating a SignalR service
Creating a storage account
Creating an Azure Cognitive Service
Using Azure Functions as an API
Creating the Azure service for functions
Creating a function to return the connection information for the SignalR service
Creating a message library
Creating a storage helper
Creating a function for sending messages
Using the Computer Vision API to scan photos for adult content
Creating a scheduled job to clear photos from storage
Deploying the functions to Azure
Summary
Chapter 9: Building a Real-Time Chat Application
Technical requirements
Project overview
Getting started
Building the chat app
Creating the chat service
Initializing the app
Creating a resolver
Creating a Bootstrapper
Creating a base ViewModel
Creating the main view
Creating MainViewModel
Creating MainView
Replacing MainPage
Editing the XAML
Fixing the code behind the view
Setting the main view
Creating ChatView
Creating ChatViewModel
Creating the class
Adding the text property
Receiving messages
Creating the LocalSimpleTextMessage class
Sending text messages
Installing the Acr.UserDialogs plugin
Installing the Media plugin
Sending photos
Creating the ChatView
Creating Base64ToImageConverter
Creating the skeleton ChatView 
Adding ResourceDictionary
Adding CollectionView
Adding templates
Creating a template selector
Adding the buttons and entry control
Fixing the code behind
Styling
Styling with CSS
Applying the style sheet
Handling life cycle events
Summary
Chapter 10: Creating an Augmented Reality Game
Technical requirements
Essential theory
An overview of the project
Setting up the project
Creating the project
Updating the Xamarin.Forms NuGet packages
Setting the Android target framework version to 9.0
Adding the camera permission to Android
Adding a camera usage description for iOS
Defining the user interface
Creating the ARView control
Modifying the MainPage
Adding UrhoSharp
Installing the UrhoSharp NuGet package for iOS and the .NET Standard project
Installing the UrhoSharp.ARCore NuGet package for Android
Adding the Android life cycle events
Defining the PlaneNode class
Adding custom renderers for the ARView control
For iOS
For Android
Creating the game
Adding the shared abstract Game class
InitializeAR
CreateSubPlane
UpdateSubPlane
FindNodeByPlaneId
Adding platform-specific classes
Adding the iOS-specific class
Adding the Android-specific class
Writing the ARKit-specific code
Defining the ARKitComponent
Writing handlers for adding and updating anchors
SetPositionAndRotation
UpdateOrAddPlaneNode
OnAddAnchor
OnUpdateAnchors
Writing a handler for removing anchors
OnRemoveAnchors
Initializing ARKit
Writing the ARCore-specific code
Defining the ARCoreComponent
SetPositionAndRotation
Writing a handler for ARFrame updates
Initializing ARCore
OnConfigRequested
InitializeAR
Writing the game
Adding a camera
Configuring a renderer
Adding lights
Implementing the game startup
Adding boxes
AddBox()
OnUpdate()
Making boxes rotate
Creating the rotate component
Assigning the Rotator component
Adding a box hit-test
Adding a death animation
DetermineHit()
OnTouchBegin()
Wiring up input
Updating statistics
Defining a statistics class
Sending updates via MessagingCenter
Wiring up events
Updating the GUI 
Subscribing to the updates in the MainPage class
Summary
Chapter 11: Hot Dog or Not Hot Dog Using Machine Learning
Technical requirements
Machine learning
Azure Cognitive Services – Custom Vision
Core ML
TensorFlow
Project overview
Getting started
Building the Hot Dog or Not Hot Dog application using machine learning
Training a model
Tagging images
Training a model
Exporting a model
Building the app
Classifying images with machine learning
Using Core ML for image classification
Using TensorFlow for image classification
Creating a base ViewModel class
Initializing the app
Creating a Resolver class
Creating a bootstrapper
Creating the iOS bootstrapper
Creating the Android bootstrapper
Building the first view
Building the ViewModel class
Building the view
Building the result view
Building the ViewModel class
Building the view
Summary
Other Books You May Enjoy
Index