The Advanced Xamarin Developer Masterclass

In this lecture we will be creating the UI for the application, very quickly we will define some XAML elements, including Entries, ToolbarItems, Pickers and DatePickers, as well as remember how the navigation is performed with the NavigationPage from the App class 

In this lecture we will quickly setup the basic functionality for this app, so later we can focus on learning new things. We will create some observable collections, some classes, and some methods, which will be making requests to a SQLite local databases for reading and inserting 

In this lecture we will set some commands to the elements in the itnerface that need to respond to user interaction, including the two ToolbarItems that we have, so methods are executed in response to a click 

In this lecture we will bind the properties from the ViewModel, that already implements the INotifyPropertyChanged interface, to the Labels, Picker and DatePicker that we have defined in XAML, for the items to be saved in the SQLite database 

In this lecture you will learn to build collections (List or in our case ObservableCollections) to a picker and some ListViews that have an Item Template (and DataTemplate) containing first a TextCell and then a ViewCell with a ProgressBar 

In this lecture we will update the form that we have to use a TableView instead of a StackLayout, and we will take a look at how the binding works in the same way. A quick bug with clearning the ObservableCollection will also be solved. 

In this lecture we take a look at scenario where Binding through C# helps bind the unbindable to a TableView, since it doesn't have an ItemsSource, only some C# tricks and C# Binding can help achieve some level of MVVM in this case. 

In this lecture we will implement a Custom Renderer to a Progress Bar for iOS, changing the height of all the elements in Xamarin Forms by exporting this renderer from the platform soecific iOS project 

In this lecture we will use the Progress Bar Renderer that we have to add some dimanic coloring to the progress, depending on the value that is being displayed, thanks to the access that we have through the ElementChangedEventArgs for the ProgressBarRenderer 

In this lecture we will implement a Custom Renderer to a Progress Bar for iOS, changing the height of all the elements in Xamarin Forms by exporting this renderer from the platform specific iOS project 

On iOS native development you can set different types of accessories to the TableViewCells, and of course, this being Xamarin, native functionality is completely available, so in this lecture you will ue a Custom Renderer and a XAML proeprty to set some customized value to the Accessory ot a TableViewCell 

For the case of Android, we will use the same ide behind the iOS example of getting a value that is set through XAML and using it in the CustomRenderer to execute some evaluations that will change the way a TextCell looks when the app runs 

In this lecture we will talk about what Dependency Services are, what they help with, and how are they going to be implemented on a Xamarin Forms app, this brief look will help students identify that they need to be familiar with Interfaces to easily follow along the coming lectures 

In this lecture we will start the implementation of Dependency Services into our Xamarin Forms project by defining the Interface that will define the members that have to be implemented in different classes from both Android and iOS proejcts 

In this lecture you will learn how to implement the interface in a new class that will be created on both the Android and iOS projects, and then registering these classes as dependencies that will be injected to the Shared Library Project (.NET Standard) 

Now that we have injected the code from Android and iOS to the Shared Libary project, in this lecture, you will learn how to use Dependency Services to create the correct instance of a class as an interface that has access to the required methods, from the .NET Standard Library project 

In this lecture you will code the functionality, native to iOS, that will use UIActivityViewControllers to share a file and some text that will eventually be coming from the Xamarin .NET Standard Library, thanks to the dependency service that we have already implemented 

In this lecture you will code the functionality, native to Android, that will use activities, intents and ActivityFlags to share a file and some text that will eventually be coming from the Xamarin .NET Standard Library, thanks to the dependency service that we have already implemented 

In this lecture, now that both the Android and iOS Dependencies are ready, the implementation for sharing complete, we will focus on creating, from the .NET Standard project, code that will generate a txt report of the expenses per category 

In this lecture I give a brief introduction to the reason why effects and behaviors are su useful, what they can help developers with, how do they compare to each other, and why are they different than custom renderers in xamarin forms 

In this lecture we will create a new behavior for a ListView, so it behaves in a way that can be easily reused with other ListViews. Simply, we will add the functionality to the Behaviors to navigate to a details page, for which we will have a new ViewModel, a new View, and create a new class, all for the Behaviors array to list now one new behavior inside the ListView 

In this lecture you will be adding Effects to your Xamarin Forms project, you will first create the Effect in the .NET Standard Library, and make sure that you set a correct id when initializing the RoutingEffect class, then, in each project, you will implement the abstract PlatformEffect class so both Android and iOS export an effect, and register a Group Name 

