Disclaimer: this is an automatic aggregator which pulls feeds and comments from many blogs of contributors that have contributed to the Mono project. The contents of these blog entries do not necessarily reflect Xamarin's position.

May 26

Podcast: Previewing Xamarin.Forms 3.0

In this episode of the Xamarin Podcast, I’m joined by Xamarin.Forms PM David Ortinau to walk through the early preview of Xamarin.Forms 3.0 announced at Microsoft Build 2017. Learn about new ways you can use Xamarin.Forms in your apps, speed and performance enhancements, and what new platforms are coming to Xamarin.Forms. Be sure to download today’s episode from your favorite podcasting app!



Subscribe or Download Today

Keeping up with the latest in .NET, C#, and Xamarin is easier than ever with the Xamarin Podcast! Cohosts Pierce Boggan and James Montemagno cover topics relevant to Xamarin developers, from designing mobile apps to identity management. Be sure to subscribe to the Xamarin Podcast on iTunes, Google Play Music, Stitcher, or your favorite podcast app you use to ensure you don’t miss an episode.

The post Podcast: Previewing Xamarin.Forms 3.0 appeared first on Xamarin Blog.

May 25

TrainerRoad Helps Cyclists Increase Performance with Five-Star Apps

The .NET community continues to grow in size and expertise, ranging from recent college grads building the future of technology to experienced professional developers modernizing decades’ old business processes. TrainerRoad,one of our amazing customers, combines their passion for technology with their passion for cycling. They’re laser-focused on user experience, delivering web, mobile, and desktop apps that provide personalized workouts and training plans, connect with on-bike sensors to track performance metrics, electronically readjust resistance, and sync real-time metrics across platforms.

Today, Nate Pearson, TrainerRoad CEO, shares how his team uses end-to-end mobile DevOps and cloud services to build, test, distribute, and continuously monitor and improve their apps to ensure their customers get the same high performance and quality from their training technology that they demand from their own performance. The result? Five-star ratings and a rapidly growing user base.

Tell us a little bit about your company and role. Have you always been a developer?

Becoming a faster cyclist used to be my personal mission and it inspired me to build TrainerRoad. I used to wake up and spend my days creating executive dashboards for a Fortune 500 slot machine manufacturer, but all my free time—weekends, early-morning hours before my 8-to-5 engineering job, and late-night evenings after my kids went to bed—was dedicated to triathlon training and increasing my speed. Your bike (and your training regime) is where you make up the most time: if you’re strong on your bike, you finish with a time you’re proud of.

Now, I wake up every day as TrainerRoad’s CEO, where I help thousands of athletes achieve their goals and become faster cyclists. I’ve been developing software since 2014, although my mobile development experience was extremely limited until 2013 when we started working with Xamarin to develop TrainerRoad’s iOS app. We couldn’t exist today, or continue to grow, without mobile: 50% of the platforms we support are mobile and nearly half of our customers use our Android or iOS apps.

Tell us about your app and how it fits into your mobile strategy.

TrainerRoad on an Android phoneTwo things make us the industry’s most effective training system: science and hard work. We bring the science, and our athletes bring the hard work; both are equally important to becoming a faster cyclist in the most efficient way possible. We combine technology with trusted, science-backed principles and deliver structured indoor workouts and plans to athletes across desktop, web, and mobile.

We’re always evaluating how we can provide the best training experience for our athletes, and mobile is a big part of the discussion. A lot of our athletes mount their cell phones to their handlebars to create an easier, more seamless training experience. We get that, and so mobile is—and always will be—a huge focus for us.

What sets your apps apart?

TrainerRoad is an all-in-one training system. When an athlete downloads our app they’re not just getting access to the best indoor cycling workouts; they get personalized training guidance just as they would if they had their own cycling or triathlon coach. We use our expertise to create structured training plans that tell riders exactly what to do to become as fast as possible, and they can track their progress throughout the training season via their personal performance dashboard.

What do you think about when you hear “native app”?

I think of the feel, launch time (it’s gotta be fast!), and how it looks. Without a doubt, Xamarin allows us to accomplish the native look and feel in a fraction of the time. Unlike most “shortcuts,” we’ve never had to compromise on quality using Xamarin. In fact, the quality of our apps has been better, because we execute new features and resolve bugs across all platforms much more quickly.

Why did you choose Xamarin?

TrainerRoad is unique because we share one codebase across four platforms (Windows, Mac, iOS and Android). All the guts of what we do—interacting with client devices, execution of workouts, syncing workouts, etc.—comes from this shared codebase. For our athletes to have a five-star experience, our apps must run seamlessly for the entire workout duration (one to two hours at a time), connect to external Bluetooth devices, connect to ANT (the fitness version of Bluetooth Smart), and instantly perform client-server interactions.

We’re a C# shop, and we specifically chose Xamarin. We knew our apps had to feel native, but we also wanted to build and implement new features across all our platforms quickly and simultaneously, which we’re able to do with Xamarin. We’ve recently switched to Xamarin.Forms to share even more code across Android and iOS.

There are very, very few companies that (1) are available on four platforms and (2) have the same thorny functional requirements we have. Managing our codebase’s complexity in the same programming language has been a game changer for our development team.

It’s a lot to handle, but Xamarin makes it all possible, allowing us to reuse our code across all platforms. Xamarin is a killer solution for us; we’ve saved so much time!

