Some devices exposes a battery service that can supply us with the current (no pun intended) battery level.
I started this blog series working with only Windows phone in mind, but then I realized if it is possible to achieve the same results with an universal app of course that’s the route I should take.

Capabilities

To be able to communicate with Bluetooth low energy (or Bluetooth Smart, as it’s also called) you need to add a capability to your app.
This can’t be done from a GUI, you need to edit the package.appmanifest manually and add the following lines of code just above </Package>.
Don’t forget to do that in both your Windows 8 and Windows Phone projects.

  <Capabilities>
    <m2:DeviceCapability Name="bluetooth.genericAttributeProfile">
      <m2:Device Id="any">
        <m2:Function Type="name:battery"/>
      </m2:Device>
    </m2:DeviceCapability>
  </Capabilities>

Now you are are all set to start coding =)

Battery Level Service

The battery service must implement read, and notify is optional.
What that means is that you can always assume that you will be able to read the battery level (if your device implements the battery service, but you have to check if it supports Notify  (a good developer should always check ).

The value it returns is a byte with a value from 0 to 100 representing a percentage of the current charge (0 being fully discharged).

The property

This is just a standard property with a backing store.

 private int _BatteryLevel;
        public int BatteryLevel
        {
            get
            {
                return _BatteryLevel;
            }
            set
            {
                _BatteryLevel = value;
                OnPropertyChanged();
            }
        }

The interesting part is how we handle OnPropertyChanged to try to avoid “The application called an interface that was marshalled for a different thread”.
I found a very neat piece of code here.


My implementation looks like this:

        public event PropertyChangedEventHandler PropertyChanged;

        private readonly CoreDispatcher _dispatcher;
        protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
        {
            if (_dispatcher == null || _dispatcher.HasThreadAccess)
            {
                var eventHandler = this.PropertyChanged;
                if (eventHandler != null)
                {
                    eventHandler(this,
                        new PropertyChangedEventArgs(propertyName));
                }
            }
            else
            {
                IAsyncAction doNotAwait =
                    _dispatcher.RunAsync(CoreDispatcherPriority.Normal,
                    () => OnPropertyChanged(propertyName));
            }
        }

 public BatteryServicePage()
        {
            if (!DesignMode.DesignModeEnabled)
            {
                _dispatcher = CoreWindow.GetForCurrentThread().Dispatcher;
            }
          ........
        }

Reading a value

I have written a simple method that reads a value from the service and if it supports notification it will also start a subscription on those notifications.

 public async Task<byte[]> GetValue(Guid gattCharacteristicUuids)
        {
            try
            {
                var gattDeviceService = await GattDeviceService.FromIdAsync(Device.Id);
                if (gattDeviceService != null)
                {
                    var characteristics = gattDeviceService.GetCharacteristics(gattCharacteristicUuids).First();

                    //If the characteristic supports Notify then tell it to notify us.
                    try
                    {
                        if (characteristics.CharacteristicProperties.HasFlag(GattCharacteristicProperties.Notify))
                        {
                            characteristics.ValueChanged += characteristics_ValueChanged;
                            await characteristics.WriteClientCharacteristicConfigurationDescriptorAsync(GattClientCharacteristicConfigurationDescriptorValue.Notify);
                        }
                    }
                    catch { }

                    //Read
                    if (characteristics.CharacteristicProperties.HasFlag(GattCharacteristicProperties.Read))
                    {
                        var result = await characteristics.ReadValueAsync(BluetoothCacheMode.Uncached);

                        if (result.Status == GattCommunicationStatus.Success)
                        {
                            byte[] forceData = new byte[result.Value.Length];
                            DataReader.FromBuffer(result.Value).ReadBytes(forceData);
                            return forceData;
                        }
                        else
                        {
                            await new MessageDialog(result.Status.ToString()).ShowAsync();
                        }
                    }
                }
                else 
                {
                    await new MessageDialog("Access to the device has been denied =(").ShowAsync();
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }
            return null;
        }

You can simply call the method like this:

BatteryLevel = Convert.ToInt32((await GetValue(GattCharacteristicUuids.BatteryLevel))[0]);

You also need a callback method that can handle the notifications.

  void characteristics_ValueChanged(GattCharacteristic sender, GattValueChangedEventArgs args)
        {
            byte[] data = new byte[args.CharacteristicValue.Length];
            Windows.Storage.Streams.DataReader.FromBuffer(args.CharacteristicValue).ReadBytes(data);

           //Update properties
            if (sender.Uuid == GattCharacteristicUuids.BatteryLevel)
            {
                BatteryLevel = Convert.ToInt32(data[0]);
            }
        }

Now your app can retrieve battery level from a Bluetooth LE device. How awesome is that?

BatteryDemo.zip (289.18 kb)

Introduction

In this blog post we will do the Android version of this app. This includes creating the new project, adding MvvmCross, implementing device specific services and of course implement the user interface. This will be a rather long post, so let’s get started.

Setting up the Project

First, let’s create the new project. Right-click on the solution, choose, Add => New Project. Choose the Android tab and create an Android application named Runner.Droid like this:

Add a reference to the Runner.Core portable class library. Right-click on the solution, choose Manage NuGet packages for solution, click Installed Packages and select MvvmCross.

Click the checkbox for Runner.Droid and press OK.

Now we’ve added references to our portable class library as well as to MvvmCross. Also remove MainActivity.cs, Views\FirstView.cs and Resources\layout\FirstView.axml + Main.axml since we are going to build our own user interface. As usual, we get a ToDo-MvvmCross folder with instructions, but we have already done those.

Go into properties for your Android project and make sure that you have at least API Level 12, since we use fragments in this app, like this:

We are all setup, let’s start building our app!

Implementing the services

Let’s start with the bottom layer. First, create a folder named Service. We have two platform specific services that needs implementation, IPeriodicService and IPositionService. Implementing IPeriodicService is trivial, it uses System.Threading.Timer. Here is the code for PeriodicService.cs:

namespace Runner.Droid.Service
{
    public class PeriodicService : IPeriodicService
    {
        #region Private fields
        private Timer _poller = null;
        #endregion

        #region Public methods
        public void Start()
        {
            _poller = new Timer(_poller_Tick, null, TimeSpan.Zero, TimeSpan.FromSeconds(1));
        }

        public void Stop()
        {
            if (_poller != null)
            {
                _poller.Dispose();
                 _poller = null;
            }
        }

        #endregion

        #region Callbacks
        void _poller_Tick(object sender)
        {
            if (Ticked != null)
                 Ticked(this, new EventArgs());
        }
         #endregion

        #region Events
        public event TickedEventHandler Ticked;
        #endregion
    }
}

We also have to implement IPositionService. The stock Android emulator I use when presenting doesn’t have the ability to generate location triggers, so PositionService.cs is just a fake that has a predefined set of coordinates that it loops around. Here is the code for this:

namespace Runner.Droid.Service
{

    public class PositionService : IPositionService
    {
        public class GpsData
         {
            public double Latitude { get; set; }
             public double Longitude { get; set; }
        }

        List<GpsData> GpsDataPoints = new List<GpsData> {
            new GpsData{Latitude=59.2403462746883,Longitude=17.9230690210418},
             new GpsData{Latitude=59.240486746198, Longitude=17.9230003559093},
            new GpsData{Latitude=59.240697452377, Longitude=17.9233093490056},
            new GpsData{Latitude=59.240820363714, Longitude=17.9236870072345},
            new GpsData{Latitude=59.241039847142, Longitude=17.9240989980296},
             new GpsData{Latitude=59.241180315795, Longitude=17.9244594899753},
            new GpsData{Latitude=59.241355900797, Longitude=17.9248714807704},
            new GpsData{Latitude=59.241522705712, Longitude=17.9252491389993},
            new GpsData{Latitude=59.241663172376, Longitude=17.925609630945},
            new GpsData{Latitude=59.241856313093, Longitude=17.9260559543064},
            new GpsData{Latitude=59.242049452717, Longitude=17.9264507788183},
            new GpsData{Latitude=59.242181138197, Longitude=17.9267941044809},
            new GpsData{Latitude=59.242365497014, Longitude=17.9272575941254},
            new GpsData{Latitude=59.242532296990, Longitude=17.9277039174868},
             new GpsData{Latitude=59.242646422819, Longitude=17.9280987419988},
            new GpsData{Latitude=59.242830779121, Longitude=17.9284592339445},
            new GpsData{Latitude=59.242997576821, Longitude=17.9288540584564},
            new GpsData{Latitude=59.243120479867, Longitude=17.9291458852697},
             new GpsData{Latitude=59.243111701093, Longitude=17.9294205457997},
            new GpsData{Latitude=59.242892231000, Longitude=17.9294720446491},
            new GpsData{Latitude=59.242734211659, Longitude=17.9294720446491},
            new GpsData{Latitude=59.242576191585, Longitude=17.9295235434985},
             new GpsData{Latitude=59.242444507631, Longitude=17.9295750423479},
            new GpsData{Latitude=59.242383054945, Longitude=17.9295750423479},
            new GpsData{Latitude=59.242225033244, Longitude=17.9296437074804},
            new GpsData{Latitude=59.242084568895, Longitude=17.9295750423479},
            new GpsData{Latitude=59.241952883042, Longitude=17.9294720446491},
            new GpsData{Latitude=59.241838754891, Longitude=17.9293690469503},
            new GpsData{Latitude=59.241707068089, Longitude=17.9292317166853},
            new GpsData{Latitude=59.241628055764, Longitude=17.929060053854},
            new GpsData{Latitude=59.241478809761, Longitude=17.9289398898721},
             new GpsData{Latitude=59.241364680024, Longitude=17.9288025596071},
            new GpsData{Latitude=59.241312004632, Longitude=17.9287338944746},
            new GpsData{Latitude=59.241268108409, Longitude=17.928390568812},
            new GpsData{Latitude=59.241180315795, Longitude=17.9280644094325},
             new GpsData{Latitude=59.241118860831, Longitude=17.9277039174868},
            new GpsData{Latitude=59.241074964360, Longitude=17.9273262592579},
            new GpsData{Latitude=59.240995950570, Longitude=17.9268971021797},
            new GpsData{Latitude=59.240916936597, Longitude=17.9265194439509},
            new GpsData{Latitude=59.240846701800, Longitude=17.9260902868726},
            new GpsData{Latitude=59.240776466859, Longitude=17.9257641274932},
            new GpsData{Latitude=59.240697452377, Longitude=17.9253693029812},
            new GpsData{Latitude=59.240653555364, Longitude=17.9249744784692},
            new GpsData{Latitude=59.240583320025, Longitude=17.9246139865235},
             new GpsData{Latitude=59.240495525648, Longitude=17.9243393259934},
            new GpsData{Latitude=59.240442848913, Longitude=17.9238758363489},
            new GpsData{Latitude=59.240390172097, Longitude=17.923618342102},
            new GpsData{Latitude=59.240319936215, Longitude=17.9232750164394},
             new GpsData{Latitude=59.240355054174, Longitude=17.9230518547587},
        };

        private Timer timer;
        private int counter = 0;
        public void Start()
        {
             timer = new Timer((state) =>
            {
                if (PositionChanged != null)
                    PositionChanged(this, new PositionChangedArgs(DateTime.Now, GpsDataPoints[counter].Latitude, GpsDataPoints[counter++].Longitude, 0));
             }, null, TimeSpan.Zero, TimeSpan.FromSeconds(10));
        }

        public void Stop()
        {
            if (timer != null)
            {
                timer.Dispose();
                 timer = null;
                counter = 0;
            }
         }

        public event PositionChangedEventHandler PositionChanged;

        public event StatusChangedEventHandler StatusChanged;
    }
}

Finally, as for the Windows Phone app, we need to help the IoC container to resolve these interfaces. Also, let’s move the event handler for PositionChanged event from app.xaml.cs to Setup.cs (since Android has no similar concept. Setup.cs then should add these lines):

protected override void InitializeLastChance()
{
    base.InitializeLastChance();
    Mvx.LazyConstructAndRegisterSingleton<IPositionService, PositionService>();
    Mvx.LazyConstructAndRegisterSingleton<IPeriodicService, PeriodicService>();

    var positionService = Mvx.Resolve<IPositionService>();
    if (positionService != null)
         positionService.PositionChanged += _positionService_PositionChanged;
}

void _positionService_PositionChanged(object sender, PositionChangedArgs e)
{
    Mvx.Resolve<IDataPointCollectionService>().AddDataPoint(new DataPointPosition()
     {
        Latitude = e.Latitude,
        Longitude = e.Longitude,
        Altitude = e.Altitude,
        Time = (e.Time.HasValue ? e.Time.Value : DateTime.Now)
    });
}

Implementing the user interface

The paradigms for user interfaces in Android is different but similar as in XAML. They both have the concept of XML to describe the user interface and code-behind in C# (when using Xamarin). In XAML we have pages, in Android we have activities. One difference is that in Android the design and the code behind is loosely coupled, where as in Windows Phone they are tightly coupled together. In Windows you can do user controls to create reusable components, in Android they are called fragments.

To build the user interface, we will replace the pivot in Windows Phone with a tab in Android. For brevity, I will not implement the map control in Android. So, we will add all the files necessary and highlight key concepts. After adding all the files, our Resources\Layout folder should look like this:

and our Service and Views folders should look like this:

If you look into these files they are pretty vanilla except for the use of binding, both for data and commands. Here’s the definition for the Start button:

<Button
    android:textSize="22sp"
    android:layout_width="0dp"
    android:layout_height="wrap_content"
    android:layout_weight="1"
    android:id="@+id/btnStart"
    local:MvxBind="Click StartExerciseCommand"
    android:text="Start" />

Notice the bind command that associates the Click event with the StartExerciseCommand in the view model. Also, look at this snippet from currentFragment.xaml to illustrate how we data bind properties:

<TextView
    android:textSize="22sp"
     android:layout_width="match_parent"
    android:layout_height="wrap_content"
    local:MvxBind="Text Time" />

Here bind again, this time the Text property of the TextView to the Time property in the view model.

Tying it altogether is MainView.cs, which is the code behind for our page (or activity). The code looks like this:

namespace Runner.Droid.Views
{
    [Activity(Label = "Runner")]
    public class MainView : MvxTabsFragmentActivity
    {
        public new MainViewModel ViewModel
        {
            get { return (DataContext as MainViewModel); }
        }

        public MainView()
            : base(Resource.Layout.MainView, Resource.Id.actualtabcontent)
         {
        }

        protected override void AddTabs(Bundle args)
        {
            try
            {
                 AddTab<CurrentTabFragment>("Current", "Current", args, ViewModel.Current);
                AddTab<TotalTabFragment>("Total", "Total", args, ViewModel.Total);
                AddTab<LapTabFragment>("Lap", "Lap", args, ViewModel.Lap);
                 AddTab<MapTabFragment>("Map", "Map", args, ViewModel);
             }
            catch (Exception ex)
            {
             }
        }

        protected override void OnStart()
        {
            base.OnStart();
            ViewModel.CollectionService.Start();
            ViewModel.PeriodicService.Start();
            ViewModel.PositionService.Start();
         }

        protected override void OnStop()
        {
             ViewModel.PositionService.Stop();
            ViewModel.PeriodicService.Stop();
            ViewModel.CollectionService.Stop();
            base.OnStop();
         }
    }
}

This is pretty much it. Press F5 and watch the app run in all it’s glory

Summary

I hope I have shown you how easy it is to develop a cross-platform app based on Xamarin/MvvmCross. Remember that since Xamarin keeps the UI code and paradigms native, you still need to understand the platform and it’s frameworks However, given that we have a single code base, single programming language and a single development tool we will save a lot of development time in our projects. Happy Coding!

Introduction

This series will provide a step-by-step instruction on how to port a small Windows Phone app to Android, using Xamarin and MvvmCross. This post will explain some basic concepts, what the app does and how the code is structured.

What is Xamarin?

Xamarin is a third-party tool that enables you to write apps for Android, iOS and OS/X in C# using .NET framework but doing the user interface natively with the designers for each platform. Xamarin then generates native executable code, so the apps are indistinguishable from real native apps. The core benefit of this approach is to have all non-UI related code in C#/.NET in shared in one place, to be able to reuse it on multiple platforms. Often we see that up to 80% of the code gets reused between platforms, opening up to huge cost-savings when doing cross-platform development work. Xamarin also integrates nicely into Visual Studio, giving you a very efficient and agile development environment.

What is MvvmCross?

MvvmCross is an open-source, cross-platform framework that implements the MVVM pattern on all the above mentioned platforms. It will also give you the ability to use data binding on all these platforms, which is a very effective way to use code written with the MVVM pattern.

What is MVVM?

MVVM is a pattern for writing user interface code. MVVM stands for Model – View – ViewModel and is a variation of the MVC (Model – View – Controller) pattern. The different parts is as follows:

• Model. Here is where you put all your entity classes and the services to provide you with operations on those. This code is not related to the UI at all and can be shared completely between platforms, par device specific stuff like position tracking etc. These implementations need to be implemented per client and we will look at how that is done in the most portable way.
• View. This layer contains all the views and the code needed to drive the user interaction. This is always done per platform and with Xamarin you use the designer etc. for the platform. We also program against the native framework, but wrapped in .NET framework wrapper classes so we can write this code in C# as well.
• ViewModel. This is the glue between the model and the views. For each view we should have a companion view model, and the view model should contain all the data for the view as properties. It should also contain all the commands the view needs to work with the data. The view model then makes calls down to the service layer and use the entities from the model. Data binding from the views is a very powerful construct that gives us a very responsive UI with almost no code at all, so this is used throughout the code.

How is the code structured?

Our phone app, which we ultimately want to port to Android, is a simple little app for tracking your running activities, like RunKeeper, Endomondo etc. It’s very simple but illustrates the basic concepts and provides a good base to illustrate how we port this. This is how the app looks like an action:

So, its basically a pivot with four views, current, total, lap and map. We have an app bar that has start, stop and lap buttons. On the lap page, there is a list of completed laps. That’s the app and we can run it in the emulator since we can fake a series of location updates with the excellent Windows Phone emulator.

As mentioned above, the code is written using the MVVM pattern, so we have the following folders in our project:

Model

Here we have a class that holds a single data Point (in our case a location at a specific time) and an interface and stock implementation of metrics around a Collection of data Points (speed, distance etc.).

Services

Here we have defined three interfaces and done three concrete implementations:

• Collection service (IDataPointCollectionService.cs, DataPointCollectionService.cs). This holds an internal collection of the data points collected. This is a singleton service, meaning that we only want one instance of this service running. Key implementation here is an event that is triggered when we get a new data point, driving updates to the user interface. This implementation is not platform specific and can be shared across platforms.
• Position service (IPositionService.cs, PositionService.cs). This service listen for location updates from the phone and sends them to the collection service. This is a platform specific service, and needs to be reimplemented for each platform.
• Periodic service (IPeriodicService.cs, PeriodicService.cs). This services fires an event every second, since we need to recalculate metrics regularly, even though we don’t get location updates. This is also a platform specific implementation.

ViewModels

Here we define the view models that drives the user interface. I have chosen to a MainViewModel that contains the view models for the different pivots current, total and lap. I have also written a base class for all view models (ViewModelBase) and a base class for all pivots (DataPointMetricsViewModel). All properties propagate changes so that the user interface gets updated automatically.

The rest of the project is pretty vanilla from the templates. MainPage.xaml has the user interface.

Summary

So this is the base we start from when we port this app to Android. Our first step is to extract all reusable code into a portable class library. Blog post is here.

Also, if you are interested at this you should attend TechDays at Kistmässan 18-20 November 2014. There will be a preconference day where I and some colleagues will spend an entire day talking about this subject. More info can be found here.

Introduction

Before we start our Android implementation, we need to do one more thing. Since we have used the MVVM pattern for the Windows Phone app, we want to continue to do so. This is not a requirement of course, but for the purpose of this article we will. The steps we need to take is to add the NuGet package and modify the code slightly to adhere to the requirements of this framework.

MvvmCross principles

MvvmCross is an intention-based framework, which means that it relies on naming conventions for finding classes to instantiate etc. It is also a view model-first framework, putting the view models in the center and instantiating views from this. MvvmCross also includes it’s own IoC-container which it relies on. IoC stands for Inversion of Control and helps us create classes through a central repository, giving us less code to write and easier to exchange implementations.

Adding MvvmCross to the Portable Class Library

First, let’s install the NuGet package for MvvmCross into the Runner.Core portable class library project. Right-click on the Runner.Core Project, select Manage NuGet packages. Click Online tab and then search for MvvmCross and install the Component as shown below:

Click the Close button and examine your project. Your References now includes MVVM libraries. There is also a new ToDo-MvvmCross folder with instructions on how to port your product to MvvmCross:

If we open the _Core.txt file we can see a checklist with the following items:

• Create a ViewModels folder and add a view model. We have already done this, although we need to modify the view model. It should derive from MvxViewModel. Since we have a ViewModelBase base class, we modify that. Open ViewModelBase.cs, change it to derive from MvxViewModel and only keep the SetProperty functions. It should look like this:

• Add an App.cs class – inside it place the code to start the app with the main view model. The file has been auto-generated, let’s just replace the name of the view model we want the app to start with. Here’s the content of App.cs:

This code will also register all our *Service.cs classes with the IoC container for automatic creation. More on this later. Now we completed the porting for our library. Let’s port the phone app as well.

Adding MvvmCross to the phone app

We need to go through a similar process here. First, let’s add the NuGet package to the Phone app as well. Right-click on the solution, select Manage NuGet packages for solution…, click Installed Packages, select MvvmCross and click manage:

Click in the checkbox next to Runner.WP as this:

If we look at the Runner.WP Project, it has added a number of references and a ToDo-MvvmCross folder here as well. The steps we need to take now are as follows:

• Add a reference to our portable class library. We already had that.
• The Setup.cs file was automatically created and we leave it as is for know.
• Change App.Xaml.cs so that it creates a 'new Setup(RootFrame)' during its constructor. I add the code the InitializePhoneApplication() function like this:

• Change App.Xaml.cs so that it intercepts the first navigation. The code should look like this:

• Add a Views folder - it must be called "Views" - and in this place a view - xaml.cs and .xaml. It must derive from MvxPhonePage. Important note. The page must also reside in the Views namespace otherwise the IoC container can’t find it. So, in the Views folder remove FirstView.xaml and move MainPage.xaml there. Then edit the MainPage.xaml and MainPage.xaml.cs to reside in the Views sub-namespace and that it derives from MvxPhonePage.

Now, we have completed the steps and when we run the application we can see that it behaves as before. Great! Are we done? No, not yet. Remember that we talked about MvvmCross being a viewmodel-first framework? This means that the view model is created first, and from the view model the correct page is created and properly setup, including setting the viewmodel as the DataContext for the page. But in MainPage.xaml.cs, we implicitly create the MainViewModel in the constructor. Let’s remove this and run again.

Now we get an exception when the view model is created. Turns out the problem is that the MainViewModel takes instances of our services in the constructor, and the IoC container doesn’t know how to create concrete instances of IPeriodicService and IPositionService. We have to provide MvvmCross with a mapping for these two interfaces. We do this in Setup.cs in the phone app like this:

We run again and now the view comes up, but the position changes doesn’t come through. Why? The reason is that now have two singletons, one explicit in App.xaml.cs and one implicit when we registered the mapping in the IoC container. We need to remove our explicit construction and reference the implicit one. In app.xaml.cs, remove all references to our service properties and replace it with the following code in InitializePhoneApplication():

And update the code in PositionChanged event handler to look like this:

Now, run the program again and see that it works now.

Summary

Here we have shown how to add the MvvmCross framework to your existing application. We have shown some of the caveats you can run into. Now we are properly setup to write the Android version of this app. Let’s go! Blog post is here.

Introduction

First we need to prepare the codebase so that we can reuse common code across platforms. There are different ways we can do this, but today we are going to move the code to a portable class library. A portable class library is a special .NET assembly where you target the platforms you want the code to run on. This will automatically limit the the part of .NET framework available to what’s common on your chosen platforms.

What’s great about this is that Xamarin for Android and Xamarin for iOS can be chosen as targets for this library. That means that we can move all our common code into this reusable Component to kick-start our Android development later. We will move all code that’s not view related or device specific. Here is how you do this.

Moving the code

So, this is what the project looks like today:

First, right-click on the solution, choose Add –> New Project… and select to create a new Portable Class Library as per below:

Hit OK and assuming that you have Xamarin for iOS and Android installed, check in the following boxes and press OK one more time:

Now, let’s move things over to portable class library. Start by removing Class1.cs, since it’s not needed. Then copy everything in Model, Service and ViewModels folders. Keep everything in the portable class library except PeriodicService.cs and PositionService.cs, and keep only these files in the Phone project. You should end up with a project structure like this:

One final thing to do; make sure that the phone project references the portable class library project:

Now, press F5 and see that we have the same functionality as before, but now all common code has been separated into a separate library, settings us up nicely for cross-platform development. We are moving closer to an Android version, but first we need to do one more step. Let’s port our code to use the MvvmCross framework.

Summary

I hope I have shown how easy it is to move your common code to a portable class library, and be ready for cross-platform development. Blog post about adding MvvmCross is here.

Introduction

With Windows phone 8.1 Microsoft also released the ability to communicate with Bluetooth Low Energy devices.
This is really exciting for Windows phone developers, this way we can start developing apps that can talk to devices without draining the battery dry.

Sadly this is not available in the developer preview of Windows phone 8.1, but will be available when Windows Phone 8.1 is released for general availability.

Pairing

The first step is always to pair with the device you want to connect to. This is easy to do by going to Settings –> Bluetooth on your phone and tapping on the device you wish to pair with, just as you would do with a  “ordinary” Bluetooth device.

Capabilities

To be able to communicate with Bluetooth Low energy (or Bluetooth Smart, as it’s also called) you need to add a capability to your app.
This can’t be done from a GUI, you need to edit the package.appmanifest manually and add the following lines of code just above </Package>.

<Capabilities>
  <m2:DeviceCapability Name="bluetooth.genericAttributeProfile">
    <m2:Device Id="any">
      <m2:Function Type="serviceId:1803"/>
    </m2:Device>
  </m2:DeviceCapability>
</Capabilities>

Now you are are set to start coding =)

Iterate through devices

To keep this as simple as possible, I’ll just show you how to iterate through devices and pick up a predefined one.

BluetoothLEDevice currentDevice { get; set; }
string deviceName = "Philips AEA1000";
protected async override void OnNavigatedTo(NavigationEventArgs e)
{
    foreach (DeviceInformation di in await DeviceInformation.FindAllAsync(BluetoothLEDevice.GetDeviceSelector()))
    {
        BluetoothLEDevice bleDevice = await BluetoothLEDevice.FromIdAsync(di.Id);
        if (bleDevice.Name == deviceName)
        {
            currentDevice = bleDevice;
            break;
        }
    }
}

Find out what your device can do

GATT (Generic Attribute Profile) provides profile discovery and description services for Bluetooth Low Energy protocol, it basically makes it possible to ask your device what it can do. The documentation for this is very thorough and shows how to communicate.

Here is how to get a list of the GATTServices your device supports.

List<string> serviceList = new List<string>();
foreach (var service in currentDevice.GattServices)
{
    switch (service.Uuid.ToString())
    {
        case "00001811-0000-1000-8000-00805f9b34fb":
            serviceList.Add("AlertNotification");
            break;
        case "0000180f-0000-1000-8000-00805f9b34fb":
            serviceList.Add("Battery");
            break;
        case "00001810-0000-1000-8000-00805f9b34fb":
            serviceList.Add("BloodPressure");
            break;
        case "00001805-0000-1000-8000-00805f9b34fb":
            serviceList.Add("CurrentTime");
            break;
        case "00001818-0000-1000-8000-00805f9b34fb":
            serviceList.Add("CyclingPower");
            break;
        case "00001816-0000-1000-8000-00805f9b34fb":
            serviceList.Add("CyclingSpeedAndCadence");
            break;
        case "0000180a-0000-1000-8000-00805f9b34fb":
            serviceList.Add("DeviceInformation");
            break;
        case "00001800-0000-1000-8000-00805f9b34fb":
            serviceList.Add("GenericAccess");
            break;
        case "00001801-0000-1000-8000-00805f9b34fb":
            serviceList.Add("GenericAttribute");
            break;
        case "00001808-0000-1000-8000-00805f9b34fb":
            serviceList.Add("Glucose");
            break;
        case "00001809-0000-1000-8000-00805f9b34fb":
            serviceList.Add("HealthThermometer");
            break;
        case "0000180d-0000-1000-8000-00805f9b34fb":
            serviceList.Add("HeartRate");
            break;
        case "00001812-0000-1000-8000-00805f9b34fb":
            serviceList.Add("HumanInterfaceDevice");
            break;
        case "00001802-0000-1000-8000-00805f9b34fb":
            serviceList.Add("ImmediateAlert");
            break;
        case "00001803-0000-1000-8000-00805f9b34fb":
            serviceList.Add("LinkLoss");
            break;
        case "00001819-0000-1000-8000-00805f9b34fb":
            serviceList.Add("LocationAndNavigation");
            break;
        case "00001807-0000-1000-8000-00805f9b34fb":
            serviceList.Add("NextDstChange");
            break;
        case "0000180e-0000-1000-8000-00805f9b34fb":
            serviceList.Add("PhoneAlertStatus");
            break;
        case "00001806-0000-1000-8000-00805f9b34fb":
            serviceList.Add("ReferenceTimeUpdate");
            break;
        case "00001814-0000-1000-8000-00805f9b34fb":
            serviceList.Add("RunningSpeedAndCadence");
            break;
        case "00001813-0000-1000-8000-00805f9b34fb":
            serviceList.Add("ScanParameters");
            break;
        case "00001804-0000-1000-8000-00805f9b34fb":
            serviceList.Add("TxPower");
            break;
        default:
            break;
    }
}
MessageDialog md = new MessageDialog(String.Join("\r\n", serviceList));
md.ShowAsync();

Time for some fun, Lets make it beep!

In my case I have a Key finder (key fob) and it implements (among other services) the Immediate Alert Service, which makes it possible to make it beep.
The GATT specification shows us how to communicate with the ImmediateAlertService
Download the PDF here.

The documentation shows us that if we want to set the alert level we need to do that with “Write without Response”.
The different values for Alert Level can be found here.

Value 0, meaning “No Alert”

Value 1, meaning “Mild Alert”

Value 2, meaning “High Alert”

This snippet will make the key finder (key fob) sound a high alert.

var immediateAlertService = currentDevice.GetGattService(GattServiceUuids.ImmediateAlert);
var characteristics = immediateAlertService.GetCharacteristics(GattCharacteristicUuids.AlertLevel).First();
byte[] data = new byte[1];
data[0] = (byte)2;
await characteristics.WriteValueAsync(data.AsBuffer(), GattWriteOption.WriteWithoutResponse);

In my next blog post I will go through more of the things you can do with a key finder (key fob).

App packaging with appx

When it comes to packaging and distribution of apps - Xap is out, Appx is in. Appx is the package model used by the Windows Store and offers some additional features over xap.

Appx generation

To generate an appx package for your app, you invoke the Store menu, and choose to create application package.

You then get to choose what platform and configuration you want to build – and also whether to create an app bundle or not, more on that later.

This process generates one binary appxupload file per configuration, and a folder postfixed Test that contains the appx and other files, for deployment testing before upload to the Store.

And looking inside one of the Test folders, we find the actual appx file, together with a binary appxsym file:

Appx overview

An appx contains the entire app, it is actually just a zip file with a different extension. Looking inside the actual appx file, and the Assets folder, we find all the files for the app:

Noteworthy here is:

App.xbf                 With the XAML stack from Windows comes the Xaml Binary Format, pre-compiled Xaml – a big performance win, especially on app startup

.scale-240.png     Apparently the app ships with scaling level 240 – on Windows we have 100, 140 and 180.

Bundles

App bundles allow the resources of an app to be partitioned based on three parameters:

• Localization
• Scaling
• DirectX feature level

When creating a bundle, you enable the Windows Phone Store to only download the resources needed for that specific device.

To demonstrate this I’ve added some resource files to the project, both a different scaling level and two more languages (en-us Is the default).

You choose to create a bundle on the package creation page:

And the resulting package files are instead just one big bundle.

Looking inside the appx for the bundle we find one appx per non-default resource-partition.

Links

BUILD 2014: App Packaging and Deployment for Windows Devices

Packaging, deployment, and query of Windows Store apps

App packaging

Games with resource packages sample

Package your Windows Store DirectX game

Intro

When

How to

using Windows.Security.Credentials
…
// public PasswordVault()
var vault = new.PasswordVault();

// public void Add(PasswordCredential credential)
vault.Add(new PasswordCredential("resourceName", “username”, “password”));

// public IReadOnlyList RetrieveAll()
Var list=vault.RetrieveAll();

// public IReadOnlyList FindAllByUserName(string userName)
var list = vault.FindAllByUserName(“username”);

// public IReadOnlyList FindAllByResource(string resource)
var list = vault.FindAllByResource(“resourceName”);

// public PasswordCredential Retrieve(string resource,string username)
var list = vault.Retrieve(“resourceName”, “username”);

// public void Remove(PasswordCredential credential)
vault.Remove(new PasswordCredential("resourceName, userName, password));

Best practices

• Use the Credential Locker to store passwords, not large data blocks.
• Make sure the user has successfully signed in and opted to save passwords before storing them in the Credential Locker.

Summary

Dude… what is going on here?!

Creating the background service

Adding the lib

public sealed class AudioPlayer : IBackgroundTask
{
private BackgroundTaskDeferral _deferral;
public void Run(IBackgroundTaskInstance taskInstance)
    {
        _deferral = taskInstance.GetDeferral();
        taskInstance.Canceled += TaskInstance_Canceled;
    }
private void TaskInstance_Canceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
    {
        _deferral.Complete();
    }
}

Enabling the background player

Open the app manifest. In Declarations add a BackgroundTask, then check the Audio task type and point the Entry Point to the AudioPlayer class that we created in the previous part. It should look something like the following

After this, we need to reference the Windows Runtime Component in the app project. There is no need to use a BackgroundTaskBuilder for an Audio task. The way we start the background task is by simply by accessing BackgroundMediaPlayer.Current. You can verify this by adding a break point in the AudioPlayer class. That’s it for the basic set up. Next up is how we use the code we have made to play some music.

Background player

Playing music

Play next song when the current song ended

Hey where is the “Tag”?! (Communication with the foreground app)

Changing song from the foreground

BackgroundMediaPlayer.Current.SetUriSource(new Uri("ms-appx:///Assets/Media/Ring02.wma"));
BackgroundMediaPlayer.Current.Play();

Changing song from the background

BackgroundMediaPlayer.SendMessageToBackground(new ValueSet { { "play", "0" } });

BackgroundMediaPlayer.MessageReceivedFromForeground += BackgroundMediaPlayer_MessageReceivedFromForeground;

Listen to event from the system

systemmediatransportcontrol = SystemMediaTransportControls.GetForCurrentView();
systemmediatransportcontrol.ButtonPressed += systemmediatransportcontrol_ButtonPressed;
systemmediatransportcontrol.PropertyChanged += systemmediatransportcontrol_PropertyChanged;
systemmediatransportcontrol.IsEnabled = true;
systemmediatransportcontrol.IsPauseEnabled = true;
systemmediatransportcontrol.IsPlayEnabled = true;
systemmediatransportcontrol.IsNextEnabled = true;
systemmediatransportcontrol.IsPreviousEnabled = true;

BackgroundMediaPlayer.MessageReceivedFromBackground += BackgroundMediaPlayer_MessageReceivedFromBackground;

Summary

Introduction

What is the same as before

var localFolder = ApplicationData.Current.LocalFolder;
var localFile = await localFolder.CreateFileAsync("localFile.txt", CreationCollisionOption.ReplaceExisting);            
var fileBytes = System.Text.Encoding.UTF8.GetBytes("some text string");
using (var s = await localFile.OpenStreamForWriteAsync())
{
    s.Write(fileBytes, 0, fileBytes.Length);
}

What is new

var tempFolder = ApplicationData.Current.TemporaryFolder;
var tempFile = await roamingFolder.CreateFileAsync("tempFile.txt", CreationCollisionOption.ReplaceExisting);
await FileIO.WriteTextAsync(tempFile, "some text string");

TemporaryFolder

RoamingFolder

applicationData.DataChanged += DataChangedHandler;

private async void DataChangedHandler(ApplicationData appData, object o)
{
    // Add code
}

RoamingStorageQuota

How much data can you roam? By calling RoamingStorageQuota you get the amount of data possible to roam. If you try to roam more data than RoamingStorageQuota specifies the system stop replication the data until it below the limit again. The normal amount of data possible to roam is 100kb.

var quota = applicationData.RoamingStorageQuota;

Settings

The settings saving is also the same as Windows 8.1. Instead of targeting LocalStorage it is possible to target LocalSettings, there is also a RoamingSettings. This works the same as folders does, local saves locally and roaming saves to the cloud. How do settings work then? Quite easy actually, just fetch the settings and save:

var roamingSettings = ApplicationData.Current.RoamingSettings;
roamingSettings.Values["MySetting"] = "Hello World";

In addition to save text to a setting one can save a composite value. This is a setting which contains several settings:

var composite = new ApplicationDataCompositeValue();
composite[settingName1] = 1;
composite[settingName2] = "world";
roamingSettings.Values["MyCompositeSetting"] = composite;

It is also possible to create containers in the settings. This for making it easier to structure the settings. Example of a container:

var container = localSettings.CreateContainer("exampleContainer", ApplicationDataCreateDisposition.Always);
if (localSettings.Containers.ContainsKey("exampleContainer"))
{
    localSettings.Containers["MyContainer"].Values["MySetting"] = "Hello Windows";
}

If you use RoamingSettings changes can also be detected using the

applicationData.DataChanged += DataChangedHandler;

Version

If you´re saving data and update your app you might need to use versioned data. Versioning enables you to change the application data format used in a future release of your app without causing compatibility problems with previous releases of your app. The app checks the version of the data in the data store, and if it is less than the version the app expects, the app should update the application data to the new format and update the version. The version start at zero and can be obtain by checking

var version = ApplicationData.Current.Version;

if the version is lower than the expected to some converting and set the version to the correct one

ApplicationData.Current.SetVersionAsync(1, SetVersionHandler);

Summary