The Effect is now exported, and the OnAttached is being called in both Android and iOS, but the functionality is not there, so here we use the ColorDrawable to evaluate the current background color of the Control and change it when required 

The Effect is now exported, and the OnAttached is being called in both Android and iOS, but the functionality is not there, so here we use the UIColor to evaluate the current background color of the Control and change it when required 

In this lecture I mention the purpose of this section, talking about how App Center can help you improve your app development process, and how GitHub is going to be part of the process 

During this section we will be working with another project, different to the one we have been using troighout the first part of the course, and so in this lecture I will explain what the View, ViewModel and Model look like, explain the Behavior that was added on XAML. and show how a Frameworks, and the UseSaveArea works on iPhone X, XS, and XS MAX 

In this lecture you will be setting up a GitHub repository and add some branches to it, so you can upload your Xamarin Forms project, have some form of version control, but more importantly, later on be able to add Continuous Delivery with the help of App Center 

In this lecture you will setup a new App Center account, add to it an organization, and a couple of apps for your Android and iOS projects. You will also setup the teams and distribution groups that App Center will be able to manage 

In this lecture we will setup the builds inside the App Center projects to happen whenever we push to a specific branch inside our GitHub repo, the the Continuous Delivery is up and running inside the App Center, although we will still need to sign the builds for the distribution to devides to happen. 

In this lecture we will be configuring the necessary keys so App Center can sign our Android Builds for them to be installed on devices. This will require us to work with keystores directly from Visual Studio (or Android Studio or the Console) and then uploading this to the App Center 

In this lecture we will be configuring the necessary keys so App Center can sign our iOS Builds for them to be installed on devices. This will require us to work with provisioning profiles directly from the Apple Developers Portal, work with certificates, and then uploading this to the App Center 

In this lecture we will implement the App Center functionality that will help us add crash tracking and error tracking to our Xamarin applications so we as developers get information about what is causing our app to fail when it is deployed. 

In this lecture we will implement the App Center functionality that will help us add analytics and event tracking to our Xamarin applications so we as developers get information about how our application is being used, and the type of devices where it is being depolyed. 

In this lecture I will be showing you how when the app crashes, App Center packages automatically log the information about the crash so we can later inspect it from the portal, but we will also implement a way of identifying if the app had crash, in case we want to tailor the experience to the user if that happened. 

Before being able to distribute through App Center to the Play Store, with every push to the master branch, we will need to publish a first version to the Play Store manually, so we cover that in this lecture. 

Before being able to distribute through App Center to the App Store, with every push to the master branch, we will need to publish a first version to the App Store manually, so we cover that in this lecture. 

Now that we have published a first version of the application to the iOS App Store, from App center we can start tu distribute new builds automatically when new pushes arrive to the corresponding Git branch, so during this lecture we will configure precisely that. 

Now that we have published a first version of the application to the Google Play Store, from App center we can start tu distribute new builds automatically when new pushes arrive to the corresponding Git branch, so during this lecture we will configure precisely that. 

Now that App Center is entirely setup, along with the connection to the stores, in this lecture we will test everything by pushing a new feature to all our users by simply pushing and pulling from GitHub to the corresponding branches to achieve continuous deployment! 

In this lecture we will talk a bit about Microsoft's Azure cloud as well as create a new Azure Notification Hub service that will allow us to send push notifications to both our iOS and our Android apps.

Apple Push Notifications services are greately important, since they will manage the notifications to all iOS devices, hence, we will need to create the required certificates and update our App IDs to enable push notifications in our apps, that is what we cover in this lecture, along with the connection to the Azure Notification Hub.

Firebase for push notifications is greately important, since they will manage the notifications to all our Android devices, hence, we will need to create the required application in the Firebase portal and setup a JSON file in our android project

In this lecture we take a look at some of the endpoints from the Azure Notification Hub API that will allows us to make a correct request to send push notifications to both our Android and iOS apps, right before implementing this REST requests to an Azure Function

In this lecture we will use the Notification Hub's REST API to send some notifications using some Python code, as an example of what you could have in the backend of a service that sends notifications to your Xamarin Forms applications.

Now that we know how to send the notifications, lets prepare our Android app to handle the notifications and display them to the user.

Now that we know how to send the notifications, lets prepare our iOS app to handle the notifications and display them to the user.