TrainerRoad on an iPhone

How long did it take to ship your app, from design to deploy?

We started with iOS, which took about a year, and our Android version took nine months. Without Xamarin, it would have taken us twice as long to build each app; we share nearly 90% of our code across platforms, which is huge for time savings.

How, and why, are you using Microsoft Azure?

All of our development servers are on Azure. We look for reliability and scale in a web hosting service, and Microsoft Azure delivers on both. Like many other software companies, we looked at AWS, but the integration with our existing technology appealed to us, and now I’d hate to not be on Azure. It’s saved us so much time and money.

Describe your development process and approach to mobile DevOps.

Our designers use InVision to create mock-ups for stakeholder sign-off and, once approved, we put them inside of Zeplin. From there, our weekly sprint planning meetings and GitHub projects define clear objectives and tasks for the dev team.

When an engineer picks up an issue and has a pull request ready, another engineer reviews the code before it goes to our testing team. After testing is complete, validated code goes into our development branch, and we publish nightly alpha and test builds to TestFlight and GooglePlay.

Why is mobile quality important?

You know what it’s like to get ready for a workout—there’s a lot of mental and physical preparation. Now imagine this: you’ve gotten yourself in the mindset to do your workout, eaten your pre-workout nutrition, changed into your gear, jumped onto your training equipment and… it doesn’t perform. That’s a fists-raised-in-the-air moment—like getting ready for a date only to be stood up. It leaves a bad taste in your mouth.

We try extremely hard to avoid our athletes ever experiencing that feeling. Testing, a lot of testing, is imperative to our app quality and our reputation. We have unit tests, integration tests, automated testing with Xamarin Test Cloud, and a test team. It’s extensive: team members physically get on bikes to ensure everything works seamlessly. For example, our automated testing suite once caught a mistake in our codebase that prevented users from signing in before we released it.

We treat testing like a first-class citizen in our development process. Without it, we’d risk a buggy app that riders wouldn’t recommend to their peers. We’re proud of our 76 NPS (Net Promoter Score), and it would sting for that to drop. So yes, we like to test, and in a variety of different ways!

It’s not feasible for us to have every device variation, and Xamarin Test Cloud gives us a breadth of devices. We have about 40 different variations of Android and iOS phones in-house, but of course that’s just the tip of the iceberg (if you look at just Android, there are over 24K device variations!).

Xamarin Test Cloud helps us run full regression tests, so we can ship beta builds to our internal teams and production releases to our customers as soon as possible.

What have your users said about your app?

TrainerRoad is an app built for cyclists by cyclists. Team members from across our development, test, support, and marketing teams are cyclists or have cycling experience. They use TrainerRoad for their own training, and we rely on them for internal testing and early product feedback. Our internal riders download our alpha and beta builds and share their commentary, ideas, and feature requests in our #rider-feedback Slack channel. We invite all teams to join our weekly product show-and-tells to make sure everyone, not just the development team, gives feedback on our in-development features.

The feedback we’ve received from TrainerRoad athletes who aren’t on our team is also incredible. We get a lot of amazing public reviews, but some of our most memorable feedback has been through our social and customer support channels. Last week, one of our athletes began a support chat, sharing that he’d been diagnosed and treated for cancer last year and how the treatments were grueling. He went on to tell us how our training system is exactly what he needed, and he’s started building his strength back up. It’s this kind of feedback that makes the whole team pause, reflect, and feel even more proud of what we’re accomplishing everyday.

What’s your team planning to build next?

We’re working to give riders a more complete, holistic view of their training, including features that automatically sync outdoor ride metrics into TrainerRoad.

What advice do you have for developers who are just starting out or investigating mobile development?

We recommend Xamarin’s educational tools; Xamarin University is a great resource. What we learned from Xamarin University courses got our team up to speed and going on mobile.
 
 
Visit xamarin.com/customers to learn how our customers across industries and geographies deliver amazing mobile apps, and visit xamarin.com/download to start building your own.

The post TrainerRoad Helps Cyclists Increase Performance with Five-Star Apps appeared first on Xamarin Blog.

May 24

Using Local Notifications in Xamarin.Mac

At Xamarin, we strive to empower you to create beautiful, practical, native mobile apps, but we also have a love of desktop applications. Xamarin.Mac and, more recently, Xamarin.Forms for Mac, give you everything you need to produce the same high quality app for the macOS desktop as you can for mobile devices.

Like mobile apps, a desktop app may not always be at the forefront of the user’s display. Sometimes we want to alert a user of something that’s happening, and local notifications are a great way to keep users engaged. Setting up local notifications with Xamarin.Mac takes just a few lines of code and is very similar to Xamarin.iOS. Today, we’re going to take another look at native Xamarin.Mac and add local notifications to our Pomodoro project, an app designed to help users segregate their workloads into 25 minute chunks.

Be sure to check out my Building Your First macOS App and Displaying Data with macOS Table Views blog posts if you haven’t already. You can also download today’s starting point here.

A Background On Notifications

The purpose of adding notifications to this app is to alert the user when 25 minutes has elapsed, even if the app is not in focus. As it stands, the dock icon bounces when the time has elapsed, since we’re displaying a modal alert; this is standard behavior on macOS and doesn’t require any extra coding from us. However, a bouncing dock icon does not provide any context as to what the alert is for (and can be quite annoying)!

