June 8, 2015

Better Apps & Faster Release Cycles Part I


Today we’re launching a four part series that covers simple steps you can take to improve your apps and make your release cycles faster. Our advice is based on real-world challenges and rewards from Niels Frydenholm, Senior iOS Developer at eBay Classified, who spoke at Xamarin Evolve 2014.

You Can’t Afford Not to Do It

“When I talk to people from other companies about automating their entire test base, they give two reasons why they aren’t doing it: ‘The tools are just too complicated to use’ – which just isn’t true — and ‘We don’t have time to start.’ I think the question they should be asking is ‘How can we afford to not be doing this?'”

In 2013, Denmark’s eBay Classifieds ran small, self-contained development teams focused on short, iterative sprints, but overhead from manual testing inhibited continuous delivery for mobile.

The development team spent two to five days per release on test runs and bug fixes, so product owners forced as many features as possible into each release before the gates closed. This feature bloat cost the company quality and time. Large deltas between releases introduced more bugs that were discovered later in the process, increasing the burden on both development and testing.

According to Niels, eBay adopted a heavily-automated testing process “to speed up the whole development cycle.” While eBay took a number of steps to integrate and tune their process, the move toward automation was the root of the strategy.

eBay Classified on Xamarin Test Cloud

Over time, eBay automated its entire test base and reassigned manual testing resources to areas where they could have the greatest impact. The effort was challenging, but ultimately worth it. They achieved:

  • Better app quality
  • Faster release cycles
  • Happier teams in ways we’ll address later this week

Easy Ways to Get Started

Niels offered three tips for anyone moving toward automation:

  • Prioritize. Test automation is a process, and your existing deployments cannot stop while you reboot. Divide your automation efforts into three categories.
    1. Focus on automating your riskiest areas of existing code first.
    2. Automate tests for new features on an ongoing basis as you create them.
    3. Automate the remainder of your test suite as time allows.
  • Structure your test code. Write clean, well-commented code free of hard-coded variables and designed for reuse, then have that code peer-reviewed before committing.
  • Supplement with manual tests. Manual testers are wonderful at finding creative ways to break things. Use exploratory manual tests to discover new weaknesses. When those tests are successful, structure and automate them.

Ultimately, Niels’ advice to developers is to push through internal resistance to reach the obvious benefits. As Niels notes, “It’s not effortless. There’s a learning curve, but it will pay off.”

In Part II we cover how to cut your app release cycles in half (or more), in Part III we discuss which target platforms fit your testing needs, and in Part IV we explore how test automation helps teams do more important work.

Tweet about this on TwitterShare on FacebookShare on Google+Share on LinkedInEmail this to someone
June 5, 2015

Catch Up on Xamarin Community Contributions This Weekend


Xamarin developers are constantly looking for ways to contribute to the developer community at large. When you develop mobile apps with Xamarin, you aren’t just downloading something that gives you a better way to build mobile apps, but joining a helpful, expansive global community and we think that’s awesome. The links below will take you to some of our favorite content from our community over the past few weeks.

Great Community Posts

Tools and Frameworks


Thank you to these developers for sharing their knowledge and insight with the rest of the Xamarin community! If you have an article or blog post about developing with Xamarin that you’d like to share, please let us know by tweeting at @XamarinHQ, and your post may be highlighted in an upcoming Xamarin community content roundup.

Tweet about this on TwitterShare on FacebookShare on Google+Share on LinkedInEmail this to someone
June 4, 2015

Add Collaboration To Your Mobile Apps with SharePoint


Microsoft SharePoint is one of the most widely used, powerful collaboration tools in the workplace, providing countless features and seamless integration with other products in the Microsoft ecosystem. Now that SharePoint is provided as a cloud solution with Office 365, integrating Office 365 into your apps with Xamarin is a breeze. In recent blog posts, we covered adding Azure Active Directory Authentication, Outlook for Email, and OneDrive for Storage to your apps.

0001 SP 2013 Logo

In this blog post, we’ll see how easy it is to add SharePoint functionality to your mobile apps using the SharePoint APIs.

Step 1: Register Native Mobile App