In this lecture I will briefly talk about what you can expect to happen with this section as time passes, since this will be the section dedicated to all important updates to the Xamarin Forms platform. I will also introduce what the section already covers, and why I consider these topics to be advanced to Xamarin Forms and XAML 

In this lecture we will learn about a quick way in which XAML, as of Xamarin.Forms 3.1, enables you to set the Android TabBar (TabbedPage) to the bottom of the screen as you would see on iOS, instead of the default top position, also getting to use some AndroidSpecific code right from XAML in the .NET Standard project 

Use Safe Area is a property of the iOS pages (ViewControllers) that is of great importance for the experience in the iPhone X and the iPhone Xs (and Xs Max) to be good, because these phones now have notches, and a new "home button" and curved edges, it is important to make sure that our content adapts to that, and it will be as easy as setting this property to true, which we can do from XAML 

New in Xamarin Forms 3.2 is a feature that I think has been long requested and necessary, the ability to easily, from XAML, change the way the Title in the Title bar looks for both Android and iOS, so during this lecture we will learn how we can change this to improve the looks of our apps. 

In XAML, the OnPlatform extension exists to let you define different values for different platforms, so if you need the UI to use different values depending on the platform that is running, you can do so directly from XAML, in this lecture we explore how to do this in the new Xamarin Forms 3.2 version 

As of Xamarin Forms 3.0, you can now use stylesheets to define the style of your applications, of course, XAML styling is still available, but now you can brind your CSS experience over to Xamarin Forms development and create the styles in those type of files 

In this lecture we will learn how to use one old XAML feature that had been missing from Xamarin for a while, but finally present in Xamarin Forms 3.0: The Visual State Manager, which will allow us to change how the UI will look according to some user interaction with the elements themselves or even with the device 

In this lecture we will take a look at what this section is going to be about, the things that we will have to build, and the main objective in the section, which will be to learn a thing or two about Xamarin Forms that will help us create a great chat experience inside of the application. 

In this lecture you will create a new Microsoft Azure service that will provide some machine learning to your applications, by allowing your users to ask questions in natural language and get responses based on a knowledge base that you have uploaded to this service 

In this lecture we are going to connect a new Azure Bot service with a QnA service so the bot is now able to answer to the same questions that the source we added in the previous lecture 

The bot is ready, all we have to do is connect it to our app, and in this lecture I will show you how to do it with a simple webview by using an embed iFrame to extract the source that contains our bot, and getting the secret from the Azure Bot service. 

In this lecture you will be using the Azure Bot Framework's API to make REST requests that will create new conversations with the bot, so eventually you use those conversations to send the messages that you need the bot to answer. 

The conversation has been created, there is already a conversation pending with the bot service from Azure, during this lecture we will learn about the structure of the REST requests that will send a new message to the bot through that conversation, to make sure that our bot will be receiving the message correctly, so it can answer back. 

In this lecture we are going to setup a web socket to a url that we received when we created the conversation with the bot, so the application can receive the stream of messages that will be coming from the Azure Bot Service 

For the Bot Helper to send all the received messages over to the observable collection that we will have in the View Mode for our Chat View, we will need to respond to every time a message is received, and so, we will also need to send some custom arguments when the event is fired. In this lecture, we will setup the View Model which will require a custom EventArgs class 

In this lecture, now that our app is sending messages to a bot, and receiving its responses from the stream, we will start tu display the elements inside of the collection in a list view, however, this being a chat, will require more than one type of cell to be displayed. for that the Data Template Selector is going to be quite useful to set the ItemTemplate to the ListView directly from XAML 

The bot is ready, and we are already using a TemplateSelector to display the correct type of cell inside the listview, now there are only a couple of improvements that we will make to the listview which include some quick margin setup and the usage of the ScrollTo method from the ListView 

In this lecture I will talk about what we will cover in the last three sections of the course, which I consider the advanced and "musts" of the course, covering platform-specific things that will up your game as a Xamarin developer, which includes using native Java (Android) and Objective-C libraries inside of the Xamarin projects. 

In this lecture we will create an AAR file from an Android Library project that we have on Android Studio, and use it to create a Bindings Library on Visual Studio for later use this new DLL file in the normal Xamarin Android project that is inside our Xamarin.Forms application 

In this lecture we will take a look at the impact that linking assemblies has on the size of the generated APK files for your android application, and how linking assemblies from the SDK is a great option if you want to deploy to the play store