Local notifications are different to push notifications in that you don’t need a web service such as Azure to push a notification to the app. The notification is set up in code locally and displayed when triggered manually in code. This is perfectly suited for our Pomodoro app, as we know exactly when we need to trigger the notification.

Adding the Code

The code for the notification is just a few lines. This needs to be added after we stop the timer; it doesn’t need be invoked on the main (UI) thread:

// Trigger a local notification after the time has elapsed
var notification = new NSUserNotification();
// Add text and sound to the notification
notification.Title = "25 Minutes is up!";
notification.InformativeText = "Add your task to your activity log";
notification.SoundName = NSUserNotification.NSUserNotificationDefaultSoundName;
notification.HasActionButton = true;
NSUserNotificationCenter.DefaultUserNotificationCenter.DeliverNotification(notification);

As you can see, we’re creating a notification in the code and then setting the title and text. We also have the opportunity to select a sound to be played. In this instance, we’ll just go with the default notification sound.

We’re also setting HasActionButton, which gives the notification two buttons by default: “close” and “show”. macOS also sets the app notifications to a “Banner” style notification by default, which doesn’t allow buttons. We can change this in System Preferences to an “Alert,” which will show buttons. There is, however, a way to force an Alert style notification by setting the following string value in Info.plist

<key>NSUserNotificationAlertStyle</key>
<string>alert</string>

Info.plist
Note: It’s important to note a quirk in macOS here. This setting will only affect the notification when the app is signed for release. During debugging this setting is ignored, so we need to set the alert type in System Preferences for now.

Trying it out

So, all we need to do now is test our new notification. Run the app, let the timer expire, and hopefully you’ll see the following notification:

Notofication

Having the notification as an alert improves the user experience, as the user can chooses to either close the notification or hit “show” to bring our app into focus.

Wrapping Up

Notifications are a powerful way to keep users interacting with your app, while also being able to display relevant information when needed. Setting up local notifications is simple and effective and doesn’t require any extra infrastructure. These notifications can also be extended in various ways by customizing the alert sound, buttons, and more advanced techniques such as providing a text field.

To view the completed project for this blog post, check out my Pomodoro GitHub repository here.

The post Using Local Notifications in Xamarin.Mac appeared first on Xamarin Blog.

May 23

Deep Dive into SkiaSharp with Xamarin.Forms

Xamarin.Forms is a versatile cross-platform user-interface toolkit that allows a single program to run on iOS, Android, the Universal Windows Platform, and (most recently) macOS.

However, one feature missing from Xamarin.Forms is a graphics system. Sure, Xamarin.Forms can render bitmaps, and you can size and rotate a BoxView for some simple blocky images, but for those of us who love graphics programming, Xamarin.Forms has a big polygon-shaped hole.

But don’t fret! A very compelling solution for Xamarin.Forms graphics is SkiaSharp, Xamarin’s C# library that incorporates Google’s powerful Skia Graphics Engine.Old-school graphics with SkiaSharp.

SkiaSharp is a cross-platform, high-performance 2D API for .NET developers perfect for mobile development. The API is straightforward to work with and can be used to do simple things, like drawing shapes or text, all the way to complex real-time drawing applications. The Xamarin team has even created a WYSIWYG graphics designer that puts out SkiaSharp graphics code.

As a member of Xamarin’s documentation team, I’ve been engaged in writing what I hope to be an extensive series of bite-sized tutorials on using SkiaSharp in Xamarin.Forms. These articles represent a deep dive into SkiaSharp, but one that I hope can also serve as an introduction to 2D graphics for newcomers. SkiaSharp shares many concepts with other 2D graphics drawing systems, so learning SkiaSharp is a terrific way to get a general education in 2D vector graphics.

Most recently, I’ve finished several articles on SkiaSharp Transforms. SkiaSharp supports all the basic graphics transforms found in other graphics systems, including translation, scaling, rotation, and skewing, which tilts graphics objects such as this shadow:

Example of drawing shadows in SkiaSharp.

That image uses an SKPaint object to define the characteristics of the text output. For the shadow (which is drawn first), the code sets a different color and a combination of translation, scaling, and skew to enlarge the text and tilt it to one side:

using (SKPaint textPaint = new SKPaint())
{
    textPaint.Style = SKPaintStyle.Fill;
    textPaint.TextSize = screenWidth / 6;
    textPaint.IsAntialias = true;
    // Common to shadow and text
    string text = "shadow";
    float xText = 20;
    float yText = screenHeight / 2;
    // Shadow
    textPaint.Color = SKColors.Gray;
    canvas.Save();
    canvas.Translate(xText, yText);
    canvas.Skew((float)Math.Tan(-Math.PI / 4), 0);
    canvas.Scale(1, 3);
    canvas.Translate(-xText, -yText);
    canvas.DrawText(text, xText, yText, textPaint);
    canvas.Restore();
    // Text
    textPaint.Color = SKColors.Blue;
    canvas.DrawText(text, xText, yText, textPaint);
}

SkiaSharp also supports standard matrix transforms, including non-affine transforms, which can achieve perspective and 3D rotation effects, such as the image at the top of this blog.

On mobile platforms and other modern devices, graphics is often intimately related to touch. Xamarin.Forms supports some rudimentary touch events, but not the essential tool of tracking individual fingers. More sophisticated touch tracking for Xamarin.Forms is now available with a Xamarin.Forms effect described in Invoking Events from Effects.

