>> I am always excited about every single thing and every
single session so far. Thank you so much for
all the great questions that have been coming in on Twitter. Of course, you need is #dotNETConf. We pick your question, you will be sent a Xamarin
Monkey. So how cool is that? So don't forget to do that
throughout all the sessions today. We have many more hours
of content coming up, and don't forget everything
will be on-demand later on, and we'll post that
on the Xamarin blog, Channel 9, YouTube, everywhere
where you get Xamarin stuff. Now, I'm really excited because I have a brand new session
that I've never done before. It's between me and all my friends, all of you amazing developers out there building things
in and for Xamarin. If you don't know who I
am, I'm James Montemagno. I'm a Principal Program
Manager Lead here at Microsoft, and I love mobile
development with Xamarin. How's the Xamarin show here? We tweet about it, blog
about it, create samples. I love the amazing work that
the community is doing. What I wanted to do today is show off that amazing work
that the team is doing, the community members
are doing as well. So this is the James Montemagno
and Friends session. So I first want to talk
about Xamarin.Essentials and some of the work
we're doing there. Xamarin.Essentials is in the box. You get it with every file
new project that you get. What Xamarin.Essentials
does is it gives you access to over 60
native APIs for iOS, Android, Windows, and more
from a single shared API. That's really cool because
if you want to access geolocation, phone dialer,
e-mail, vibration, connectivity. You can do all of that
with just one API. So you have to learn
a for each platform. It's completely
opensource, and we have amazing contributions
from the community that we are continuously adding. Now, last year, when we
launched Xamarin.Essentials, we started with iOS,
Android, and UWP. We quickly heard that developers
wanted our more platforms. So we then added in watchOS, tvOS, and we worked with the
Samsung team to add official Xamarin.Essentials API support
to the Tizen platform. We work closely with
the community and our partners to ensure that when we're adding new
features to the core, they get added to
additional platforms. I'm also excited to
announce that soon we'll be adding even more platforms
to Xamarin.Essentials, and we're starting next with macOS. So soon you will have
a fully cross-platform API for not only your
mobile applications, but also your desktop
applications to truly, wherever your .NET applications can run, that's where we want to be. So right now, we just recently
launched version 1.5, which I'm really excited about as Theme Detection,
Platform Extensions, a Cross-platform Permissions API, and even a WebAuthenticator API to enable you to login with OAuth
with a few lines of code. It's also based on AndroidX
for the brand new Android 10, if you're targeting that,
same with Xamarin.Forms. Now, we'll be working on 1.6 next, which will add macOS support, which is near finally in
the open PR on GitHub. But we'll also be adding file
pickers, contacts, and calendars. We've worked closely with
developers in the community, and these are community
contributions that we've been iterating on them
for the last few months, and we're ready to pull them in to
the core of Xamarin.Essentials. So be on the lookout for that. But it's not about just all the great things that
we're working on here. We love the community, and I love the community and all the great work that
all of you are doing. So what I wanted to do today is
something a little bit different. I asked all of my amazing friends
out there on Twitter, on GitHub, and through all my e-mails that
you've all sent me throughout the years to highlight your projects, the things that you're working on. You're going to see some
amazing opensource projects from the Xamarin team, but also community
developers around the world. I first want to start out with some amazing libraries that
developers just sent me and said, "Hey, I'm using this
on my Xamarin app, why don't you show it
off?" So I said, "Sure." First one's from Shaun,
which is expressive, which is this awesome .Net API, or it's an any .NET application that enables you to evaluate expression. So here he's doing one plus one, and it's going to evaluate an
integer to return three or 1 plus 2 to return three,
which is really cool. It's really extensible,
completely opensource. Next, here we go. MVVM Atom for my good friend Sameer, who works here at Microsoft now. It's really awesome. It's a minimum base class MVVM with commands and
navigation service. You wanted to get the maximum done in the most minimum amount of time. So it allows you to
do custom commands and things like that for your MVVM. Next up, HTTP Tracer. This is from Dylan,
Daniel, and Chase, really, really cool stuff. I get asked all the time, "Hey, I'm making HTTP requests. How do I debug that? How long does it take?" Well, HTTP Tracer does that. It works with any .NET application
and your Xamarin apps. It's a fiddler for
those applications. You can trace your responses, your requests, output
it to the council, which is what you're seeing here. Best of all, completely opensource. In fact, everything I'm showing
you completely opensource. AnyBind. Alexander sent this
one, and I really like this. This is the best part, I didn't
know a half of this stuff existed. So sending it in is awesome. This AnyBind helps improve the binding situation to get rid of those OnProperty changes.
It's really cool. What he does is it simply comes in. He used before here with adding
events for property change, having to propagate up
OnPropertyChanged notifications in here on the right-hand side, after just simply initializes the dependency manager as these little attributes on
top and the magic happens. TinyInsights from Daniel out
there, which is awesome. This is really cool if
you're using any Analytics. So App Center, App Insights
or Google Analytics, it abstracts it into a common API that you can access
from your shared code. You can even add your
own custom providers. So if you're not
satisfied with what's out there using your own back-end, it's really, really easy. So here, there's a little
tracker that you initialize. You can set up dependency trackers, what you're calling, and you can
send that into the back-end. It's really, really nice, no matter what you're using
and multiple providers too. So I love that because
sometimes you're sending data to multiple sources, and I really, really
like this to give you insights into your apps. Now, when you go beyond
Xamarin.Essentials, which sometimes you may, you
want deeper integration OS. You can always access those APIs. But there are amazing
community projects out there that deliver some of
this great functionality. So now that I ask the amazing developers and all of
you to send me your suggestions. I said, "Hey, why don't
you make a video for me?" So I have a few here that I
want to play back for you. The first is Allan Ritchie and
his amazing Shiny project. I use Shiny in my applications
to do all sorts of good stuff. Check him out on GitHub
and the shinyorg as well. But I'm going to let him talk
about it because he deserves it, because he helped build
it. So here we go. >> Hi, my name's Allan Ritchie. I've been working with Xamarin
and .NET for many years. I'm a former Xamarin MVP and
a current Microsoft MVP. Over the last few years, I've contributed many
opensource components to help developers get stuff done with a total of almost four
million NuGet downloads to date. I love being a part of the
Xamarin and.NET community. Today, I'm going to talk about my latest opensource contribution
to the community called Shiny. Traditionally, background services
can be quite difficult to write and even harder to bring your
shared code and services to them. No one likes to rate spaghetti
code or untestable code. Forget about a good
cross-platform solution to this until now and Shiny. Shiny fixes all these scenarios and makes it really
easy for you to write this code fast that runs across
all of the Xamarin platforms. By bringing a solid dependency
injection architecture, Shiny allows you to get
your back-end done quickly, freeing you up to create beautiful user experiences
and innovative applications. Shiny is a framework that has several libraries and
utilities for you to use, such as Periodic Background Jobs,
Geofencing, Background GPS, Motion Activity Recognition, Local Notifications,
Push Notifications, Bluetooth LE Client and Server Modes, BLE Beacon Detection and
more to come in the future. As the standard process
pick with a NuGet, you need to install, each
of the NuGet packages does contain a baseline set of instructions to help get you started. Shiny like Xamarin.Forms and Xamarin.Essentials does
require some boilerplate code. Because Shiny use
dependency injection, we do need a general
type of startup file. If you've used ASP.NET core, this should look familiar to you. You'll notice that we've registered a background job with some criteria and notifications
module with categories and actions and some geofencing. We'll take a look at how we handle the events for these modules shortly. This file is also where
you want to register your own services and code so that Shiny can use them
in the background events. iOS is pretty straightforward when it comes to the
boilerplate code. Everything is done in AppDelegate
and any permissions that you normally need to get set
up in the info P list. Nothing new here but a
couple lines of code. As you can see, Shiny wires in using
extension methods. This is to make the
plug points a little easier for you to discover
during development. Android, on the other hand, is a bit more complicated. Shiny needs to initialize
before everything. Note the use of the
main application here. This is something that is a bit different versus
Essentials and Forms. Behind the scenes, Shiny
uses broadcast receivers, which when run in the background, will be starting the app in a cold state without ever
hitting your main activity, and thus going through
the normal Xamarin.Forms application life cycle
you are used to. Lastly, there are few
touch points here in the main activity to enable
things like notification entry, interception, and
permission requests. Finally, let's take a look
at our Background Job code. Note the constructor injection
of the Notification Manager. You can basically DI, whatever you registered in
your startup file here. In this job, we're not
doing anything crazy, just sending out a notification. Things you could do with
background jobs are things like synchronizing offline data
to and from your server, maybe cleaning up a local database, maybe sending some reminder
notifications later in the day. Note that jobs are
periodic, not scheduled. Android is generally pretty good about running roughly
every 15 minutes. iOS is a bit more
intelligent, and we'll run shortly before the user
is known to use the app. The OS is essentially
being trained by the user when they like to use
your application during the day. Let's take a look at some geofencing. Geofencing allows you to
monitor for when your user is entering or exiting a circular
region from a center point. Geofencing has several
great scenarios, like welcoming a user
to a certain location. In the startup file, I registered a geofence for Toronto,
Canada CN Tower. When the user gets roughly a
mile away from the CN Tower, we'll send a notification
welcoming the user and attach a category. We'll cover that in a couple slides, which will allow the user to
interact with the notification. We can also use a
different set of actions based on if the user is
leaving the geofence. For now, we'll just say goodbye. Here's a couple of
screenshots showing our trigger geofence running. Note the welcome response and
how the app responds with another notification without
ever entering the application. Let's take a look at
how we accomplish that. This is the notifications delegate. From here, I'm able to catch events for when the notification
is actually being sent and when the user has interacted with one of
your notifications. The only entry event here
is where I'm responding to the user interaction from
the geofence notification. If the user chose to leave a message, I'll simply respond to them saying
that their message is recorded. If they wanted a free ticket, we'll just let them know that
we've received their request. Because the methods are
traditional .NET tasks, you could also choose to
interact with your backend here to provide some
additional business logic. Looks pretty simple, doesn't it? So that's a quick look at Shiny. I hope you liked what you saw. Be sure to check out the links below for the latest developments in modules that are being worked
on. Thanks for watching. >> There you have it, Shiny
to accomplish so much more. Geofencing, background
notifications, and sinking, everything that you
could possibly want. That's amazing work
being done by Allan. I cannot thank him enough for him and all the contributors
to the project. I use it in my
applications, and I hope that you find it useful too. Now, sometimes, it's not just about
libraries and the application. It's about extensions, about
build time of your application. I asked my good friend, one of my best friends
in the entire world, Jonathan Dick, you may know
as Redth on the Internets. I worked closely with him
here on the Xamarin team, specifically on Xamarin.Essentials, and he's tackling how to properly get different image sizes
from a single source. Everyone knows images, different
sizes, different platforms. He's going to show off Resizetizer NT in his project. So
let's check it out. >> Hey, James. Hey, everyone. This is John Dick here. You may better know me as Redth
on the Internet or on Twitter. Today, I wanted to share
with you quickly just a little something I've
been working on to make cross-platform images in
your Xamarin apps a lot easier. So if you've ever done images
before in your Xamarin apps, you know that it can be a pain. So if you have your Android app, and I've got a new solution here
that's just a Xamarin.Forms app, it's got an Android app, it's got an iOS app,
it's got a UWP app. If I want to add an image to this, I've got to go into my resources, I've got to resize it
for all the different displayed densities that
exist for Android devices. When I'm done doing that, I've got to go into my iOS project, I've got a resize
everything for all of the different display
densities for it. So I've got like the normal image, the 2x image, the add 3x image, and finally, if I come down to
UWP and I do the same thing, I've got a bunch of different assets. I've got a scale 100, a scale 200, 400, etc, etc. That's a lot of images
to have to resize, and so I've made a
quick plugin that lets you share your images from
your shared code project. If you go today and
install Resizetizer NT, go install this to all
your different projects, including your shared code project. Then what I'm going to show
you here is I'm going to take a vector image, an SVG, and I'm going to drag it
into my shared code project here. You'll see this popping,
it's a Xamagon, it's an SVG, it's a lovely image. Now, what I need to do
is go to its properties, and I need to set it as
a shared image type, and then this is a build action
that Resizetizer adds for you. I go and resizetizer shared image, and when I'm done with this, I can actually go
into my project file, my shared project file, and I'm going to go ahead and set an attribute on here called BaseSize. This is going to be the size of the image that I
want to specify in my code. Now, because this is a vector, we actually have to know
what your normal resolution, what your 1x iOS resolution, your MDPI Android resolution, your scale 100 resolution for UWP is so that we can make the right
sizes for all the other, their different display densities. I go ahead and I save this, I add my base size, and now in my apps, I can actually reference
this in all my app head projects just using, now, this is a vector, so
we'll resize it for you, and it will actually
output as a PNG file. So I'm going to go ahead and
reference this as xamagon.png. Let's go into our
shared project here. Let's get rid of this label, and let's add an image. Let's call it xamagon.png. We'll center it. Horizontal
options will be centered to. Then finally, we've got to go
give it our width requests, which is going to be 100, and our height requests,
which will be 100. Now remember, that's
the size we set in our shared project as the base size. So now, I've got this thing. I can go ahead and build my app. Let's start it off on iOS, and you'll see it launch in the
simulator here in a second. We'll run, and we should
have a lovely Xamagon image. Yeah, nicely in our view
here. That's great. You'll notice that if we
look at our resources, it didn't actually add it
to our resources here, it's actually adding it to our
resources in the output folder, in the intermediate outputs. If I go into the
output folder here in the OBJ folder for iPhone Simulator, we can go into this folder
called resizetizer, and we can see all the different
display density versions of that image were
created for us as PNGs. They were included into
the build automatically. We didn't have to add anything
specifically to those projects. So that's pretty cool, and the same is true
for Android, for UWP. It now supports WPF, and it will be supporting
Tizen soon as well. So we support a lot of
different platforms. Now, we'll just run the
Android version quick here, and as for doing that, we'll just check out
the fact that we don't see any resources built into
these folders for the Xamagon. They all exist at runtime, just built into your app
automatically for you, all from this one little include shared image item in your project. The Android app is launching now, and we should see a pop
up here in a second, and there it is. That's great. We have the Android app, the Xamagon in there, and
everything works just fine. Now, we could start
the UWP app as well. There we go, the icon is
in our UWP app as well. So this is called Resizetizer NT. This is a new plugin I made. It's in pre-release now. Go give it a shot, try it out, and you can get it installed
into all your projects, and let me know how it goes. Thanks. >> That thing is
absolutely astonishing. The first time John showed
it to me, it blew my mind. I was like, "I need to have this, and we need to share with the world." So checkout Resizetizer NT and
give us feedback on the project. I know John would love it. Now, let's hope over to the UI. I've shown you some amazing libraries from developers out there for your Xamarin applications
and some plug-ins into Visual Studio to help you with
images such as Resizetizer. When you're building applications, there's tons in the box. We've had some great
sessions about building beautiful applications, and
there's a lot more out there. Sometimes you need things
that are super-duper custom, and you could build them yourself, but there's amazing companies in the Xamarin and
Xamarin.Forms Ecosystem that are making awesome tool kits with tons of controls
built into them. Now, I could talk about him all day, but I challenge every single one of the amazing control
vendors out there to highlight their amazing tool
set in just 30 seconds each. So lets hop over to the
video and check them out. >> We explain why you should
be using Syncfusion's Xamarin controls in just 30 seconds. Well, let's find out. Essential Studio for Xamarin with comprehensive Xamarin UI controls. Controls that include a
High-Performance DataGrid that helps you to efficiently display and manipulate large amounts of data. Our seamless ListView with features such as swiping,
multiple orientations, pull-to-refresh, grouping, and more, and our gallery at 30 plus charts that cater to all charting scenario. Plus, you can implement them
all and use ease of use Xamarin templates from
our Xamarin UI Kit. Want to try them out for yourself, download a free trial at
syncfusion.com/xamarin. I made it. [MUSIC] >> Putting together that
video was absolutely amazing. Seeing all of the videos come in, combine them up with
the awesome music, I literally just playing that
over and over again at home. I don't know how my
wife put up with me. But truly, there is
something out there for any single application
that you're building, [inaudible] will
beautiful applications. Now, is amazing control vendors are building the most
complex, amazing, awesome things possible, and there's also great work being
done in the community. So as a few of my friends, some of them already present today
to show off more awesomeness. A few awesome projects out
there, Magic Gradients, helping you put XAML gradients and C# gradients absolutely
everywhere for Marcin and Bohdan, absolutely stunning, built
on top of SkiaSharp. The UI Color Picker Control
out there from Udara, being able to easily
pick a color with just a single XAML
snippet in your app. XamAnimation, Javier
presented earlier today, easily enabling you to
add an animations into your Xamarin applications all
from XAML or code behind, super duper awesome,
completely open-source. Sheet control. This is
an awesome one from Havard who also was tweeting today. A lot of people are asking
about sheet control. He spent a lot of hard work on this. It's really awesome to
see how easy it is to add the sheet controls
into your application. Xamlly is a different
tool set out there from Mohamed with progress switch, toggle bars, radio
buttons, all awesome, being built on top of Xamarin.Forms
to add to your applications. Now, I also asked a few good friends
to make another short video. Steven presented earlier today. He talked a little bit about
PancakeView and Debug rainbows, but I asked him to go a little
bit more in-depth. So here is. >> Hi there. My name is Steven
Thewissen, and I'm here to give you a quick overview of some
of the NuGet packages that I've created for
Xamarin.Forms over the last year. The first package I'd like
to show you is PancakeView, which despite its quirky name, it's a really useful control. Using the built-in
Xamarin.Forms controls, it can be hard to create views, the view shadows, the
gradients, or borders. There are a few built-in
controls available that implement some of these
things, like frame, for example, but what PancakeView does is it combines it all into
a single simple-to-use control. So let's take a look at what
options we have available. For that, I will open the
accompanying sample app. You can find that in
the repo, and it has a built-in page with all
the options that has. What I especially like besides these options we are showing
here is the debug mode, which allows you to play around
with the control itself by adjusting all these sliders and exploring all the
options that way. So we have gradients, we have multi-colored gradients, we can adjust angles on them, we can add borders and
all shapes and forms, so dashed or maybe
a gradient as well, and the angle of that
can also be adjusted. It supports CornerRadius. So a uniform corner radius for every corner all the way
up to making it a circle. Or we can also do, if we want to, individually around the corners, we can add shadows and
multiple fashions, so either using elevation, which is an Android thing, or just a regular shadow. It also clips its content
automatically, so it doesn't really matter what type
of borders or corners we add. The content is always clipped,
and we can also make it into a multi-cornered element,
so maybe a hexagon or a triangle if we really want to, and CornerRadius is
also influencing that. So we can create all crazy shapes, and we can also rotate
that shape around. So it offers a lot of
freedom in that regard, has a lot of options, and it
can really help you quickly get started on making a
beautiful user interface. That was debug rainbows. If you're creating user
interfaces in Xamarin.Forms, you've probably come across the
scenario where you've changed the background color on an element to identify the space that
it consumes on the page or maybe to debug positioning issue, debug rainbows can help
you with those issues. So essentially, what the
package does is give you a few additional attach
properties that you can set with your content pages to enable
different debug views. I have downloaded a sample
made by Kym Phillpotts. I hijacked his styles and added all of the debug
rainbow styles in here. The sample app normally looks like
this, which looks pretty great. If we enable debug rainbows, it becomes much more colorful. But this helps you identify where
all the different elements are, where they're positioned, and how they align
compared to one another. On the topic of alignment, debug rainbows also offers the
alignment grid which helps you figure out if everything
is aligned evenly. So it allows you to create all
these major and minor grid lines. You can adjust all of the
properties related to it. So colors, opacities, the interval
of how many major grid lines you want, and it really helps
you align your items evenly. When combining this with hot reload, you can really speed up your
depth loop when figuring out those nasty layouting issues or you can just use it to create
pretty colorful pictures. Wraps up this little quick summary of all the packages that
I've built over last year. I hoped you enjoyed it, and
we'll see each other soon. >> Awesome. I love PancakeView
and Debug rainbows. I use them in every single
application I build. Hope you find it super useful. I also challenged Steven to
put the grid on there, and he totally did it from one
of my favorite packages, from I think Jeff Wilcox
who did it back in the day on the bunch of
different platforms. So really cool to see this work
from the amazing community. Our next up, a library near to a lot of our
developers hard is SkiaSharp. Somebody you may not even
know about SkiaSharp, so I asked Matthew
Leibowitz from Africa, one of our amazing developers here, to give a little brief
overview of what SkiaSharp is, what you can build with it, and also some amazing
libraries built with it. So let me go ahead and show off this. >> Hello, world. I'm
Matthew Leibowitz, a software engineer from Microsoft,
and I'm based in South Africa. I have the honor of working on many different
libraries and tools for all the developers in the community, and not only do I
get to work on them, but I get to see the
cool and exciting things that are made with those tools. One of my favorite
libraries of all time is SkiaSharp, an
open-source, cross-platform, 2D drawing library
that enables you to do anything when it comes to
graphics, animations, or UI. It's based on the
amazing open-source work done by the folks at Google
on the Skia Project. Skia is used in many things such
as Android, Chrome, and Firefox. I intake the code, wrap it in a pretty package, add a few extra APIs, make it work great with .NET, and ensure that it runs on Android, iOS, UWP, MacOS,
Windows, Linux and more. You can check out the
code for SkiaSharp on github.com/mono/SkiaSharp. Speaking of amazing things
done by the community, I just wanted to take the time to show off some of the great things that has been done with SkiaSharp
by the folks in the community. The first cool example I like to show off is Balloony by Shanmukha. It's a cool little
slider with a balloon, wobbles back and forth using
SkiaSharp to draw the balloon. The next is a library called MagicGradients by Marcin
that adds shadings, backgrounds or gradients or
patterns to pages and views. You can edit in code, or in XAML, or even use CSS to style it. Another very cool library
I'd like to show off is MicroChart originally
written by [inaudible]. It allows you to add
all colorful graphs and charts into your app to represent any data
that your app maybe using or you want to
show to the user. The last library I'd like
to show off is Mapsui. This is awesome cross-platform
mapping component that you can drop into your
desktop or mobile applications. Just look how smooth this map renders and this is
just the CPU renderer. Now, I'd like to move on from individual controls to entire control galleries built
on top of SkiaSharp, such as Aurora controls with buttons, gauges, gradients, and
even Confetti Control. Another awesome control library
is [inaudible] all the buttons, steppers, and other
various progress bars that you can add into your app. If we go from libraries and control galleries to
entire applications, Wiesław has really cool
project called Draw2D. This is a multi-platform
2D diagram editor. It allows you to create
and edit 2D diagrams. I hope you enjoyed looking at some of the things made by the
folks in the community. Maybe some of your stuff was shown, maybe you're inspired
to do some cool things, but I hope you would
checkout SkiaSharp. Don't forget to hit up
github.com/mono/SkiaSharp. See you around. >> Awesome to see all the amazing
things built with SkiaSharp and all the amazing libraries
that are built on top of it, and the awesome things you
can do to your application. Now, last and not least, I couldn't talk about
awesome controls but I'll tell you about my
good friend, Jean-Marie. Jean-Marie is an amazing developer,
building awesome things. Mr. Sharpnado himself, I'm
just going to let him explain all the awesome things that he's building to use in your applications. Hello, ladies and gentlemen. This is Jean-Marie Alfonsi
speaking for Sharpnado. Sharpnado.com is a blog
about mainly Xamarin.Forms, but also a bit of C# and a
tiny bit of Monthy Python. Behind Sharpnado, this is just me, a French software developer
working as a freelance. So if you want to build
flabbergasting apps, you can contact me and
we'll make this happen. But today it's about the
community, and I will talk about my components that
you can find on NuGet, and we will start with
Horizontal List View. So it's really self explainable. What you can do about the
Horizontal List View, it sets the column count for example. So now, you have three items, four pages, but if you set
the column count to one, you achieve a carousel
layout, in fact. Which is cool about the
Horizontal List View is that it recycle all the items just
like the collection view, and you can also change the layout of the Horizontal
List View and have a grid. Now, you have a grid with
three column for example, if you set to one column, you have now a list view. Which is really cool also about the Horizontal List View is that
you can drag and drop items. Now, if I can take my father, Ted and put it all the way up, or I can take my Steve Carell
here and put it all the way down. Now I will jump straight to the tabs. So pure Xamarin.Forms tabs, and so we have a lot of
different tabs here, all the different
style you can imagine, like the bottom tab item, this one, or the underline tab item, like this one, which are fixed types. But you also have scrollable
tabs and custom tabs. You can style them, you
can change the color, you can change the font, everything. But which is really cool about
it is we can also create your own tab item by
inheriting from Tab Item, look at those spam and
this animation here. We can play a bit with
the tabs you see here. We can just go to
those scrollable tabs, and yes, it's working. No problem. Now, I will be talking about
my favorite components, the Task Loader View. It's my favorite one because
it will remove a lot of boilerplate code, and it will
also prevent a lot of crashes. The main provide of Task Loader View is to free yourself
from IsBusy equal true. So it's a bit mysterious. To understand it more, we will launch the Ritornado app, and we'll want to achieve this, a little loading spinner
with a result view here, a list of games, and if there's error, we will show an error
view to the user. This is what we want. Now to do this, we have a view model here and all
these properties like IsBusy. If you set IsBusy to true, you will see the spinner. If it's a zero, it's true, you will
see the error view, All those kind of things here. For sure, you have
retroGamingService. You will retrieve your games from it, and we have our load method
that will run this code, which is a missing void method. We'll just start with
the Properties and then load the Initialization and
Catch all the Exception. All those properties will
be bound to our example. So we have the result view
here, the loading view here with an activity indicator and the error view as a stack layout. So this is what you saw earlier. If we use a Task Loader View, all is really simple now. You just add Task Loader
View and that's it. In it, you just have
your result view, and all the loading states
are embedded in it. It's the same in the view model. If you use a task loader notifier, you just give in the initialization code and it
will take care of everything. You see, IsBusy is gone. All their properties are gone, everything is taken care of. Thanks to composition. So it's really great. Now, if you look at
the documentation, you can see that it features
many things like default states, though there's already
different views that are implemented in
the Task Loader View, default one, like the error view
is just an image with text. It's styleable, you can
put any font you like. For example here,
it's the ISSD fonts. But you can also use your own custom view by
overriding the loading states. You see how you do it here? Loading States, you just override
the views and you put your own, so you can achieve really
all the design you want. Now, there are more to it. You can also use skeleton loading, thanks to our rich package. Better also, load the animation. So that really everything, anything you can do with
the Task Loader View. So guys, I think that's all for me. Have a great .NETConf and see you
soon on Sharpnado. Bye, guys. >> I want to first say
thank all of you for being part of this amazing
Xamarin community, building libraries, building
on top of what the team builds and also just sending your pull requests and
your feature requests. You-all made it easy for me to
put together this presentation because all of you together
in this amazing community help other developers build
beautiful, stunning applications. We couldn't do this alone. We do it as one big happy
.NET and Xamarin family. I want to thank everyone. I want to make a shout out to all the different awesome
projects that are highlighted here and the
amazing component vendors. I believe we have time
for just three questions. So I'm going to head over to
the board here really quick, and Olia is helping me out
by picking some good ones. The first one's from Rob Wilson. Again, he says, does
Xamarin.Essentials support GPS location capture with long running
stuff via background services? As of today, it doesn't, of course, Xamarin does. So you could go and access those API's yourself
on iOS and Android. But you should also look
what Allan Ritchie is doing because he's already
built this library included inside of Shiny to do background updates and
notifications as well. You can combine the two
together if you want or use the amazing open-source
libraries that are out there. Now, we are looking at integrating some of that stuff into the project. So check out the
GitHub issues as well. Next from Ali, he say's, "Great presentation, James."
Well, thank you. He said, why isn't camera and gallery added the Xamarin.Essentials
or will it be added? It's a great question. You know, we're actively talking
to developers all the time, seeing what you need
for your applications, and we're adding those continuously
into Xamarin.Essentials. Now, Xamarin.Essentials,
since we support so many platforms and it's
included inside the templates, we have to be rock solid that the functionality is super
complete and well-tested. We run hundreds of UI tests
and unit tests on our app, on Xamarin.Essentials itself. Now that said, our big focus is
actually on file-based access. We started with sharing files, e-mailing files, SMSing files. In the next version,
you'll see file pickers, which is going to start to get into the camera picker,
video picker controls. Those are very, very complex
controls out there are API's, I should say, but we are looking
to integrate them over time. But again, just because it's not in Xamarin.Essentials
doesn't mean there's not an awesome library
out there that can already do it, such as the media plug-in or
some other plug-ins out there. All right, last one here. Luis
says, "#dotNETConf, hey, James." Hey Luis. "When can we try
gradients with Xamarin.Forms?" You can do it today. In fact, I showed you some amazing
libraries from the community, including Magic Gradients
and the PancakeView. I use gradients in all
my applications today. Now, Xamarin.Forms itself
is adding it into the box, different controls. I believe it's added in the
next version and the one after. But you can check out
the pool requests and even download a new git from that PR. Again, I want to thank every
single one of you for being part of this amazing
Xamarin and .NET community, for building these awesome
libraries, and for letting me show off
all of your hard work. Go build beautiful applications
with these amazing libraries. Now, let's head back over to
Olia now for our next session.