Before SharePoint can be integrated into your app, you must register it using the Azure Active Directory.

Step 2: Provide Access to SharePoint APIs

Once you register the app, click on the ‘Configure’ tab. On this tab, you should see a green button with the text ‘Add application’. Click on it to access the SharePoint APIs.

Providing access to SharePoint ServicesOn the next screen, select ‘Office 365 SharePoint Online’ and click on the check mark button.

Providing access to SharePoint Services Pt. 2.After this, give the appropriate permissions to the SharePoint services, so users can access them from your mobile app.

Providing access to SharePoint Services Pt. 3Save the changes. Now it’s time to integrate SharePoint with our app. Make sure to copy the ‘Client Id’ and ‘Redirect URI’, which will be required in future steps.

Step 3: Authenticating to Azure Active Directory

With the latest Azure Active Directory Authentication Library (Azure ADAL) preview, the code from our previous blog post on ADAL changes slightly. As of the latest release, AuthorizationParameters has been renamed PlatformParameters, which govern the authentication mechanism on individual platforms. For Android, this is what the code to fetch access tokens should look like now:

public static async Task<AuthenticationResult> GetAccessToken(string serviceResourceId, PlatformParameters param)
    authContext = new AuthenticationContext(Authority);
    if (authContext.TokenCache.ReadItems ().Any ()) {
        authContext = new AuthenticationContext (authContext.TokenCache.ReadItems ().First ().Authority);
        var authResult = await authContext.AcquireTokenAsync(serviceResourceId, clientId, returnUri, param);
        return authResult;

Here, serviceResourceId is your top-level SharePoint URL. For example, in my case it’s “http://mayurtendulkar.sharepoint.com/”, and once authenticated, the app can access any resources below that level. You can call this method from OnCreate, so whenever the app is launched, it will check for tokens (or launch the sign in process).

var authResult = await AuthenticationHelper.GetAccessToken (AuthenticationHelper.SharePointURL, new PlatformParameters (this));

Now, you can use this token from authResult to call the SharePoint APIs.

Step 4: Calling SharePoint APIs

Unlike objects like OutlookClient (which is responsible for Mail, Contacts, and Calendar) or SharePointClient (which is responsible for handling files in OneDrive), SharePoint APIs are REST APIs. Instead of using objects from the SDK, you will use HttpClient to call the SharePoint APIs.

Before discussing how to call the SharePoint APIs from your app, I want to revisit some SharePoint fundamentals. SharePoint contains SiteCollections, which can have sites and the sites can have sub-sites. Sites can be individual apps (e.g. HR Portal, Leave Portal, etc.) that contain libraries (for storing documents) as well as lists (task list, custom lists of data, etc.). Tasks can be shared with colleagues and marked as not started/started/complete/etc. Here, we’re going to create a Task List and add some items to it.

Step 4.a: Create a List in SharePoint Site

The code below will show you how to create a list within a SharePoint site. You can find detailed REST API documentation on SharePoint via MSDN.

protected async Task<bool> CreateList(string token)
    var client = new HttpClient();
    client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", token);
    var mediaType = new MediaTypeWithQualityHeaderValue ("application/json");
    mediaType.Parameters.Add (new NameValueHeaderValue ("odata", "verbose"));
    client.DefaultRequestHeaders.Accept.Add (mediaType);
    var body = "{\"__metadata\":{\"type\":\"SP.List\"},\"AllowContentTypes\":true,\"BaseTemplate\":107,\
        "ContentTypesEnabled\":true,\"Description\":\"Tasks by Xamarin.Android\",
    var contents = new StringContent (body);
    contents.Headers.ContentType = MediaTypeHeaderValue.Parse( "application/json;odata=verbose");
    try {
        var postResult = await client.PostAsync ("https://mayurtendulkar.sharepoint.com/_api/web/lists/", contents);
        var result = postResult.EnsureSuccessStatusCode();
        Toast.MakeText (this, "List created successfully! Seeding tasks.", ToastLength.Long).Show();
        return true;
    } catch (Exception ex) {
        Toast.MakeText (this, "List already exists! Fetching tasks.", ToastLength.Long).Show();
        return false;

As you can see from the above code, the body of the request defines what needs to be done on the SharePoint side. In our case, we’re asking SharePoint to create a SP.List (list with template 107,) which is nothing but a Task List, and giving this list a title and description.

Step 4.b: Add Items to the List

Once the list is created, the same code shown above can be used to create ‘List Item’. To do so, changes need to be made in the request url and body. The following code can add a new task in ‘Task List’, which was just created above.

protected async Task<bool> CreateItems(string token)
    var client = new HttpClient();
    client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", token);
    var mediaType = new MediaTypeWithQualityHeaderValue ("application/json");
    mediaType.Parameters.Add (new NameValueHeaderValue ("odata", "verbose"));
    client.DefaultRequestHeaders.Accept.Add (mediaType);
    var itemToCreateTitle = "Item created on: " + DateTime.Now.ToString("dd/MM HH:mm");
    var body = "{\"__metadata\":{\"type\":\"SP.Data.TasksByAndroidListItem\"},\"Title\":\"" + itemToCreateTitle + "\",\"Status\": \"Not Started\"}";
    var contents = new StringContent (body);
    contents.Headers.ContentType = MediaTypeHeaderValue.Parse( "application/json;odata=verbose");
    try {
        var postResult = await client.PostAsync ("https://mayurtendulkar.sharepoint.com/_api/web/lists/GetByTitle('TasksByAndroid')/items", contents);
        var result = postResult.EnsureSuccessStatusCode();
        if (result.IsSuccessStatusCode) {
            Toast.MakeText (this, "List item created successfully!", ToastLength.Long).Show();
            return true;
    } catch (Exception ex) {
        var msg = "Unable to create list item. " + ex.Message;
        Toast.MakeText (this, msg, ToastLength.Long).Show();
        return false;

Step 4.c: Fetch & Display List Items

Getting records from list requires nothing beyond calling a ‘GET’ request on list endpoint. Displaying these items in a list within your mobile app is easy: the request returns JSON data, which you can parse to objects using Json.NET and then you can create a custom adapter (in my case ListItemModels) and display it in a ListActivity.

protected async Task<bool> FetchListItems(string token)
    var client = new HttpClient();
    client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", token);
    var mediaType = new MediaTypeWithQualityHeaderValue ("application/json");
mediaType.Parameters.Add (new NameValueHeaderValue ("odata", "verbose"));
client.DefaultRequestHeaders.Accept.Add (mediaType);
    try {
        var result = await client.GetStringAsync("https://mayurtendulkar.sharepoint.com/_api/web/lists/GetByTitle('TasksByAndroid')/items");
        var data = JsonConvert.DeserializeObject<O365SharePoint.Models.ListItemModels>(result);
        ListAdapter = new ListItemAdapter(this, data.D.Results);
        ListView.ItemClick += async (sender, e) => {
            var _status = (e.View as CheckedTextView).Checked;
            var _id = (e.View).Tag.ToString();
            await ChangeStatus(token, _id, _status);
        for (int item = 0; item < data.D.Results.Length; item++) {
            if(data.D.Results[item].Status == "Completed")
                ListView.SetItemChecked(item, true);
    } catch (Exception ex) {
        var msg = "Unable to fetch list items. " + ex.Message;
        Toast.MakeText (this, msg, ToastLength.Long).Show();
    return true;

Step 5: Run the App

Run this app using either the Xamarin Android Player or a physical device. If all of the steps above are executed correctly, you should see the same items from the list created in SharePoint in the Android app we built.

SharePoint List and List in a Mobile App


Once you understand the basics of the SharePoint REST APIs and how to call them from mobile apps, the possibilities are endless. Integrating existing SharePoint sites into your iOS and Android apps is easy with Xamarin.

To get started, download the SharePoint sample from GitHub and be sure to replace the client ID, redirect URI, and your resource URI with the ones you created in the tutorial before running the app.

Tweet about this on TwitterShare on FacebookShare on Google+Share on LinkedInEmail this to someone
June 3, 2015

Build Your Own Selfies App with Xamarin.Forms and Azure


Text messaging is so ‘90s! With the rise of selfies as today’s preferred form of communication, we decided to build a sample app that reflects this paradigm shift. Today, we’re happy to introduce Moments, a Snapchat clone built entirely with Xamarin.Forms and Azure. Moments is available for download today on Android, and is currently in review for iOS (stay tuned). Moments is also open-source and freely available under the MIT license, so building your own Snapchat clone based on Moments is easy! Follow the steps listed here, and you’ll be sending selfies in a matter of minutes.

Moments, a Snapchat clone built with Xamarin.Forms and Azure.

Share More Code with Xamarin.Forms

Moments for iOS and Android was written entirely using Xamarin.Forms, allowing me to create native UIs from a single shared codebase while still maintaining access to all of the native APIs on each platform. Because Xamarin.Forms allows you to share nearly every line of code you write, a significant amount of code can be shared across the targeted platforms. Moments shared an amazing 88% of code on Android and 87% on iOS, resulting in a massive increase in developer productivity.

Moments is also a great sample for those interested in seeing everything Xamarin.Forms has to offer, including usage of custom renderers, the dependency service, data binding, styles, and much more.

Powerful Backends with Microsoft Azure

Great mobile apps require great backends. Azure provides everything you need to build that backend, including cloud storage, push notifications, social integrations, blob storage, and auto-scale to support millions of devices.

Moments uses Azure Mobile Services to store data in the cloud. Everything from accounts, to managing friendships between users, and even authentication is done using Azure Mobile Services in Moments. At Microsoft Build 2015, the Microsoft Azure team announced the Azure Storage preview for Xamarin. Azure Storage provides an easy way to store and retrieve large amounts of unstructured data, such as blobs, tables, queues, and SMB-based files. Moments takes advantage of the simple Azure Storage API to save all of your amazing selfies in the cloud (i.e. cloud selfie support).

Try Moments!

Moments is available for Android in the Google Play store today, and is in review for iOS in the Apple App Store. Be sure to send a “moment” to us at @XamarinHQ! Or, get started building your own ephemeral messaging app using Xamarin.Forms and Microsoft Azure by cloning Moments on GitHub.

Discuss this post on the Xamarin Forums.

Tweet about this on TwitterShare on FacebookShare on Google+Share on LinkedInEmail this to someone
June 2, 2015

iOS Development for Windows Developers


Before I developed my first Xamarin.iOS app, my C# experience was limited to Windows.Forms and WPF. I had never developed a native app for a mobile device, but within 48 hours of being introduced to Xamarin, I put together a proof of concept for iOS that was 100% native and reused an existing C# library that I had already developed.

In this blog, I’m going to share a few of my initial experiences with you so you can see just how easy it is for Windows developers to develop iOS user interfaces with Xamarin.

iOS Designer in Visual Studio 2015

iOS Designer in Visual Studio 2015

Building Your Interface 

When you open the iOS designer in Visual Studio, you’re going to find a lot of things that are familiar to you: a property grid, a control toolbox, and a solution explorer populated with .cs files. Just like the WinForms of WPF designer, you’ll see controls within the toolbox that you’ve been using for years, including import controls such as buttons, sliders, text views, and tableviews. In fact, every control available to an Objective-C or Swift developer is available to you, plus you can create your own custom controls, which are available from the toolbox as well.

Much like in WPF or Windows.Forms, when you add a control from the toolbox onto your view, you’re going to need to give the control a unique name to be able to program against it. Once you’ve named the control, you’re able to program against it just like you would for a Windows app. Although iOS APIs are often a little different from those found on Windows, you’ll find IntelliSense makes learning them incredibly easy.

One of the first controls you’ll see large API differences in is UIButton. UIButtons don’t have a click event like you’d expect of a button found on Windows; instead, UIButtons respond to gestures and taps. If you select a UIButton and look at the event pad in Visual Studio, you see an event called ‘TouchUpInside’, which is the iOS equivalent of click. Although iOS is lacking the click event, this doesn’t stop us from double clicking the control within the view in Visual Studio and having it generate the boiler-plate code for TouchUpInside (click) events for us.

Control Layouts

In WPF, you’ve probably been anchoring controls using a mixture of margins and alignment options. You can see below that I’ve recreated my iOS “Hello World” sample as a WPF application and anchored the button to the bottom of the view. This means that when I resize the main window, the button will always remain at the bottom of the screen with a constant margin.

wpf anchor

WPF Design View


For iOS Views, you’ve got two layout options. You can use Autolayouts or Autoresizing. Autolayouts are more powerful for defining dynamic user interface and, unlike Autoresizing, Autolayouts allow you to specify complex relationships between different controls within your view. On the other hand, Autoresizing offers a fairly simple approach which relies on springs and structs. You can see both Autolayouts and Autoresizing layout options for a control below. In this example, I want to ensure that the button remains at the bottom of the view no matter the view size.

It’s worth noting that if backwards compatibility is important to you, then you’ll want to use Autoresizing rather than Autolayouts. This is because Autolayouts is only supported in iOS 6 or later. This shouldn’t prove to be a huge problem for most developers, as iOS users tend to be very quick to update to the latest iOS release.


iOS Autoresizing Layout Options


iOS Autolayouts


Styling Your Controls 

Unlike WPF, which creates custom vector-based UI elements, iOS developers tend to opt for creating images for most of their custom controls. Obviously, UIKit controls have APIs for tweaking appearances, but these are far more limited than the APIs available to WPF developers.

If you’re looking to create beautiful custom controls for iOS, then you might want to read my previous blog post on a tool called PaintCode. This is a vector drawing package that generates Xamarin.iOS drawing code. Alternatively, I would recommend embracing using images for your UI, as this is the standard approach to iOS development used by both Objective-C and Swift developers.

Wrap Up

If you’re interested in learning more about iOS, our videos from last year’s Xamarin Evolve conference are a great place to get started. In particular, you’ll find the dynamic layouts talk by Adrian Stevens very helpful.

Additionally, you may also find Xamarin.Forms, which allow you to write iOS, Android, and Windows Phone apps in XAML another helpful option.

Tweet about this on TwitterShare on FacebookShare on Google+Share on LinkedInEmail this to someone
June 1, 2015

Google I/O 2015 Recap For Android Developers


Last week Google I/O, Google’s annual developer conference, took place in San Francisco. Google IO logoIt was an exciting week for Android developers as there were new enhancements and updates to Google Cardboard, Android Wear, Google Play Services, and just about every other Google product. Here are my three biggest takeaways from Google I/O to help you get ready to implement them in your own Android apps.

M Developer Preview

As expected, Android Lollipop will be followed by Android M (still a code name).

Android M

While the introduction of Material Design made Lollipop a dramatic departure from previous versions of Android, M will have a focus on quality and performance. In addition to a plethora of bug fixes and enhancements, there will still be plenty of goodies for developers to take advantage of when M releases this fall. Here are some of the highlights:


One of the most significant changes this fall will arrive in the Android Permission system. Previously, you were able to specify what your app required, but with M, permissions have been simplified and optimized. This change will require your users to accept permissions at runtime instead of install time.


Fingerprint Authentication

fingerprint-screen_2xGone are the days of requiring users to enter passwords. With just a few lines of code, you’ll be able to integrate Android M’s new Fingerprint Authentication.

So Much More

There are tons of other features packed into Android M, including enhanced Notifications, Voice Interactions, and Direct Sharing. You can learn about all of these features in the Android M Developer Preview API Overview.

You can also start playing around with the Android M Developer Preview today on your Nexus 5, 6, and 9 devices. To learn more about the Preview, head to the Android M Developer Preview website.

Material Design Updates

It’s been a big year for Material Design; here on the blog we’ve written about Material Themes, Toolbar, and the awesome controls you can use. Material Design is now one year old, and Google has done a fantastic job of updating their Design Guidelines for designers and developers to include all of the latest controls, including extending to TV and Auto.

Material Design

Even more of a game changer for developers is the introduction of the new Design Support Library, which now includes the Floating Action Button, Material Tabs, Snackbar, AppBarLayout, CollapsingToolbarLayout, and much more! We’re excited to announce that you are able to take advantage of this brand new Design Support Library today with our release of a preview NuGet package for your Xamarin.Android apps. We’ve also released a sample to help you quickly learn these great new Design Support Library features.

All the Libraries!

chromecustomtabsThe Android fun doesn’t stop there, though! There have also been several updates to core Android libraries that we’re making available today as preview NuGet packages, including Google Play Services, Android Support Libraries, and the latest and greatest Android Wearable Library.

One of the most exciting new libraries we released today is Chrome Custom Tabs, which enables you to easily and elegantly display websites with the power of Chrome without having your users leave your app. It’s available today on NuGet and as a full source code sample on GitHub so you can get started today!

Tweet about this on TwitterShare on FacebookShare on Google+Share on LinkedInEmail this to someone
May 29, 2015

Get the Summer Going with Xamarin Events in June


Summer is upon us, which means it’s an excellent time to get out and meet some fellow Xamarin developers in your area to learn about crafting beautiful native cross-platform mobile apps in C# at a local conference, user group, or Xamarin Dev Days event!


Visual Studio Live us

  • Austin, TX: June 1–4
  • iBeacons and Contextual Location Awareness in iOS and Android apps with James Montemagno

Couchbase Connect 15 us

  • Santa Clara, CA : June 2–4
  • Xamarin and Couchbase Lite with Mike Bluestein

Cross-Platform App Development with the Swiss Mobile Association Swiss Flag

  • Zurich, Switzerland: June 4, 5:30pm-8:00pm
  • Learn about Xamarin with the Swiss Mobile Association in Zurich

Xamarin Dev Days Dallas us

  • Dallas, TX: June 6, 8:00am–5:00pm
  • Come learn about Xamarin with your local developer community!

.NET Day Franken Germany

  • Nürnberg, Germany: June 13
  • Xamarin.Forms with Mike James

Xamarin Dev Days Atlanta us

  • Atlanta, GA: June 13, 8:00am–5:00pm
  • Come learn about Xamarin with your local developer community!

Developer Week it

  • Nürnberg, Germany: June 15–18
  • iBeacons and Contextual Location Awareness in the Android track and Xamarin.Forms: Native apps from one C# Codebase in the Windows Phone track with Mike James

Introductory Training Session to Xamarin French Flag

  • Paris, France: June 15–19
  • Get an introduction to Xamarin and Xamarin University

NDC Oslo Norway

  • Oslo, Norway: June 15–19
  • Xamarin.Forms and CocosSharp with James Montemagno

New York Mobile .NET in

  • New York, NY: June 16, 6:30pm
  • Automated UI Testing and Monitoring for your Mobile Apps

Madison Mobile .NET Developers Group in

  • Madison, WI: June 17, 5:30pm–8:30pm
  • Getting Started with Apple Watch Development

Xamarin Dev Days Seattle us

  • Seattle, WA: June 28, 8:00am–5:00pm
  • Come learn about Xamarin with your local developer community!


The Xamarin Events Forum has MANY MORE upcoming Xamarin events, meetups, and presentations happening this month near you, so check it out if you don’t see an event in your area here.

Interested in getting a developer group started? We’re here to help! Here’s a tips and tricks guide on staring a developer group, an introduction to Xamarin slide deck, and of course our community sponsorship program to get you on your way. Also, we love to hear from you, so feel free to send us an email or tweet @XamarinEvents to help spread the word and continue to grow the Xamarin community.

Tweet about this on TwitterShare on FacebookShare on Google+Share on LinkedInEmail this to someone
May 26, 2015

IBM and Xamarin Partner to Simplify Secure Enterprise Mobility


IBM MobileFirst Protect LogoLast October, we announced a strategic partnership with IBM MobileFirst. Today, we’ve expanded our partnership to include industry-leading Enterprise Mobility Management (EMM) with IBM MobileFirst Protect.
The growth in mobile apps brings substantial opportunities to the enterprise, but also comes with significant risks, including: loss of data through device theft, employee misuse, or targeted attacks. With an increasingly mobile workforce, and employees’ ability to access company information from anywhere at anytime, companies must ensure their mobile strategy includes safeguards for data breaches and security threats.
We’ve established interoperability with IBM MobileFirst Protect to provide our customers with more comprehensive methods for securely delivering high quality native iOS and Android apps. This capability allows enterprises to wrap their Xamarin apps and leverage IBM MobileFirst Protect capabilities, such as: requiring an application PIN when using the protected application, jailbreak detection, and using MobileFirst app tunneling for secure access to corporate data. Additionally, IBM MobileFirst Protect can insulate enterprises with data loss prevention (DLP) in their mobile apps by restricting users’ ability to cut/copy/paste, print, or using “open in” functions outside of whitelisted apps.
Protect your Xamarin apps with IBM MobileFirst Protect in three easy steps:

  1. Build your Xamarin app.
  2. Upload the iOS and Android app packages to IBM MobileFirst Protect for containerization and configuration of security policies.
  3. Distribute and manage apps through the IBM MobileFirst Protect portal.

For more information about Xamarin and MobileFirst Protect, please visit xamarin.com/ibm.

Tweet about this on TwitterShare on FacebookShare on Google+Share on LinkedInEmail this to someone

Introducing the Xamarin Podcast


Today, I’m excited to announce a new season of the Xamarin Podcast. The Xamarin Podcast makes it easier, and more enjoyable, to learn everything new in the world of C#, .NET, and mobile development. Be sure to download the first two episodes of the Xamarin Podcast today and subscribe to ensure that you never miss any announcements, interesting blog posts, projects, or tips and tricks from fellow developers.

podcast icon

We are two episodes in to this season, and in the latest episode Pierce and I were joined by fellow Xamarin Developer Evangelist James Montemagno to discuss plugins for Xamarin. James gives us the run down on why you should use plugins and how to go about developing your own. We also discuss HomeKit, the latest Xamarin Profiler, new components for Google Services, and upcoming events.


Get Involved

Do you have an interesting story, project, or advice for other .NET mobile developers? If so, Pierce and I would love to share it with the Xamarin community! Tweet @XamarinPodcast to share your blog posts, projects, and anything else you think other mobile developers would find interesting.

Subscribe or Download Today

To make it easier than ever to hear the latest news in the .NET, C#, and Xamarin realm, the Xamarin Podcast is available from both iTunes and SoundCloud. Be sure to download the first two episodes today, and don’t forget to subscribe!

Download today


Tweet about this on TwitterShare on FacebookShare on Google+Share on LinkedInEmail this to someone
May 22, 2015

Case Study: Development Time Slashed by 50% for Leading Transport Company


mrw-logoMRW is Spain’s leading national and international express transport company. Powered by 10,000 people linked to the brand in over 1,300 franchises and 64 logistical platforms in Spain, Portugal, Andorra, Gibraltar, and Venezuela, MRW handles an average of 40 million parcel deliveries per year and ships to more than 200 countries and over 10,000 online stores.
A mission critical element of the company’s success is the MRWMobile app that supports 2,500 concurrent users in the field by helping them with process optimization, including delivery coordination. MRWMobile was developed by the company’s Portugal-based partner Moving2u, and after the successful creation of MRWMobile 3 for Windows, MRW wanted to expand to Android.
MRW app on HTC OneThe app is used in the field for a range of functions, including proof of picking up deliveries in real time, receiving new work orders, and for rescheduling order pick ups and deliveries—all while using secure communications and local data encryption. To support these functions, the app needs to support a range of capabilities, including offline work, local storage, push sync, multi-threading, barcode scanning, photos, and signature capture. The app also incorporates geolocation, multilingual support, multiple user profiles, mobile payment, printing, document scanning, and internal communications with messages and tasks.
The magnitude of requirements coupled with budget and conflicting project roadblocks created time-to-market challenges. “Without Xamarin, it would have taken at least twice as long to have the full feature set of the app built and tested,” says Alberto Silva, R&D Manager at Moving2u.
“Xamarin is the right approach for any serious Android, iOS, or mobile cross-platform app development,” Alberto adds. “Even if you don’t plan to go cross-platform, the productivity of Xamarin in producing an app for a single platform in C# is unmatched.”

View the Case Study

Tweet about this on TwitterShare on FacebookShare on Google+Share on LinkedInEmail this to someone