Combining SkiaSharp with touch tracking can result in some fun applications. I’ve recently created a Xamarin.Forms version of SpinPaint, based on a program I first wrote seven years ago for the Microsoft tabletop computer (originally called Surface and later renamed PixelSense).

SpinPaint simulates a rotating disk. Touch it or move your fingers on it, and it draws not only a line corresponding to your finger but three other lines that are mirror images, creating pretty patterns. Here’s SpinPaint running on iOS, Android, and the Universal Windows Platform:

Painting graphics with SkiaSharp

I think what impresses me most about SkiaSharp is its versatility. For example, other 2D graphics systems aren’t in total agreement about the best way to draw an arc, which is a curve on the circumference of an ellipse. Different graphics systems define the arc in very dissimilar ways.

SkiaSharp doesn’t force you into thinking of arcs in a particular way; rather, it supports three different ways to define an arc in a graphics path, so you can use the one that’s best for your particular application:

The angle arc requires that you specify a bounding rectangle for an ellipse, along with start angles and sweep angles:

path.AddArc(rect, startAngle, sweepAngle);

The resultant arc is shown here in red:

Angle arc drawn with SkiaSharp

This is identical to the AddArc and ArcTo methods of the Android Path object, and similar to the AddArc method of the iOS CGPath (although the iOS version is restricted to arcs on the circumference of a circle). This type of arc is great for pie charts.

The tangent arc is similar to the PostScript arct function and the iOS AddArcToPoint method. A radius of a circle is specified that is then fit snugly between two connected lines:

path.ArcTo(pointCorner, pointDestination, radius);

SkiaSharp draws a line and the arc, again shown in red:

Drawing a tangent arc with SkiaSharp.

The tangent arc is ideal for making rounded corners.

Finally, the elliptical arc allows you to specify two radii of an ellipse, as well as a rotation angle. The resultant tilted ellipse can fit between two points in two different ways, resulting in four different arcs between the two points, shown here in four different colors:

Drawing an elliptical arc with SkiaSharp.

You specify which of these four possible arcs you want with two further parameters:

ArcTo (radii, rotation, largeArcFlag, sweepDirectionFlag, point)

This type of arc specification is consistent with the elliptical arc supported by Scalable Vector Graphics (SVG) as well as the ArcSegment supported by XAML-based Windows graphics systems, including the Universal Windows Platform.

If you think arc-drawing is versatile, wait until you see SkiaSharp’s shaders and path effects! The shaders let you specify various gradients for filling in areas, including a linear gradient, radial gradient, conical gradient, sweep gradient, and random patterns called Perlin noise. The path effect can render a dotted or dashed line with any pattern of dots or dashes you want, but also render a line composed of little patterns:

SkiaSharp drawing a patterned texture.

Wrapping Up

There are still more SkiaSharp articles to come, so check the Using SkiaSharp in Xamarin.Forms page often to see what’s new.

Meanwhile, you’ll also want to register for Xamarin University Presents, a series of five must-see webinars in July, including one I’ll be doing on SkiaSharp Graphics for Xamarin.Forms.

The post Deep Dive into SkiaSharp with Xamarin.Forms appeared first on Xamarin Blog.

May 22

Staying Up-to-Date in Visual Studio 2017 with the Xamarin Updater

Traditionally, Xamarin developers have used our updater channels to stay up-to-date with frequent Xamarin releases, previews, and updates. To enable our developers to receive updates outside of the Visual Studio release cadence, we are introducing the Xamarin Updater extension for Visual Studio 2017, which allows you to receive updates to Xamarin for Visual Studio out-of-band, such as updates to the Xamarin Live Player or support for new versions of Xcode.

Installing the Xamarin Updater

Visual Studio 2017 provides two channels: Stable and Preview. The Xamarin Updater currently requires the Preview 15.3 release and will only provide preview updates on preview installations.

  1. Go to Tools -> Extensions & Updates.
  2. Navigate to Online -> Visual Studio Marketplace.
  3. Search for Xamarin Updater and press Download. The extension will be marked as “Created by: Xamarin”.
  4. Restart Visual Studio.

You now have the Xamarin Updater installed. This is will provide you preview updates on the preview channel of Visual Studio.

Keeping Up-to-Date with Xamarin

The Xamarin Updater will automatically push updates via the Extensions and Updates window. To receive updates (if available), go to the Updates tab, and press Update for each item to download all available updates.

Using the Xamarin Updater in Visual Studio 2017.

When the downloads have completed, a restart of Visual Studio is required to install the updates. After Visual Studio is closed, the updates downloaded above will be installed. You can follow along at releases.xamarin.com for release notes and information regarding updates shown in the Xamarin Updater and/or Visual Studio updater.

Wrapping Up

The Xamarin Updater extension for Visual Studio 2017 allows you to always be up-to-date with the latest Xamarin SDKs. This updater mechanism does not replace traditional updates to Visual Studio Stable and Preview, but instead is meant to supplement them. For more information, check out our documentation on changing the updater channel.

The post Staying Up-to-Date in Visual Studio 2017 with the Xamarin Updater appeared first on Xamarin Blog.

May 18

Glimpse the Future of Xamarin Forms 3.0

