Wednesday, December 7, 2016

Xamarin Forms: Customizing the Synfusion Kanban Control is as simple as 1-2-3

Following on from my previous post on getting started with the Kanban Control from Syncfusion, we’re going to have a look at customizing the kanban card template, binding the tap event on the card to execute a command and binding the card to a custom model.

As always, you can find all the source code here

image       image  image

Disclaimer: As of this writing, there are rendering issues with the Windows UWP implementation. A support ticket has be lodged with Syncfusion and it should be resolved with the next iterative release.

1) Providing a Custom Model

In the previous post, we used a KanbanModel to bind against. But you’re free to bind against any object, so long as the properties fire a NotifyPropertyChange event (class must implement the INotifyPropertyChange interface).

In the custom example, I’m using the CustomModel class, which inherits from the BindableBase class that comes out the box with the Prism.Core nuget package.

Properties look something like:

image

Remember that the columns in the Kanban control map by default to a ‘Category’ property. If you want the columns to map to a different property on the model, then set the ColumnMappingPath property on the SfKanban control

image

2) Customizing the Kanban Card

If you’re accustomed to any XAML technology, then customizing the kanban card should be familiar. The idea is that you supply a custom user control to act as a template when rendering the items for the bound collection. For a sample of a custom user control, check out the CustomCard.xaml user control in the source code. The only significant thing to note is the root element is a ContentView.

Once you have a template defined, then the only thing left to do, is to add it as the DataTemplate to the SfKanban control:

image

3) Binding the Tap Event to a Command on the ViewModel

It’s a common scenario that you want to perform a certain action when the user taps in a card. Currently there is no TapItemCommand property on the SfKanban control, but you can achieve the same thing by implementing a behavior.

The KanbanItemTappedToCommandBehavior can be found here.

Basically it takes the ItemTapped event from the card, and executes the command when the event fires.

You then bind the behavior to the SfKanban control like so:

image

The command on the ViewModel would look something like:

image

… and that’s it.

Happy Coding.

Daily Links 7 Dec 2016

7 Tips for Designing a Better REST API

Ten ways to minimize Azure costs

Free local development using the DocumentDB Emulator plus .NET Core support

.NET Standard 2.0 - Making Sense of .NET Again

Hacking the Xamarin.Forms Layout System for Fun and Profit

Resource Files in Xamarin Forms

Continuous Integration and Continuous Delivery for Xamarin.iOS With VSTS

Azure App Services Continuous Delivery

Introducing Xamarin.Forms 2.3.3: Native View Declaration and Platform Specifics

How Passwordless Authentication Works

Xamarin.Forms: Java.Lang.IllegalStateException

Setting Up Android x86 HAXM Emulators




Thursday, December 1, 2016

Xamarin Forms and the Syncfusion Kanban Control: Getting Started

 

kanban

Xamarin Forms and Syncfusion Xamarin Controls are a great combination to get great looking cross platform native mobile apps while using a mostly shared code base.

In this blog post we’re going to look at getting started with one of the newer controls to the syncfusion xamarin family: The Kanban Control

First and foremost, all the source code for the examples below can be found here

If you’re not familiar with getting a Xamarin Forms app up and running – have a look at the quick start outlines here

Nuget packages for syncfusion controls can be found here – keep in mind you need a license to be able to use them. Luckily if you’re a hobbyist developer or a company with less than five people, you can get a community license which is FREE!

Okay – time to get started.
I’m going to assume you already set up a Xamarin Forms wireframe app – check out the quick start above for details on how to get that up and running.
Usually a new Xamarin Forms project adds Windows Phone variant projects. I tend to stick with UWP only for windows, since this is generally more actively supported by control suites.

To get access to the syncfusion nugets, setup a new nuget package source that points to the syncfusion nuget location.
Add nuget packages for the syncfusion kanban control:

image

be sure to set the source to the syncfusion xamarin nuget location:

image

Every project needs to have a reference to the Syncfusion.Xamarin.SfKanban nuget package. You’ll notice there are Android and iOS variants for the package too – these are for the specific Xamarin native platforms (would have been helpful if they actually postfixed the package with “.Forms” – can get a bit confusing as to which package to pick)

Now for some code:

In the portable library, create a ViewModel class to contain all the items that the cards on the kanban control are going to bind to. A sample of the ViewModel class can be found here
The important bits:

You need a class that is the model that each kanban card will represent. Syncfusion provides a default called KanbanModel. We’ll use this for now, but you can use your own model classes too (which I’ll cover in another post). Place an ObservableCollection of this model as a property on the ViewModel class:

image

…. and then add some items to the collection:

image