At Microsoft Build 2017 we shared our vision for Xamarin.Forms 3.0: to enable using Xamarin.Forms in more ways, on more platforms, and faster than ever before. Today, I want to walk you through some of the exciting new features that we’ll be adding to Xamarin.Forms that we know you’re going to love!

Xamarin.Forms Embedding

You’ve always been able to call native APIs from Xamarin.Forms, but now we’re allowing you to use Xamarin.Forms from a mostly native application.

Whether you’re going all-in on Xamarin.Forms, or just want to use it in your native applications where it benefits you most, we’re enabling all paths; we call this Xamarin.Forms Embedding. Take any ContentPage in XAML or C# and embed it directly into a Xamarin.iOS, Xamarin.Android, or UWP application.

All of your existing Xamarin.Forms UI now has extended use outside of Xamarin.Forms applications.
 
Here’s how it looks. In your non-Xamarin.Forms application it’s as simple as initializing Forms with the expected parameters for that platform and creating the native counterpart for the ContentPage using a convenient method. Just like that, you have native controls at your fingertips!

// Android
Forms.Init(this, null);
var androidFragment = new MyFormsPage().CreateFragment(this);
// iOS
Forms.Init()
var iosViewController = new MyFormsPage().CreateViewController();
// UWP
Forms.Init(e);
var uwpElement = new MyFormsPage().CreateFrameworkElement();

 

Xamarin.Forms features, such as DependencyService, MessagingCenter, and the data binding system, all still work in this scenario.

Reach More Platforms

Xamarin.Forms is heading to more platforms! Get ready to run on macOS, Linux, and even more Windows applications using WPF. We’ve started with macOS in preview today, but we aren’t stopping there—we’re enabling you to target every desktop platform! Our team is well under way developing for GTK# and WPF.

Speed Boosts and Enhancements

We’ve put Xamarin.Forms under the microscope to identify key targets for making your apps load faster and run quicker, specifically:

  • Control Renderers: we continue our work on what we appropriately call Fast Renderers. These refactored renderers avoid creating many intermediate objects and achieve much better performance.
  • Layout Compression: when enabled, we optimize your layout at compile time to improve rendering speed and minimize memory usage.
  • Binding System: we’re introducing one-time binding mode.
  • Flexibility: the popular Web layout system is coming to Xamarin.Forms. We’re introducing a FlexLayout system for building adaptive layouts and implementing a Visual State Manager.
  • Styling: we’re polishing up a CSS-inspired styling implementation that’s requested often. You can continue to style your applications as you do today, and if you’re a fan of CSS styling, it will now be a powerful option for you.

Introducing XAML Standard

As announced at Microsoft Build 2017, we’re collaborating with the Windows division on XAML Standard, a way to share XAML as an asset. Xamarin.Forms will fully support XAML Standard and take you to every platform you need to be on.

Frameworks that support XAML Standard will be able to share common XAML based UI definitions. Our goal is for the first version, XAML Standard 1.0, to be available later this year.

Try it Today and Join the Conversation

Here’s where you can get started today on all of the great stuff we’re cooking for Xamarin.Forms 3.0.

Download Xamarin.Forms 3.0 Preview

We’ve posted a preview of Xamarin.Forms Embedding to a new feed and shared our demo code. To get it:

  • Add a new source to your NuGet Manager: https://www.myget.org/F/xamarinforms-dev/api/v3/index.json
  • Check Pre-Release
  • Select and install the package with the feature name “Embedding”. 3.0.0.100-embeddingpreview
  • Download the Weather demo application code on GitHub. https://github.com/davidortinau/build2017-new-in-xamarin-forms

When you’re ready, explore the full Xamarin.Forms Roadmap and join the XAML Standard conversation on GitHub.

 

Watch our full Microsoft Build 2017 Xamarin.Forms session at channel9.msdn.com/events/Build/2017/B8099.

The post Glimpse the Future of Xamarin Forms 3.0 appeared first on Xamarin Blog.

May 17

Sharpen Your Mobile Development Skills with New “Xamarin University Presents” Webinars

Xamarin University Shield LogoThousands of developers attended our Xamarin University Presents webinar series earlier this year, and we had a great time introducing developers to the breadth of apps they can build with Xamarin Tools for Visual Studio. Now, our team of mobile experts are hosting five brand NEW demo-packed sessions, covering all things mobile and beyond. From building your first cloud-connected game with SpriteKit to adding intelligent APIs with Machine Learning, join us to get the training, samples, and advice you need to ship amazing mobile apps using the IDE, language, and code you know and love.

Beginning June 1, we’ll air a new topic every Thursday. Each expert-led session is free and open to everyone; whether you’re just getting started or want to broaden up your skills, our mobile experts will be on hand to answer your questions live.

Sign up now and be sure to register for the entire series. We encourage you to sign up for all of the webinars even if you’re unable to attend a session, as we’ll email the recordings to all registrants when they become available.
 

Register

  • June 1, 9 am PDT | Introduction to Xamarin.Forms for Visual Studio 2017: Learn how to take your .NET skills mobile with Visual Studio 2017 and Xamarin.Forms. Jesse Dietrichson, a Xamarin University instructor, will show you how to use the latest Visual Studio features to maximize code re-usage and design, develop, and test fully native apps for Android, iOS, and Windows, faster than ever.
  • June 8, 9 am PDT | Building games for iOS, macOS, and tvOS with Visual Studio and Azure: Create multiplayer games for the latest Apple devices, from iPhone to tvOS, with René Ruppert, Xamarin University instructor. He’ll teach SpriteKit basics, integration with cloud back-end services, and show you best practices for sharing C# game logic, UI, and infrastructure code cross-platform.
  • June 15, 9 am PDT | SkiaSharp Graphics for Xamarin.Forms: Get serious about graphics with special guest and popular author, Charles Petzold. You’ll learn how to use SkiaSharp, powered by Google’s Skia graphics library, to extend your Xamarin.Forms apps with compelling 2D graphics.
  • June 22, 9 am PDT | Customizing Xamarin.Forms UI: Embed native Android and iOS controls into your Xamarin.Forms apps. Join Rob Gibbens, Xamarin University training manager, to see how to integrate native controls and adjust visual properties unique to each platform – while still sharing the majority of your code. You’ll get the step-by-step guidance you need to take full advantage of the latest OS-specific UI patterns and designs.
  • June 29, 9 am PDT | Introduction to Azure Machine Learning: Start integrating intelligence and predictive analytics into your apps. Jason DeBoever, Xamarin University instructor, will introduce Machine Learning fundamentals, get you started with Azure Machine Learning Studio, and demo how to easily build your first “smart” mobile app.

Sign up today, bring your questions, and get ready to learn—we’ll see you soon!

The post Sharpen Your Mobile Development Skills with New “Xamarin University Presents” Webinars appeared first on Xamarin Blog.

May 15

Xamarin Live Player FAQ

In the Microsoft Build Day 2 Keynote last Thursday, Terry Myerson demonstrated iOS development with our new Xamarin Live Player and Visual Studio 2017 live on stage. We simultaneously released previews for Visual Studio 2017 and Visual Studio for Mac, with support for Xamarin Live Players for iOS and Android. To help answer the flood of questions we’ve received since this announcement, we’ve created the following FAQ.

What is the purpose of the Xamarin Live Player?

The Xamarin Live Player apps enable you to write, execute, and debug code continuously on an iOS or Android device straight from the IDE. The purpose of the Xamarin Live Player is to provide an easier and faster way to work and iterate on applications with C# and Xamarin in Visual Studio without the need to commit to downloading gigabytes of SDKs and provisioning different devices to get up and running.

As your project gets more advanced, you’ll want a fully configured development environment to do more advanced work, such as customizing your applications with app icons, loading screens, and additional functionality such as launch screens, app extensions, and widgets. Visual Studio makes it easy to finish installing and configuring dependencies at that time, and you’ll be able to continue working with the same iOS and Android project files you used with the Xamarin Live Player.

How do I get started using the Xamarin Live Player?

To get started using the Xamarin Live Player for iOS and Android, follow our setup guide or check out our video walkthrough:


Does the Xamarin Live Player remove the Mac requirement for iOS development with Xamarin?

No. To completely develop your app for iOS, you’ll need to install and configure a complete Xamarin development environment, which requires a Mac for iOS tools, including storyboard designers, app extension development, app packaging/signing, and more. With Visual Studio 2017 on Windows, we make it easy to develop for iOS using a Mac on your network to stay in a familiar IDE on Windows.

Does the Xamarin Live Player remove the Java and Android SDK requirements for Android development with Xamarin?

No. To completely develop your app for Android, you will need to install and configure complete Xamarin development environment, which requires Java and Google’s SDKs for Android development, including Android layout designers, app packaging and signing, and more.

Does my source code get uploaded to a server to then deploy to the device?

No. Visual Studio and the Xamarin Live Player use a server to find each other and set up the initial connection. Once Visual Studio and your device are paired, they communicate directly with each other over the network.

Does Xamarin Live Player support development with Xamarin.Forms?

Yes. Xamarin.Forms is the primary focus of this initial preview, and the iOS and Android apps both have support for Xamarin.Forms development in C#, F#, and XAML. Many advanced Xamarin.Forms features are supported in this release, including data binding, DependencyService, and MessagingService.

What development features and limitations are there when developing with the Xamarin Live Player on iOS?

On iOS, the Xamarin Live Player works best with Xamarin.Forms apps developed in C#, F#, and XAML, and for apps developed with native UI elements constructed in C# or F#.

The Xamarin Live Player has limited support for rendering iOS storyboards; however, storyboard editing requires a Mac. You cannot change setting found in the Info.plist, modify rotation restrictions, or work on platform features that require provisioned devices or features that require entitlements. The player also has limited support for reflection that affects some popular NuGets, like SQLite and Json.NET, though many other NuGets are compatible.

Visit the Xamarin Live Player page for a complete, up-to-date list of limitations. We’ll be updating this list as we improve the app and the Visual Studio extensions, so keep checking back.

What development features and limitations are there when developing with the Xamarin Live Player on Android?

On Android, the Xamarin Live Player works best for apps developed in C#, F#, and XAML with Xamarin.Forms.

The Xamarin Live Player does not currently have support for rendering Android layouts in XML files (AXML). The player also has limited support for reflection that affects some popular NuGets, like SQLite and Json.NET, though many other NuGets are compatible. The app is currently an open beta on the Android Play Store so please give us feedback if you run into any issues.

Visit the Xamarin Live Player page for a complete, up-to-date list of limitations. We’ll be updating this list as we improve the app and the Visual Studio extensions, so keep checking back.