Take note of the Category property, as this is going to be used by the control to know in which swim lane to place the kanban card.

Next, create a page that will host the kanban control – sample can be found here

image

… and then wire up the BindingContext of the Page to your ViewModel:

image

.. and then attach categories to each column, so the kanban control knows where to place each item template:

image

This is done in code behind, but you could just as easily bind these to ViewModel properties in XAML.

Be sure to set the Page to the startup page in the Forms App class:

image

… and that should be it. Download the source code and give it a test drive.

In my next post I’ll cover:

  • Bind cards to custom models
  • Creating a custom card template
  • Opening up another page when a card gets tapped using a command.

Happy Coding.

Sunday, November 13, 2016

Daily Links 13 Nov 2016

Upgrading Xamarin PCLs to .NET Standard libraries
link 1
link 2
link 3

Resilient network services with mobile Xamarin apps

Exploring Application Insights for disconnected or connected deep telemetry in ASP.NET Apps

9 Things You Should Know About SQL Azure Databases

Authorizing your .NET Core MVC Core API requests with OpenIddict and Identity

First Look: Authentication in ASP.NET Core

Xamarin Android 9-Patch Image Splashscreen

Custom Animations in Xamarin Forms

Xamarin Forms Page Templates

Introduction to UrhoSharp in Xamarin Forms


Generate pdf documents using Xamarin Forms and Syncfusion in 5 easy steps

Xamarin Forms is a great way to implement cross platform fully native mobile apps, but when developing these apps, there’s still a gap ito components needed to fill out the functionality.
These gaps typically fall into two areas:  Platform Services (Camera / GPS / Maps / Settings etc.) and UI Components.
The Xamarin Plugins are a great resource for the former. There are a few resources for the latter, but I have found the Syncfusion Xamarin Control Suite to be the most helpful.
image
One of the more common needs, of Line of Business apps particularly, is for pdf integration (generating / reading / merging etc.)
The syncfusion xamarin samples seem to be a little sparse, so I thought I’d share an example implementation here.
For more in-depth syncfusion pdf documentation, have a look here. There’s quite a bit more pdf capability that they provide than what is covered here.
This post will cover a basic scenario of generating a pdf document from invoice information using the syncfusion pdf component for Xamarin.
Source code for this post can be found here.
If you’re looking for the detail, check out the github repo – we’ll cover the basic outlines here of what’s necessary.

1. Create context for the pdf generation

In the case of the sample code, I’ve created a GenerateInvoiceContext class – which mostly houses the Invoice from which to generate the pdf from.
All the information that you require to generate the pdf needs to be contained in this class.

2. Wrap the generation logic into a command

Create an implementation class that contains the logic for generating the pdf from the invoice. In the sample code, this is the GenerateInvoiceCommand class. I’ve used the command pattern here, because it’s a great way to separate out and force the single responsibility design pattern. The basics for command implementation are provided by the Command Pattern Wireframe nuget package, which provides and ExcuteAsync<TIn, TOut> command pattern to follow. So calling the command from the view model looks something like this:
image
Note that you don’t need to wrap the logic in a command – this is just my personal preference for keeping the code clean.

3. Creating a pdf document

When generating pdf elements, you need to first create the document, and a page for the document before you can start adding elements. I’ve created a PdfGenerator class to make these tasks a little easier. In the Setup method you’ll notice the creation of the document and the first page, as well as common properties for the document to be generated:
image

4. Add elements to the pdf document

Generally, you need to add elements to the pdf document using a top-down approach, keeping track of the Y-position in order to make sure that each element is placed correctly in reference to the previously added element.
image
I found it useful to prefer the methods on the syncfusion pdf component that return a PdfLayoutResult – this helps in creating a reference for where the bounds of the next generated controls needs to be.

5. Save and launch the pdf document

Until now – all the code is shared between all the mobile platforms (iOS / Android / UWP), but saving and launching the pdf document requires platform specific code. In order to call platform code from the shared code, it’s useful to abstract the platform implementation behind an interface – which is then implemented for each platform. I’ve again used the command pattern for ease of use:
image
Now each platform should provide an implementation, which is resolved using Xamarin Forms DependencyService (or you can wire it up using another container service like Autofac)
An example of the android implementation can be found here.
… and a screen grab of the finished product:
image

Bonus

The xamarin syncfusion components are pretty handy, and in my experience the support I’ve received from them has been exceptional.
The best part though, is that all of it is available for FREE – if you’re a single developer or a small business. Check out the community license here.
As someone who has a side project that he hopes to turn into a business one day – it’s these kinds of licensing models which are really helpful – thanks syncfusion!