Are third party libraries (NuGets, Components) supported?

Third party libraries and NuGets are supported; however, some limitations, such as limited support for reflection and use of custom resources, can cause issues for popular libraries including SQLite and Json.NET. A complete, up-to-date list of limitations for the the Xamarin Live Player can be found here.

I just updated to the preview version (15.3) of Visual Studio 2017, but I don’t see the Xamarin Live Player option.

To get the preview bits for Visual Studio 2017, which includes support for Xamarin Live Player, make sure to follow the instructions on in our troubleshooting docs on how to add in the Xamarin Updater to Visual Studio 2017.

Are there any good samples to demonstrate development with Visual Studio and the Xamarin Live Player?

Yes! We have a repository of samples that work with the Xamarin Live Player hosted here:
https://github.com/xamarin/mobile-samples/tree/master/LivePlayer

I’m running into a problem, can you help?

Make sure to check out the Troubleshooting and Limitations pages first. If you’re still running into problems, let us know on the Bugzilla or the Xamarin Live Player subforum.

For more details on how to try out the Xamarin Live Players, head on over to the setup page and be sure to check out Miguel’s blog post for more information.

The post Xamarin Live Player FAQ appeared first on Xamarin Blog.

HP, Inc. Takes the Pain Out of Forms Processing with User-First Scanning Apps

Many of our customers use their passion for .NET to build amazing employee and consumer-facing apps that power the “future of work.” These developers help entrepreneurs and team members eliminate pen-and-paper based systems, access information, and be productive from anywhere, with any connectivity.

HP, Inc. turns document capture, scanning, editing, and routing into an automated, one-click process, allowing users to customize workflows, integrate with their cloud storage provider of choice, and more. Today, we’ve invited Jeff Lee, Modern Capture Lead Software Architect, to share how his team reduced code complexity with Xamarin for Visual Studio, transitioned from one-platform specific Android app to .NET for all platforms (iOS and Windows), and delivers “world-class” apps to professionals everywhere.

Tell us a little bit about your company and role; have you always been a developer?

At HP Inc., we believe everyone can be a creator with the right intuitive, accessible technology, and that this technology should work for you and adapt to your needs, context, and environment. The Modern Capture team develops products that give users a customized, easy way to transition from physical documents to digital.

I started working on image capture software as a college intern, developing an X-Windows-based scanning app for HP-UX 300 Workstations. Since then, I’ve worked on HP Inc.’s ScanJet and multi-function device software imaging solutions and, in 2015, our business stakeholders kicked off an initiative to deliver advanced scanning capabilities across web and mobile platforms.

Currently, I’m a technical lead and architect for HP Inc.’s software solutions, and our team supports both desktop and mobile apps. The Modern Capture Team is primarily a group of experienced developers who use C++ and C# as their main development language, and Xamarin makes it easy to leverage our existing expertise to deliver native apps for Android and iOS. Our new college graduates have picked up Xamarin and .NET quickly, becoming highly productive early on.

Tell us about the app and what prompted you to build it.

HP JetAdvantage Capture is a scanning and capture workflow app that targets mobile professional customers, ranging from government agency clerks to leasing agents to banking customer service reps. We help them capture and route forms, invoices, statements, receipts, checks—any sort of document—and accomplish tasks such as collecting signatures, logging inspections, routing documents to case folders, onboarding customers, initiating claims, applying for permits, and providing approvals.

The app’s design center (see screenshot from our Windows 10 app) is focused on one-touch capture flows; we use customizable shortcuts and cloud services to provide a simple, fast, powerful, automatic, and secure user experience.

HP

We’d previously built a version of HP JetAdvantage Capture for Android, using Java and Android Studio. Now, with our iOS and Windows 10 releases, our customers can complete their tried and true desktop capture tasks on their preferred mobile device, anytime, anywhere.

Why did you choose Xamarin for the project?

Our customers use an onslaught of new mobile platforms, beyond traditional PCs, and they expect to be able to accomplish the same tasks, including advanced document capture, on their device of choice. We delivered a simple document and photo scanning app for Windows 8.1 (HP Scan and Capture) desktop users, and, in early 2016, an advanced scanning and capture app for Android.

When our business stakeholders requested that we deliver the same advanced capture capabilities to our iOS and Windows mobile users, we had a choice: (1) continue to invest in separate development efforts and code bases for each platform or (2) find a way to use one unified effort and code base to deliver on all platforms.

We explored and evaluated web/cloud, code translation, platform-specific, and cross-platform technologies. We chose Xamarin for three reasons: high level of industry support, our team’s experience in Visual Studio and with the C/C++/C# programming language, and the ability to create and maintain one build process.

Coding once and releasing fully native apps on three platforms is extremely powerful, and we’re all looking forward to delivering more products using C#.

To me, to be a “native app,” it must look and feel like it belongs on each platform, and provide a true-to-platform experience. Using the MVVM pattern, we separated platform-specific UI code from the common model and view model code. We opted to use Xamarin.Android and Xamarin.iOS (versus Xamarin.Forms), giving us maximum control over the user experience, and used MVVM to minimize the amount of business logic at this layer.

We had in-house experience with .NET and Visual Studio, and we used a mix of educational resources, including: Xamarin University classes, Xamarin Forums, and cross-platform collaboration with other internal teams. We also had a weeklong on-site Xamarin training workshop that got the team up to speed. Since then, we’ve continued to research online, and take Xamarin University courses to learn new and advanced skills.

How long did it take to ship your app, from design to deploy?

We had a lot of technical know-how barriers to overcome with this project: integration with a unique scanner, Wi-Fi Direct implementation, online/offline conditions, integration and synchronization with our cloud services, learning Mac, determining the best project structure, localization, and Xamarin itself. We integrate with several existing HP cloud services for authentication, temporary cloud storage, and connectors to email and cloud storage providers.

We started a few people on the project in September 2015, then provided team training in January 2016. We released our new, first-ever JetAdvantage Capture iOS and UWP apps on March 1st, 2017. We’re now working on bringing the iOS and UWP versions to feature-parity with our existing Java-based Android app (released January 2016).

In anticipation of replacing our Java-based app, we’ve developed the Xamarin.Android version in lock-step with iOS and UWP. Doing so ensured our common code works for all three platforms, and we can maintain one code base going forward. Now that the massive learning curves are mostly behind us, delivering new features to all three platforms will be much faster than platform-specific development and we’ll release concurrently.

Cross-platform also applies to build, test, and delivery. We’re striving for continuous integration and deployment across desktop and mobile projects; we’ve built an agile deployment pipeline (using industry best practices and optimizing for our needs), and we’re finding and fixing bugs more quickly across all of our platforms. We can “fail” fast and learn fast, with lower risk.

HP Pie ChartAnother way to determine Xamarin’s impact, in addition to faster time to market, is return on investment. When I compare platform-specific versus cross-platform staffing models, I estimate that, for us, delivering multiple apps with Xamarin is roughly half the cost of platform-specific delivery. The more platforms you deliver out of your effort, the higher the ROI.

As you can see in this pie chart, we have ~65% code that is platform-independent, with between 8-15% platform-specific UI (but, still all C# of course).

What is the most compelling or exciting aspect of your app?

If you need to scan frequently, our app dramatically improves your productivity, allowing you to set repetitive tasks, automatically re-do your last task, build custom documents—including pages from multiple document—rotate, edit, and delete multiple pages, and overall, saves our users time with each transaction.

The customizable shortcut is a huge time-saver for our users: launch, scan, send, and walk-away (grab n’ go). For example, when I have an expense form to submit, I sign my form, place it on the scanner, tap my customized “Email & Archive Expense” shortcut, and I can grab my paper when the scan completes and immediately walk away. The app finishes the processing and delivery tasks, and, based on the my “Email & Archive Expense” settings, takes it a step further: optimizing and formatting my documents into the specified format, sending to pre-specified email recipients with pre-specified subject/body content, and archiving documents to my company’s OneDrive expense submissions folder.

With our new release, we’ve added cloud-based multi-destination processing, which means that the app delivers the document (users’ files can be very large, like for a multi-page, 300 dpi color document) to the cloud service once. Our cloud uses the users’ customized shortcut settings to automatically deliver the document to any number of destinations and services, including: specific email recipients and clients, Google Drive, Box, Dropbox, without requiring any other client apps are installed on the device.

Going forward, we’ll add even more advanced imaging features and cloud services, such as additional image quality and document processing, file type support, capture settings, and more to create an even more powerful experience.

How do you use HockeyApp?

We use HockeyApp to distribute pre-store release versions to internal stakeholders, outside of our team, and to external beta customers. It’s been a very convenient way to distribute and install new updates, complete with release notes. The simple sign-up, distribution, and install (no side-installs required) are our team’s favorite features.

User experience is critical to us: poor quality leads to low customer satisfaction, usage, and ratings. HockeyApp helps us get new releases into users’ hands as soon as possible, so they can provide feedback and help us prioritize enhancements and improve our customers’ experience.

What kind of feedback have you gotten about the app?

Our users love that they can create and customize shortcuts for specific tasks and workflows, saving them time. Internally, our boss says that the app and our delivery is “world-class.” I feel the same: the outcome and the effort is world-class. To go cross-platform, implement a continuous delivery pipeline, connect to hundreds of different HP scanners, support Wi-Fi Direct, and integrate with cloud services at one time, with a very small team? To say I’m proud is an understatement.

What advice or resources would you share with developers who are just starting out or investigating mobile development/deployment?

Leverage the large development community, and work closely with your partners. You’ll still need some platform and Mac knowledge, and, as always, Stack Overflow and other online knowledge bases yield great results. We’ve found that Xamarin web search hits are high on the list, which lends itself to the growing interest and number of developers using this technology.

I’ve really enjoyed my experience using Xamarin; we haven’t found a technical challenge we couldn’t overcome, and I think that’s due to (1) the great support from the Xamarin team themselves and (2) the other experienced developers who contribute both components and knowledge to continuously improve the technology and its growing developer community.
 
 
To learn how our customers across industries and geographies deliver amazing mobile apps, visit xamarin.com/customers, and visit xamarin.com/download to start building your own.

The post HP, Inc. Takes the Pain Out of Forms Processing with User-First Scanning Apps appeared first on Xamarin Blog.

Monologue

Monologue is a window into the world, work, and lives of the community members and developers that make up the Mono Project, which is a free cross-platform development environment used primarily on Linux.

If you would rather follow Monologue using a newsreader, we provide the following feed:

RSS 2.0 Feed

Monologue is powered by Mono and the Monologue software.

Bloggers