Mobile Development

Why setting a control Height and Width to 0 is not the brightest idea inside a Windows Phone project

2013-05-15T21:34:00.000+02:00

I am doing this small post because I have battled the whole morning with this bug and finally got it and it might save you some time if you read it and have the same problem.

Scenario: Pivot with two items and at some point the swipe on one of the items doesn't work anymore. Putting a button on the PivotItem that doesn't swipe I can still change the selected item and the second item still swipes correctly.

Cause: I was setting the Height=0 and Width=0 on a control inside the PivotItem (in my project I don't want my control to be collapsed). The problem presents itself if you set any of the controls inside a PivotItem to Height and Width = 0 when the PivotItem is selected. If on the other hand you set the Height and the Width to anything >1 the PivotItem continues to swipe correctly. Even more strange: if the PivotItem is not selected when you set the Width and Height to 0 and swipe to the control's PivotItem everything will still work correctly. So pay attention better not use set Width and Height =0 on UI controls.

If you want to test it yourself and maybe tell me what really happens I am attaching a small project created from a Windows Phone Pivot application where I've added a menu that will set the Height and Width of the list inside the first PivotItem to 0. I also set the background of the first PivotItem to green so you will see that it is still expanded.

How to reproduce the problem: If you execute the menu command with the first PivotItem selected you will see that the pivot doesn't swipe anymore. If you change the values to 1, run the app again and execute the menu with the first PivotItem selected you will see that the pivot still swipes correctly. If, on the other hand, you let the values set to 0 but when executing the menu you have the second PivotItem selected you will see that the first item stil swipes correctly. Bug? Feature? Just pay attention to setting controls to Width and Height 0 because you might have problems with the UI and you won't know what is causing it.

SOURCE CODE

NAMASTE

Fix Panorama layout when upgrading your project to OS 8.0 SDK

2013-05-13T19:24:00.000+02:00

This will be a really short blog post but might save you some time if you have an OS 7.1 Panorama project and decide to upgrade the project to 8.0 SDK. After the upgrade you might see that the layout of your old page changed and you have less content available for the items and also the header looks different. Don't try to fix the problem by changing the margin of the control on the OS 8.0 SDK. The reason why this happens is because the Windows Phone SDK team decided to "tweak" a little bit the default style for the Panorama control, to be more precise the TitleLayer part of the style.

On Windows Phone OS 7.1 projects the TitleLayer looks like this:

 <controlsPrimitives:PanningTitleLayer x:Name="TitleLayer" CacheMode="BitmapCache" ContentTemplate="{TemplateBinding TitleTemplate}" Content="{TemplateBinding Title}" FontSize="187" FontFamily="{StaticResource PhoneFontFamilyLight}" HorizontalAlignment="Left" Margin="10,-76,0,9" Grid.Row="0"/>

while on OS 8.0 we have:

 <Primitives:PanningTitleLayer x:Name="TitleLayer" CharacterSpacing="-35" ContentTemplate="{TemplateBinding TitleTemplate}" Content="{TemplateBinding Title}" FontSize="170" FontFamily="{StaticResource PhoneFontFamilyLight}" HorizontalAlignment="Left" Margin="10,-34,0,0" Grid.Row="0"/>

You can see that not only the margin have changed (the reason why on OS 8.0 version we have less space in the content -44px ), but also the font size changed from 187 to 170 producing these visual differences:

The solution to this problem is pretty simple: extract the old style of the Panorama control (the easiest way is using Blend) and apply to both WP7.1 and OS 8.0 versions of your project. This way the UI will be consistent between the two versions of the app. If you don't want to use Blend I am attaching the default OS 7.1 style so you can directly copy/paste it in your project and apply it to your Panorama control.

 <Style x:Key="PanoramaStyleWP71" TargetType="controls:Panorama">  
                <Setter Property="ItemsPanel">  
                     <Setter.Value>  
                          <ItemsPanelTemplate>  
                               <controlsPrimitives:PanoramaPanel x:Name="panel"/>  
                          </ItemsPanelTemplate>  
                     </Setter.Value>  
                </Setter>  
                <Setter Property="Foreground" Value="{StaticResource PhoneForegroundBrush}"/>  
                <Setter Property="Background" Value="Transparent"/>  
                <Setter Property="Template">  
                     <Setter.Value>  
                          <ControlTemplate TargetType="controls:Panorama">  
                               <Grid>  
                                    <Grid.RowDefinitions>  
                                         <RowDefinition Height="auto"/>  
                                         <RowDefinition Height="*"/>  
                                    </Grid.RowDefinitions>  
                                    <controlsPrimitives:PanningBackgroundLayer x:Name="BackgroundLayer" HorizontalAlignment="Left" Grid.RowSpan="2">  
                                         <Border x:Name="background" Background="{TemplateBinding Background}" CacheMode="BitmapCache"/>  
                                    </controlsPrimitives:PanningBackgroundLayer>  
                                    <controlsPrimitives:PanningTitleLayer x:Name="TitleLayer" CacheMode="BitmapCache" ContentTemplate="{TemplateBinding TitleTemplate}" Content="{TemplateBinding Title}" FontSize="187" FontFamily="{StaticResource PhoneFontFamilyLight}" HorizontalAlignment="Left" Margin="10,-76,0,9" Grid.Row="0"/>  
                                    <controlsPrimitives:PanningLayer x:Name="ItemsLayer" HorizontalAlignment="Left" Grid.Row="1">  
                                         <ItemsPresenter x:Name="items"/>  
                                    </controlsPrimitives:PanningLayer>  
                               </Grid>  
                          </ControlTemplate>  
                     </Setter.Value>  
                </Setter>  
           </Style>

NAMASTE

Type forwarding and XAML sharing between WP OS 7.1 and 8.0 projects

2013-05-09T19:41:00.001+02:00

This post is about a new feature available in Windows Phone OS 8.0 SDK called Type Forwarding.

Have you ever wondered how does the Windows Phone 8.0 SDK handles the fact that the Panorama, Pivot controls changed the namespace and the assembly from OS 7.1 SDK to OS 8.0 SDK? (80% that you haven't :) ). I recently had to migrate an OS 7.1 project to OS 8.0, but also keep the old one (duplicated the old project and upgrade the duplicated one).

Here is the story of what happens when you upgrade an OS 7.1 project that uses Panaroma or Pivot to OS 8.0:
If you start a new Windows Phone Pivot App with the target OS 8.0 inside MainPage.xaml the prefix "phone" is used for the Pivot control where "phone" is:

 xmlns:phone="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone"

If, on the other hand, you create a new Windows Phone Pivot App with the target OS 7.1 inside MainPage.xaml the prefix "controls" is used for the Pivot/Panorama control where "controls" is:

 xmlns:controls="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone.Controls"

The real "magic" happens when you upgrade the Windows Phone 7.1 project to OS 8.0. The MainPage.xaml page doesn't change (you will still see the "controls" tag is kept in order to be able to better share the code between the versions), but instead a reference to Microsoft.Phone.Controls.dll is added to the OS 8.0 reference that is not used if you create a new project with target OS 8.0. If you wonder if by adding this reference you use the old version of the controls the answer is NO. What this assembly does is that is uses a really neat and new feature of the .Net compiler called Type Forwarding. This feature can be used when you move a class from one namespace/dll (assembly) to another and you don't want to recompile the application to reference the new dll but you will only deploy the two dlls where the first one (the one that the application already knew uses the Type Forwarding to tell the application that a certain class/es moved to another assembly). In the case of Windows Phone OS 8.0 SDK the usage is even "cooler" as it enables you to use the same XAML for both OS 7.1 projects and OS 8.0 ones. Inside AssemblyInfo.cs of Microsoft.Phone.Controls.dll OS 8.0 version we have all the declarations needed to forward the types to their new locations:

 [assembly: TypeForwardedTo(typeof(Panorama))]  
 [assembly: TypeForwardedTo(typeof(PanoramaItem))]  
 [assembly: TypeForwardedTo(typeof(Pivot))]  
 [assembly: TypeForwardedTo(typeof(PivotItem))]  
 [assembly: TypeForwardedTo(typeof(PivotItemEventArgs))]  
 [assembly: TypeForwardedTo(typeof(AnimationDirection))]  
 [assembly: TypeForwardedTo(typeof(PanningBackgroundLayer))]  
 [assembly: TypeForwardedTo(typeof(PanningLayer))]  
 [assembly: TypeForwardedTo(typeof(PanningTitleLayer))]  
 [assembly: TypeForwardedTo(typeof(PanoramaPanel))]  
 [assembly: TypeForwardedTo(typeof(PivotHeaderItem))]  
 [assembly: TypeForwardedTo(typeof(PivotHeadersControl))]

I am attaching a small project called TypeForwarding that implements the same functionality as Microsoft.Phone.Controls.dll OS 8.0 version.

Other usages that I can thing of:

Flurry SDK changes the name of the namespace for the Api class for WP7SDK to WP8SDK (bad choice when you need code sharing). If you want to keep the same code for the OS 7.1 and the OS 8.0 version of the app you will have to use conditional compiling for every file where you use the Api class. Much easier would be to create an OS 8.0 library project with the default namespace WP7SDK and forward the Api class to the WP8SDK added as a reference to the library project. This way the old WP7SDK will continue to work as it was on the OS 8.0 using the OS 8.0 version of the Flurry SDK.
MVVM Light. If you use inside your XAML the EventToCommand this is not xaml shareable between OS 7.1 and OS 8.0 because the assemblies changes from GalaSoft.MvvmLight.Extras.WP71.dll to GalaSoft.MvvmLight.Extras.WP8.dll. The easiest approach in this case (an open source) would be to recompile the dll and use the same name for both versions of the dll. But if you don't have access to the source code of the dll you could use type forwarding. Also a third approach would be to derive your on class like MyEventToCommand and use this inside the xaml.

Keep in mind this neat feature because you might need it. I would also love to see, in the next version of the SDK, the possibility to use MarkupExtension this way we could conditionally compile parts of the XAML depending on the version of the SDK the app is running on. Have a look at this blog post that explains how it works on WPF projects.

SOURCE CODE

Till next post NAMASTE and have fun coding for Windows Phone!

Enable Azure Mobile Services for "pure" Windows Phone 7.1 Xna Games

2013-05-01T15:33:00.000+02:00

Recently somebody asked me for an advice on what library should he use to communicate with an Azure Mobile Service for an Windows Phone OS 7.1 and Windows 8 Xna game. My answer was, of course, the Windows Azure Mobile Services client library available on NuGet as I remembered that the prerelease version works also for Windows Phone OS 7.x applications.

The "problem" is that the library will not install if the game is a pure Xna Windows Phone project.

There are 2 (maybe 3 :) ) solutions to this problem:

1. Migrate your XNA project to an "Windows Phone XAML and XNA App" and on this type of project the client library will install correctly.

2. You could use a small hack in order to force NuGet to install the Azure Mobile Services client library on your XNA project. The hack is pretty simple:

open the YourProject.csproj file with an text editor (like Notepad) and add these 3 line (not sure if all 3 of them are needed but doesn't matter as it is only done to force the library to install):

 <SilverlightVersion>$(TargetFrameworkVersion)</SilverlightVersion>  
 <TargetFrameworkProfile>WindowsPhone71</TargetFrameworkProfile>  
 <TargetFrameworkIdentifier>Silverlight</TargetFrameworkIdentifier>

Visual Studio will see that the project has been modified so it will ask to Reload the project. Reload it (don't try to build the project as it won't), open the Package Manager Console and write:
```
 Install-Package WindowsAzure.MobileServices -Pre   
```
the package should now install.
Reopen the .csproj file in Notepad and remove the 3 lines we've previously added, save and reload the project in Visual Studio. The project should compile correctly and you should be able to use the Azure Mobile Services client library.

The only thing that doesn't seem to work is make Visual Studio recognize the await keyword for the XNA project. You will have to use the ContinueWith syntax:

 void TestAzureMobile()  
     {  
       todoitem item = new todoitem { Text = "Awesome item XNA" };  
       ms.GetTable<todoitem>().InsertAsync(item).ContinueWith((task)  
         =>  
       {  
         //do what you need here  
       });  
     }

3. Came to me while writing the post. Guess the most "elegant" way is to add an Windows Phone Class library to your project, add and use the Azure Mobile Service client library from the class library, reference the class library from your XNA project. Tried this one but the MobileServiceClient seems to fail initialization with 'System.TypeInitializationException'.

Take in consideration that the Azure Mobile Services client library is still a pre-release version in this moment so for the release they might fix/enhance it and you could install it on XNA projects without any hack needed (it is a PCL library).

Detect the screen resolution for Windows Phone OS 7.1 applications

2013-04-24T21:59:00.000+02:00

As you probably know Windows Phone 7.1 applications run perfectly on Windows Phone 8 devices. This means that your application/s could run on multiple display resolutions (which are the resolutions supported by Windows Phone 8 devices). If you want to take advantage of the new resolutions (for example downloading higher quality images for higher resolutions devices, fix some minor UI anomalies on higher resolutions) you will need to know the ScaleFactor of the device. The property is only available in the Windows Phone 8.0 SDK, but the good news is that you can access it using reflection.

Solution:

We retrieve the Get method of the ScaleFactor property and invoke it only if the application is running on an Windows Phone 8 device.

Here is the source code:

  public static Size DisplayResolution  
     {  
       get  
       {  
         if (Environment.OSVersion.Version.Major<8)  
           return new Size(480,800);  
         int scaleFactor=(int) GetProperty(Application.Current.Host.Content, "ScaleFactor");  
         switch (scaleFactor)  
         {  
           case 100:  
             return new Size(480, 800);  
           case 150:  
             return new Size(720, 1280);  
           case 160:  
             return new Size(768, 1280);  
         }  
         return new Size(480, 800);  
       }  
     }  
     private static object GetProperty(object instance, string name)  
     {  
       var getMethod= instance.GetType().GetProperty(name).GetGetMethod();  
       return getMethod.Invoke(instance, null);  
     }

I am also attaching a small sample Windows Phone OS 7.1 test project.

SOURCE CODE

P.S. I think Telerik could use this method to fix this RadToolTip visual anomaly (the 1 pixel width lines that I have filled with blue for contrast) :

NAMASTE

3 ways to force the WebBrowser control to logout from Facebook

2013-04-17T08:00:00.000+02:00

Decided to write this post because it took me some time to find the answer. Maybe you already know that if you use OAuth Facebook connect inside your Windows Phone application there is one step where you use the WebBrowser control to let the user authenticate on the Facebook server and authorize your app. The "problem" presents itself when you want to link another user because the WebBrowser control has already memorized the old credentials and will automatically use them. What needs to be done is to logout the old user from the WebBrowser without actually telling the user to go on the web page and click logout. I have found 3 easy ways to do that: the first two will work on both Windows Phone 7.x and Windows Phone 8 and are Facebook specific and the third one will only work on Windows Phone 8 (generic method for OAuth providers). The 3 methods can use the WebBrowser control headless (you don't actually have to show the WebBrowser control to the user and don't even have to have the webbrowser attached to a Page):

Method 1: described by Rene Schulte in this blog post

The method constructs the logout Uri using your AppId and a SessionKey that is obtained from the AccessToken you got when the user authenticated.

Get the SessionKey:

  private static string ExtractSessionKeyFromAccessToken(string accessToken)  
     {  
       if (!String.IsNullOrEmpty(accessToken))  
       {  
         var parts = accessToken.Split('|');  
         if (parts.Length > 2)  
         {  
           return parts[1];  
         }  
       }  
       return String.Empty;  
     }

Obtain the logout Uri:

  public Uri GetLogoutUri(FacebookCredentials credentials)  
     {  
       var sessionkey = ExtractSessionKeyFromAccessToken(credentials.AccessToken);  
       var url = String.Format("http://facebook.com/logout.php?app_key={0}&session_key={1}&next={2}", EndpointData.FacebookAppId, sessionkey, EndpointData.FacebookLogoutCallbackUrl);  
       return new Uri(url);  
     }

Make the WebBrowser navigate to the logout Uri:

 Browser.Navigate(FacebookService.GetLogoutUri(EndpointData.Settings.Facebook));

Method 2:
If for some reason you don't have the Facebook AppId available (my case) you can use the WebBrowser to navigate to the Logout page https://www.facebook.com/logout.php and after the page gets loaded you just execute the script document.forms['logout_form']:

 wb.LoadCompleted += wb_LoadCompleted;  
 wb.Navigate(new Uri("https://www.facebook.com/logout.php"));

Once the page gets loaded:

 void wb_LoadCompleted(object sender, System.Windows.Navigation.NavigationEventArgs e)  
     {  
       wb.LoadCompleted -= wb_LoadCompleted;  
       if (wb.SaveToString().Contains("logout_form"))  
         wb.InvokeScript("eval", "document.forms['logout_form'].submit();");  
     }

Method 3:
This is the easiest one, but will only work on Windows Phone 8: call the new WebBrowser async method ClearCookiesAsync(). This method works for every OAuth provider (Dropbox, Box, Skydrive, Picasa, Flickr, Google Drive... infinite list).

NAMASTE

Smooth scrolling content on Windows Phone

2013-04-02T20:26:00.001+02:00

Gotta say that I am not 100% satisfied about the title of this blog post, but since I haven't found a better one I will use this one (don't get it wrong windows phone has smooth scrolling implemented). This post is focusing on how to smooth scroll the content of a ScrollViewer. If you are using the ScrollViewer you know that it already has the method ScrollToVerticalOffset that can be used to manually scroll the content but this method doesn't have any animation implemented so you will see only a fast redraw of the new content without getting the "feeling" that the content scrolled to the new position. The easiest way to achieve this task would be using a StoryBoard with an Animation on the property VerticalOffset of the ScrollViewer, but VerticalOffset is a read-only property so it cannot be set and therefore cannot be used for animation.

The solution I found was to build a custom control and add a custom property that can be used as a target for a DoubleAnimation. The attached sample (see the link at the end of the post) is using a ListBox as the content of my Custom Control but you can use anything else inside the control (a better approach for the ListBox would be to create a custom control derived directly from ListBox and use the built-in ScrollViewer).

Let's start from the XAML part of the User Control:

  <ScrollViewer x:Name="scroller">  
     <ContentPresenter Content="{Binding ContentArea, ElementName=userControl}"/>  
  </ScrollViewer>

So we have a ScrollViewer which inside has a ContentPreseter that has its content binded to the control's property ContentArea. Now let us have a look at the .cs code.

 public static readonly DependencyProperty VerticalOffsetProperty = DependencyProperty.Register("VerticalOffset",  
       typeof(double), typeof(SmoothScroller), new PropertyMetadata(VerticalOffsetPropertyChanged));  
     public double VerticalOffset  
     {  
       get { return (double)this.GetValue(VerticalOffsetProperty); }  
       set { this.SetValue(VerticalOffsetProperty, value); }  
     }  
     private static void VerticalOffsetPropertyChanged(object sender, DependencyPropertyChangedEventArgs args)  
     {  
       SmoothScroller cThis = sender as SmoothScroller;  
       cThis.scroller.ScrollToVerticalOffset((double)args.NewValue);  
     }  
     public static readonly DependencyProperty ContentAreaProperty = DependencyProperty.Register("ContentArea", typeof(object), typeof(SmoothScroller), null);  
     public object ContentArea  
     {  
       get { return (object)GetValue(ContentAreaProperty); }  
       set { SetValue(ContentAreaProperty, value); }  
     }

The property that we will use for animation is the VerticalOffset that uses the method VerticalOffsetPropertyChanged to scroll to a vertical offset inside the control's scroller. The property VerticalOffset can be animated and we will use it to smooth scroll the ListBox content.
Here is the content of the MainPage.xaml

  <uc:SmoothScroller x:Name="smoothScroller">  
         <uc:SmoothScroller.ContentArea>  
         <ListBox x:Name="lstItems" ItemsSource="{Binding Items}" ScrollViewer.VerticalScrollBarVisibility="Disabled" ScrollViewer.HorizontalScrollBarVisibility="Disabled" ItemTemplate="{StaticResource DataTemplate}" >  
           <ListBox.ItemContainerStyle>  
             <Style TargetType="ListBoxItem">  
               <Setter Property="HorizontalContentAlignment" Value="Stretch"></Setter>  
             </Style>  
           </ListBox.ItemContainerStyle>  
         </ListBox>  
         </uc:SmoothScroller.ContentArea>  
       </uc:SmoothScroller>

So we have the SmoothScroller control which inside its ContentArea has a ListBox (the ListBox has it's scrollviewer disabled). What the sample does is it is changing the selected item every second (incrementing the selectedindex) and scrolls the content so that the newly SelectedItem is centered in the ScrollViewer. Here is the code used for scrolling:

  void dt_Tick(object sender, EventArgs e)  
     {  
       ((ListBox)smoothScroller.ContentArea).SelectedIndex = idx;  
       var container = ((ListBox)smoothScroller.ContentArea).ItemContainerGenerator.ContainerFromIndex(idx) as FrameworkElement;  
       var transform = container.TransformToVisual(smoothScroller.scroller);  
       var elementLocation = transform.Transform(new Point(0, 0));  
       double newVerticalOffset = elementLocation.Y + smoothScroller.scroller.VerticalOffset - smoothScroller.scroller.ActualHeight / 2 ;  
       //Animate transition  
       DoubleAnimation verticalAnimation = new DoubleAnimation();  
       verticalAnimation.From = smoothScroller.scroller.VerticalOffset;  
       verticalAnimation.To = newVerticalOffset;  
       verticalAnimation.Duration = new Duration(TimeSpan.FromMilliseconds(500));  
       var sb = new Storyboard();  
       sb.Children.Add(verticalAnimation);  
       Storyboard.SetTarget(verticalAnimation, smoothScroller);  
       Storyboard.SetTargetProperty(verticalAnimation, new PropertyPath(SmoothScroller.VerticalOffsetProperty));  
       sb.Begin();  
       idx++;  
       if (idx >= 56)  
         dt.Stop();  
     }

Pretty basic: select the new index in the ListBox, calculate the new VerticalOffset so that the newly selected item is centered in our scrollviewer and create and start a 500ms animation for the SmoothScroller.VerticalOffsetProperty. Anyway I am sure that you will better understand how it works when you will try the sample code.
The sample is far from perfect (before starting a new animation I should check if the old one finished, should not automatically scroll when the user is manipulating the list,...).
Here is a screenshot from the sample:

As usual let me know if you need help. The code works on both Windows Phone 7.1 and Windows Phone 8 SDK.

SOURCE CODE

Small tip on XAudio2 for Windows Phone

2013-03-24T18:58:00.001+01:00

While debugging one of my Windows Phone applications on the device I've noticed that after the debug session the battery of the device drained faster than usual (so I always restarted the device after using it for debugging). Initially I thought it was the Bluetooth driver but I saw that if I stop the XAudio2 engine when my application gets suspended and re-enable it when the application resumes my battery drains "normally". This should be a best practice as your application doesn't really need the engine when it gets suspended. So:

When your app is suspended, call IXAudio2::StopEngine.
When your app is resumed, call IXAudio2::StartEngine.

NAMASTE

How to add songs to the emulator's MediaLibrary

2013-03-22T17:20:00.000+01:00

One of the new features of the Windows Phone 8 SDK is the ability to save(add) songs to the phone's MediaLibrary. This is a really nice when you add songs to the MediaLibrary any other music application that you have installed on your phone can play the songs that your application has saved.. The SaveSong method is found in the MediaLibraryExtensions class. Here are the parameters of this method:

[ExtensionAttribute]

public static Song SaveSong (
         MediaLibrary library,
         Uri filename,
         SongMetadata songMetadata,
         SaveSongOperation operation
)

    The method requires the ID_CAP_MEDIALIB_AUDIO capability and will return a reference to the newly saved song. One of the things that the documentation forgot to mention is that the filename Uri has to be an Uri to a file on the IsolatedStorage. You cannot give a direct Uri to an asset file (this I think because using the SaveSongParameter you can choose if you want to copy or move the file to the MediaLibrary) as you will get InvalidOperationException. If you want to add a song deployed as an asset you will first have to copy the file to the IsolatedStorage and then save it to the MediaLibrary.

    To copy the file to the IsolatedStorage you can use the:

 var resource = Application.GetResourceStream(new Uri(@"Assets/Songs/"+fileName, UriKind.Relative));  
 resource.Stream.CopyTo(fileStream, 4096);

or you can use the WinRT Api to read the asset file:

  songUri=new Uri("ms-appx:///Assets/Songs/"+fileName,UriKind.Absolute);  
  var file=await Windows.Storage.StorageFile.GetFileFromApplicationUriAsync(songUri);

One interesting parameter is the SongMetadata. This enables you to "mess" with the metadata that will be saved to the MediaLibrary. If this parameter is null then the function will automatically import the file's metadata. If you still want to verify/import just some of the files metadata you can use the PCL ID3.NET and read the metadata of the file you have on the Isolated Storage. The portble dll is Id3.dll. You just have to pass the Stream to the Mp3Stream method:

 Id3.Mp3Stream mp3 = new Id3.Mp3Stream(resource.Stream);  
 if (mp3.HasTags)  
 {  
 }

NAMASTE

How to debug Windows Phone HTML5 Apps

2013-03-18T20:26:00.000+01:00

Debugging HTML applications is never an easy task and until today I did not know how to approach this for Windows Phone HTML5. The technique I will describe in this post can be applied also for Windows Phone 7.1 applications using Phonegap or Android/iOS applications.

The "secret" tool for debugging the html content inside our applications is called WEINRE which comes from WEb INspector REmote. Weinre is a debugger for web pages, like FireBug (for FireFox) and Web Inspector (for WebKit-based browsers), except it's designed to work remotely, and in particular, to allow you debug web pages on a mobile device such as a phone.

In order to install Winre you will need to download and install NodeJS

Once you have installed NodeJS restart your machine this way you will be able to run the NodeJS commands from the command prompt. After restart open a command prompt window and run this command:

 npm install weinre -g

This will install the Weinre package globally. This is what you should see in the Command Prompt window:

When the installer has finished its work you are ready to run the Weinre server on your PC. Execute this command from the Command Prompt:

 weinre --boundHost -all- --debug -true

With these parameters Weinre should also open the firewall port. For more parameters have a look at this page. You can verify if the server started by opening a browser page and loading 127.0.01:8080 (8080 is the default port for Weinre). If you are seeing this page then the server is running:

Now click on the Debug Client User Interface link where you will be able to see if any client is connected and debug the connected clients.

Let's create the Windows Phone HTML5 application. Use the SDK template to create a new project, open the page index.html inside the folder Html and add this line to the head section:

 <script src="http://[the server ip]:8080/target/target-script-min.js#anonymous"></script>

replace [the server ip] with the IP of the PC running the Winre server and run the application. If everything went as we expected in the Debug Client user Interface on the Server we should see one Target connected:

Once the target Windows Phone page is connected you can inspect and change the DOM in real-time, execute javascripts:

In this particular case I've only changed the background of the page but you can do whatever you want. Here you can find further details on how to use the Server User Interface.
Using the Console panel you can execute arbitrary JavaScript expressions/statements. It also shows the output from various console methods, like console.log().

This is pretty much everything. Simple and veryyyyyy useful if you need to debug your HTML5 windows phone applications.
As usual don't hesitate to contact me if you have further questions.

NAMASTE

HTC Mazaa OS 7.10.8862.144 - live tiles fix

2013-03-15T12:53:00.000+01:00

This is a small update to my previous post on how to update your HTC Mazaa to the latest build of Windows Phone 7.x http://sviluppomobile.blogspot.it/2013/02/update-htc-mazaa-to-windows-phone-78.html . You can now update to version 7.10.8862.144 of the OS that seems to fix the live tiles issues.

The steps you will have to add:

Step 1:
7.10.8858.136 - 7.10.8860.142

Step2:
7.10.8860.142 - 7.10.8862.144

Share localization files between Windows Phone and Windows 8

2013-03-12T00:54:00.001+01:00

As I wrote in my previous post I am getting back with a post on how to share the localization files between Windows Phone and Windows 8. This should be a simple task, but in the current version of the Windows Phone SDK and Windows 8 it cannot be easily done. The target is to have only one of the two projects (Windows Phone or Windows 8) that manages the localized (in this sample I am only taking in consideration localized strings but the concept can be easily extended) and use it in the other project. Also I wanted to use the Multilingual App Toolkit to easily manage the translations inside the project.

First let's see what we have:

Windows Phone + Multilingual App Toolkit

The main resource file is called AppResources.resx and is inside the Resources folder
The AppResources.resx automatically generates the AppResources class
The files generated by the Multilingual App Toolkit for the Windows Phone project are also inside the "\Resources" folder and the name look like AppResources.[culture].xlf
We have a class called LocalizedStrings.cs that helps us with the binding inside xaml files

Windows 8 + Multilingual App Toolkit

The main resource file is called Resources.resw and it is inside the \strings\[Default language] folder
The Resources.resw doesn't have .cs class in code behind generated (it uses the ResourceLoader class to load the localized values). We can also have values with "." like MainButton.Text to directly use inside xaml with the x:Uid.
The files generated by the Multilingual App Toolkit for Windows 8 are inside the "\MultilingualResources" folder and the names are [AppName]_[culture].xlf

So we cannot directly use the files from one project to another. There are a lot of differences but the couples (AppResources.resx, Resources.resw) and all the (AppResources.[culture].xlf, [AppName]_[culture].xlf) have different names but share very similar structure (they share most of the structure).

My approach and idea is to automatically generate the set of localized files needed by one solution directly from the set of files of the other project at compilation time. As source I have chosen the Windows Phone resource files (the other way around is more difficult as we could have resources not supported by Windows Phone). In order to automatically generate the resource files I have created a console application that would be run as a Post-build event on the Windows Phone project and write the necessary files to the Windows 8 project. the Windows 8 project build will be set to depend on the Windows Phone project this way we will always have updated resources when we run it. The console application needs three parameters/inputs: the folder of the Windows Phone project (source), the folder of the Windows 8 project (destination), and the name of the Windows 8 project as we will need it when we generate the [AppName]_[culture].xlf files for the Windows 8 project. The console application also automatically generates the AppResources.cs class inside the Windows 8 projects which is a class similar to the one used by Windows Phone. The source code for the Console Application is also included in case you need to do some changes and also the full sample.

So let's see what would be the steps you will have to make if you want to use the solution.

Create a Windows Phone application (in the attached sample the project WindowsPhoneApp). Using the Tools menu enable the Multilingual App Toolkit and using right-click on the project name select "Add translation languages..." to support more languages (in the sample is italian)
Create the Windows 8 projects (in the attached sample the project called WindowsStoreApp). Create the the folder structure \strings\en and add the file Resources.resw to it. Inside the Package.appxmanifest set the default language as en. Now use the Tools menu and enable the Multilingual App Toolkit on the Windows 8 project and add the same languages that you have added to the Windows Phone Project.

If later you want to add another language support remember to add it to both Windows 8 and Windows Phone projects.

This is how our solution looks :

two different projects each of one with its localization part. Now we will set that the Windows 8 project build depends on the Windows Phone project and set the post-build action of the Windows Phone project to be:

$(SolutionDir)ConvertAppResources\$(OutDir)ConvertAppResources.exe "$(SolutionDir)WindowsPhoneApp" "$(SolutionDir)WindowsStoreApp" WindowsStoreApp

where ConvertAppResources is the project that converts the resources. We pass 3 parameters to the console application:

the folder of the Windows Phone application which is the source - "$(SolutionDir)WindowsPhoneApp"
the folder of the Windows 8 app which is the destination - "$(SolutionDir)WindowsStoreApp"
the name of the Windows 8 app- WindowsStoreApp

In our case the console application will generate and overwrite Resources.resw, WindowsStoreApp_it.xlf and WindowsStoreApp_qps-ploc.xlf. It will also generate the file AppResources.cs in the Windows 8 application folder which you will have to include in the project after the first compilation of the Windows Phone application.

To keep things even more similar to Windows Phone method I have added the class:

 using Localization;  
 namespace WindowsStoreApp  
 {  
   /// <summary>  
   /// Provides access to string resources.  
   /// </summary>  
   public class LocalizedStrings  
   {  
     private static AppResources _localizedResources = new AppResources();  
     public AppResources LocalizedResources { get { return _localizedResources; } }  
   }  
 }

and inside App.xaml added the resource:

 <Application.Resources>  
     <ResourceDictionary>  
       <local:LocalizedStrings x:Key="LocalizedStrings"/>  
       <ResourceDictionary.MergedDictionaries>  
         <!--   
           Styles that define common aspects of the platform look and feel  
           Required by Visual Studio project and item templates  
          -->  
         <ResourceDictionary Source="Common/StandardStyles.xaml"/>  
       </ResourceDictionary.MergedDictionaries>  
     </ResourceDictionary>  
   </Application.Resources>

This way you could easily bind in Windows Phone style and even reuse xaml and cs that you already have from your Windows Phone project:
Xaml Binding

  <Button Content="{Binding Path=LocalizedResources.ButtonText, Source={StaticResource LocalizedStrings}}" HorizontalAlignment="Left" VerticalAlignment="Top" Margin="517,302,0,0" Height="100" Width="283" Click="Button_Click"/>

and/or code-behind:

 MessageDialog md = new MessageDialog(AppResources.ButtonMessage);

If you want to know more on how the conversion works look inside Program.cs. The steps I do is save the Resx to Resw and generate the class AppResources.cs. After that for every .xlf file in the Windows Phone Resources folder I generate and write the corresponding Windows 8 .xlf file (there are some conversions involved). If you want you don't have to add the project ConvertAppResources to your solution but only add the output .exe file to one of the projects and be very careful when you write the post-build action command.

Once everything is setup-ed you will only have to modify the Windows Phone resource strings and the Windows 8 ones will get updated. If you want to use specific Windows 8 resources you can add more resource files and use the ResourceLoader to load them - for example if you've added the file Errors.resw to the \strings\en folder of the Windows 8 project you will access it like this:

var resourceLoader = new ResourceLoader("Errors");
this.Scenario5TextBlock.Text = resourceLoader.GetString("InvalidOperation");

Be careful:

before adding the post-build action verify that the localization of both Windows Phone and Windows 8 project work (independent from each other)
if the post-build command is not right the Windows 8 application will not get the updated resources when you compile the windows phone project
the Window 8 project has to depend on the Windows Phone project this way you will be sure that Windows 8 gets the updated resources
modify ONLY the Windows Phone .resx and .xlf files

Some limitations of the Multilingaul App Toolkit:

If you modify the Resx file and add a new resource you will have compile the project before you will see the new string in the .xlf files
If you are modifying the Resx file for a resource that you have already localized when you compile you will loose the localization and you will have to modify the .xlf files again.

Let me know if you have problems understanding or making it work (I don't think that I was really good at explaining the process but the hack works).

SOURCE CODE

NAMASTE

Easily localize your Windows Phone applications using the Multilingual App Toolkit

2013-03-08T09:04:00.000+01:00

Great news for Windows Phone developers. Today Microsoft released an updated version of its Multilingual App Toolkit for Visual Studio 2012 that supports also Windows Phone projects (the previous version only supported Windows Store projects). You can download the Visual Studio Extension from HERE. The extension itself is multilingual:

So why is this extension so great in my opinion? As you probably know Windows Phone projects in Visual Studio already support multilingual localization for the applications based on .resw files. The Multilingual App Toolkit adds support for localization industry-standard XLIFF file format and also connects with the Microsoft Translator for quick translation suggestions.

Lets have a quick looks on how it works. After you have installed the extension you will find a new menu entry inside the Visual Studio 2012 Tools menu with which you can enable or disable the Multilingual App Toolkit for your Windows Phone project.

Once you have enabled the Multilingual App Toolkit Visual Studio added the XLIFF support and also generates the AppResources.qps-ploc.xlf which is the pseudo-language engine that helps identify translation issues during development.

From this moment you will USE ONLY the AppResources.resx file to add new resource strings and the extension (at compilation) will add the missing strings to the corresponding .xlf file.

To add new languages to your application you will only have to select the desired language as supported in the project Properties inside the Application section. Once a language is selected the extension automatically generates the corresponding Xlf file.

You can then double click on the xlf file and Visual Studio will open the Multilingual Editor that enablesyou to edit the translation. If you add new strings to your AppResources.resx file remember to compile the project before opening the .xlf file or you will not see the newly added strings.

Now with these 3-4 easy simple steps we have localized our application. You can use the the Microsoft Translator in order to have some suggestions but you should always double-check the translation in order to avoid strange translations and situations ("My Application" in italian is translated as "La mia domanda" which actually means My question).

If you are building a test application remember to add the binding to the resource strings inside your .xaml and .cs files ({Binding Path=LocalizedResources.ApplicationTitle, Source={StaticResource LocalizedStrings}}" Style="{StaticResource PhoneTextNormalStyle} for Xaml or AppResources.value for .cs )
Some words about the AppResources.qps-ploc.xlf pseudo language file. Pseudo Language is an artificial modification of the software product intended to simulate real language localization. The pseudo language can be used to detect potential localizability issues or bugs early in the project cycle, before the actual localization starts. For more details about localizability testing with Pseudo Language see Localizability Testing. Inside Visual Studio if you right click on the Pseudo Language file you can select the Generate pseudo translations.

In order to test it you will have to set the qps-ploc culture for the Application UI. Just add these 3 lines to your Application constructor (but remember to take them out when you don't need them anymore):

  public App()  
     {  
       var ci = new System.Globalization.CultureInfo("qps-ploc");  
       Thread.CurrentThread.CurrentCulture = ci;  
       Thread.CurrentThread.CurrentUICulture = ci;

More details on how to use the Multilingual App Toolkit can be found HERE.

It is really great that Microsoft is migrating the localization of the apps to an open standard. I will get back to this subject with a post on how to share the same xlf files between windows phone and windows 8 projects)

NAMASTE

How to build a multi-touch control for Windows Phone

2013-02-20T17:05:00.001+01:00

What I intend for multi-touch? Windows Phone is already a multi-touch device but for some reason (I guess it is legacy of Silverlight) the standard Xaml controls don’t have a real multi-touch behavior. Real multi-touch means that I should be able to interact with two different objects at the same time with multiple fingers. What happens now for the XAML standard controls is that once a control start receiving touch events (ManipulationStarted, ManipulationEnded, ManipulationDelta) all the other controls will not receive touch events. The easiest test to do is add a standard button on the page, put one finger on the screen outside the button and try to press the button with another finger. You will see that the button does not respond to your commands. For Xaml applications this might not be a problem, but for games it becomes one. Xaml (I mean Xaml+C# or XAML+VB.NET) is fast to develop easy games.

The solution would be to build your own control and use Touch.FrameReported to “drive” it. In this sample I will build a multi-touch button. I will call it ButtonEx (some of you remember OpenNETCF J ?) and I will just add three events to it: TouchDown, TouchUpInside, TouchUpOutSide (iOs MonoTouch event names). With this three events I should have better control (Click in reality is a TouchUpInside event) .

So I've created a new Windows Phone Class Library called ControlsEx and I added the control ButtonEx derived from ContentControl. I copied the standard style of the Button control (you can easily generate it from a standard button using Blend and Edit Copy command on the Button Template). I've then added the style to the /Themes/generic.xaml file inside our project. When I create the control I will subscribe Loaded and Unloaded events as I want to start receiving Touch events when the control loads and unsubscribe the Touch events when the control gets unloaded.

  public ButtonEx()  
     {  
       DefaultStyleKey = typeof(ButtonEx);  
       this.Loaded += ButtonEx_Loaded;  
       this.Unloaded += ButtonEx_Unloaded;  
       IsEnabledChanged += ButtonEx_IsEnabledChanged;  
       IsPressed = false;  
     }  
     void ButtonEx_Loaded(object sender, RoutedEventArgs e)  
     {  
       Touch.FrameReported += Touch_FrameReported;  
     }  
     void ButtonEx_Unloaded(object sender, RoutedEventArgs e)  
     {  
       Touch.FrameReported -= Touch_FrameReported;  
     }

Now everything we need “happens” inside the Touch_FrameReported method. For my button I am interested to trace only one finger(using its id) from TouchAction.Down until TouchAction.Up. Once the first finger is down on the surface of my control I memorize the id and track it’s actions till it leaves the screen. Depending of the control that you are building you might have to take in consideration multiple fingers. One thing that is pretty important when starting to track a finger is to see if your control is in front or not (imagine an MessageBox over your controls and when you press the Ok button you will also press the button which is in the back). To resolve this issue I’ve used TouchDevice.DirectlyOver property of the TouchPoint and the VisualTreeHelper to see if the UIElement returned by DirectlyOver is a member of my control or not.

  bool IsControlChild(DependencyObject element)  
     {  
       DependencyObject parent = element;  
       while ((parent != this) && (parent != null))  
         parent=VisualTreeHelper.GetParent(parent);  
       if (parent == this)  
         return true;  
       else  
         return false;  
     }

Here is the method Touch_FrameReported method:

 void Touch_FrameReported(object sender, TouchFrameEventArgs e)  
     {  
       if (Visibility == Visibility.Collapsed)  
         return;  
       TouchPointCollection pointCollection = e.GetTouchPoints(this);  
       for (int i = 0; i < pointCollection.Count; i++)  
       {  
         if (idPointer == -1)  
         {  
           if (IsEnabled&&(Visibility==Visibility.Visible) && (pointCollection[i].Action == TouchAction.Down) && IsControlChild(pointCollection[i].TouchDevice.DirectlyOver))  
           {  
             //start tracing this finger  
             idPointer = pointCollection[i].TouchDevice.Id;  
             IsPressed = true;  
             VisualStateManager.GoToState(this,"Pressed", true);  
             if (TouchDown != null)  
               TouchDown(this, pointCollection[i].Position);  
           }  
         }  
         else if ((pointCollection[i].TouchDevice.Id == idPointer) && (pointCollection[i].Action == TouchAction.Up))  
         {  
           idPointer =-1;  
           IsPressed = false;  
           UpdateIsEnabledVisualState();  
           if ((pointCollection[i].Position.X > 0 && pointCollection[i].Position.X < ActualWidth) && (pointCollection[i].Position.Y > 0 && pointCollection[i].Position.Y < ActualHeight))  
           {  
             if (TouchUpInside != null)  
               TouchUpInside(this, pointCollection[i].Position);  
           }  
           else  
           {  
             if (TouchUpOutside != null)  
               TouchUpOutside(this, pointCollection[i].Position);  
           }  
         }  
       }   
     }

For the button control we don’t have to trace the movements of the finger until Up action but we might need to if we are writing a Slider control for example. The sample application that you will find in the source code uses 2 ButtonEx controls and a standard Button control. The ButtonEx should always respond to your commands (fingers).

I’ve also used this approach to develop an multi-touch XAML game for flying an Bluetooth BeeWi helicopter. I will also have a session on the 27^th February at Community Days here in Italy where I will present a session on developing a game for Windows Phone and I will use this game as a starting point. This application has multi-touch buttons, slider and joystick control.

Also have to thank the TTT (Train The Trainer) program which awarded me a beautiful Sphero for my multi-touch controls.

As always don’t hesitate to contact me if you have further questions.

SOURCE CODE

NAMASTE

Update the HTC Mazaa to Windows Phone 7.8

2013-02-06T09:57:00.001+01:00

HTC Mazaa was the first ever Windows Phone to run the 7.5 build of the OS. It is a really great development device (as performance it is somewhere between the gen 1 devices and the gen 2 devices) but unfortunately it haven't received any updates since the RTM release build 7.10.7720.68. If you still have RTM build on it you will probably see that you are not even able to access the Store anymore. The bad news is that it will not receive any automatic updates but if you want you can still manually update it to the Windows Phone 7.8 version on it.

To manually update the device you will need :

Zune 4.8 final (build 4.8.2345.0)
Download the WP7_update_tool.rar and install the UpdateWP package for your platform (x86 or x64). This is version 4.8.2134.0. You can download the Update tool from this post

What you will need to do is simulate the steps that Zune does when it updates your phone. At each step there are a number of cab that you can send to the phone at the same time. BACKUP YOUR PHONE before updating. This tutorial starts the update from the version 7.10.7720.68 up to 7.10.8858.136. If you have a heigher version than 7.10.7720.68 just start from the step of the version you have. We assume that your Mazaa has the following language packs installed (if you have less just remove the corresponding cabs from each step):

German (0407)
English - United States (0409)
French (040C)
Italian (0410)
English - United Kingdom (0809)
Spanish (0C0A)

At each step just run:

updatewp /iu [concatenate cab's from step here with space between]

Here are the cabs for each step:

1) 7.10.7720.68-7.10.7740.16

diff-7.10.7720.68-7.10.7740.16-armv7-retail-microsoft.pks_2cb1bfdd82133914239b8ee1a78e61e9000d124a.cab

2) 7.10.7740.16-7.10.8107.79

diff-7.10.7740.16-7.10.8107.79-armv7-retail-microsoft.pks_c9b7f3bc5bb340ba30473b566b4557de0cf3322e.cab

diff-7.10.7740.16-7.10.8107.79-armv7-retail-microsoft.lang_040c.pks_2d74e8c5f6a835f1fe4c62b488c96ac2d7f01c29.cab

diff-7.10.7740.16-7.10.8107.79-armv7-retail-microsoft.lang_0409.pks_bfd9c047a7b27c28208c8a717f8d7511fb2586f1.cab

diff-7.10.7740.16-7.10.8107.79-armv7-retail-microsoft.lang_0410.pks_9ecf9b052b6cc3161462e998dac8204a0f754556.cab

diff-7.10.7740.16-7.10.8107.79-armv7-retail-microsoft.lang_0809.pks_2666da3127f526b23b492f293983ccce1d28f375.cab

diff-7.10.7740.16-7.10.8107.79-armv7-retail-microsoft.lang_0c0a.pks_97df86b81a40df06bb2b15c6739e2ee772e53bbf.cab

diff-7.10.7740.16-7.10.8107.79-armv7-retail-microsoft.lang_0407.pks_b50019ef50d52090d408d854c0708ddbf520706c.cab

3) 7.10.8107.79-7.10.8112.7

diff-7.10.8107.79-7.10.8112.7-armv7-retail-microsoft-pluspkr.pks_d500a10eeb11fb6c1913adac4759d67185474d3e.cab

diff-7.10.8107.79-7.10.8112.7-armv7-retail-microsoft.dpi_262.pks_24bb20423e86130365686c1796577d4b22343be9.cab

diff-7.10.8107.79-7.10.8112.7-armv7-retail-microsoft.lang_0407.pks_d89120e9719b4791ecf5f5581730952790d85505.cab

diff-7.10.8107.79-7.10.8112.7-armv7-retail-microsoft.lang_0409.pks_ae068921fd637ba2e3e268b28e6ca1c9f3a9c11f.cab

diff-7.10.8107.79-7.10.8112.7-armv7-retail-microsoft.lang_040c.pks_0e4fe7facb5bd169c742f7811f10e3caf4110e9a.cab

diff-7.10.8107.79-7.10.8112.7-armv7-retail-microsoft.lang_0410.pks_9b7013b1a94c12121b92964f6a0d12425986c195.cab

diff-7.10.8107.79-7.10.8112.7-armv7-retail-microsoft.lang_0809.pks_80abdd4c9c9f3df25432fe4465e23fc3048012cb.cab

diff-7.10.8107.79-7.10.8112.7-armv7-retail-microsoft.lang_0c0a.pks_69aaa5b4911d99c4669344254bfa7ba5f8cd0408.cab

4) 7.10.8112.7-7.10.8773.98

diff-7.10.8112.7-7.10.8773.98-armv7-retail-microsoft.pks_113460c78ac6233e3bb776ceddb6ac94e98c4221.cab

diff-7.10.8112.7-7.10.8773.98-armv7-retail-microsoft.dpi_262.pks_4dbf7302a7b3da01eeafbcfbf1b9b75e6f6de15e.cab

diff-7.10.8112.7-7.10.8773.98-armv7-retail-microsoft.lang_0407.pks_e1a132dbad341e61c902f697bbde9d2ebb98a08f.cab

diff-7.10.8112.7-7.10.8773.98-armv7-retail-microsoft.lang_0409.pks_3e940c840ee4815422610bb6da8f28ac327767cc.cab

diff-7.10.8112.7-7.10.8773.98-armv7-retail-microsoft.lang_040c.pks_7cbfbdf414fcea12530080f94cb7c29fea74c54a.cab

diff-7.10.8112.7-7.10.8773.98-armv7-retail-microsoft.lang_0410.pks_926fdca3ca7df7ac163d22b15ab18a716eef0042.cab

diff-7.10.8112.7-7.10.8773.98-armv7-retail-microsoft.lang_0809.pks_04fcbfbd2d6f419b7f0b854da77f6ce13a16698d.cab

diff-7.10.8112.7-7.10.8773.98-armv7-retail-microsoft.lang_0c0a.pks_09cab7985d025414c9923461e0a0729d95ec6737.cab

5) 7.10.8773.98-7.10.8779.8

diff-7.10.8773.98-7.10.8779.8-armv7-retail-microsoft.pks_b9598a098a3a4e902d043cef778a79ff3e6b0869.cab

diff-7.10.8773.98-7.10.8779.8-armv7-retail-microsoft.lang_0407.pks_a325cee9b2e502ee7cba73ad3b5276e23972080d.cab

diff-7.10.8773.98-7.10.8779.8-armv7-retail-microsoft.lang_0409.pks_4d87f62a11c7898a516df7563a9333e1082fad57.cab

diff-7.10.8773.98-7.10.8779.8-armv7-retail-microsoft.lang_040c.pks_b345d08ab6583dbf9e1d132533ec68e2af411e0f.cab

diff-7.10.8773.98-7.10.8779.8-armv7-retail-microsoft.lang_0410.pks_1645c0de81f21046e42bad6feadcc50a621bb025.cab

diff-7.10.8773.98-7.10.8779.8-armv7-retail-microsoft.lang_0809.pks_255010547a84862a8621b8819aa202e0d2aa9b0d.cab

diff-7.10.8773.98-7.10.8779.8-armv7-retail-microsoft.lang_0c0a.pks_3a0b5492a3b3bbbdbb0aa57f66faaa14c88df184.cab

6) 7.10.8779.8-7.10.8783.12

diff-iucorefixed-7.10.8779.8-7.10.8783.12-armv7-retail-microsoft.pks_8a50b92b21951c7baf9f3600cea8c77e0918021f.cab

7) 7.10.8783.12-7.10.8858.136

diff-7.10.8783.12-7.10.8858.136-armv7-retail-microsoft.pks_d6fb2a271eed6a5d1187b17aba60806753d0ffce.cab

diff-7.10.8783.12-7.10.8858.136-armv7-retail-microsoft.dpi_262.pks_39b9cc884c90d83c0df50ed5623166e9257d1162.cab

diff-7.10.8783.12-7.10.8858.136-armv7-retail-microsoft.lang_0407.pks_91c88df3371a97e95fddec6d490f184d79069b92.cab

diff-7.10.8783.12-7.10.8858.136-armv7-retail-microsoft.lang_0409.pks_653898f93f54d951992766d317db1b846ca71e36.cab

diff-7.10.8783.12-7.10.8858.136-armv7-retail-microsoft.lang_040c.pks_b34792a900bc0aeafeb0a2aaa666b490e44eb1ca.cab

diff-7.10.8783.12-7.10.8858.136-armv7-retail-microsoft.lang_0410.pks_01ab9c5b927d1fdfb5de71774056a146697065ac.cab

diff-7.10.8783.12-7.10.8858.136-armv7-retail-microsoft.lang_0809.pks_45cef4457233690e536db6b7821af0a39b8aeb98.cab

diff-7.10.8783.12-7.10.8858.136-armv7-retail-microsoft.lang_0c0a.pks_29c153eae13ce7184ac8abc63eb6345694e9fce0.cab

If you have problems updating please let me know.

BTW I am not responsible if you BRICK your phone :) . Here is mine updated:

NAMASTE

How to use Team Foundation Service with MonoDevelop

2013-02-04T21:57:00.000+01:00

As you probably know Team Foundation Service team announced a few days ago full support for Git protocol. This was AWESOME news for our small company that needed a FREE source control solution for our MonoTouch and Mono for Android projects. We were already using visualstudio.com for our Windows Phone and Windows 8 projects and previously to Git support in TFS we had an in-house svn server but I was not really happy with it. The thing it took me most was to understand what is the Git endpoint address than everything is standard.

Here is a quick guide on how to create and then use a TFS Git repository with MonoDevelop:

First you need to create a new Team Project with Git support

Once the project is created press the "Navigate to projec"t button.

2. Go to Code explorer and you will be able to see the the Git endpoint address. It might not show the git endpoint the first time but if you navigate away and try again you will see it.

3. Use the Git endpoint address to register a new Repository in MonoDevelop

4. Then just publish your solution using the registered repository. You can see all your files in Code Explorer and also all the commits:

Tip: If you want to use a more simple user name than you full live id you can enable your Alternate Credentials on the User Profile page

The same Git endpoint can be also used to "Connect to a repository" in Xcode for your Obejctive C projects.

Thank you TFS TEAM for this great feature.

NAMASTE

Saving the Windows Phone 8 Emulator State

2013-01-02T16:40:00.001+01:00

Saving the emulator state between runs was one of the feature needed for the Windows Phone emulator, but till now it is not officially supported. It even makes more sense now when the Windows Phone 8 emulator is a full working operating system and not a trimmed one like Windows Phone 7/7.5 was. You could configure an email account, personalize the start screen, install some applications, install certificates or even save the state of an application that requires a lot of data to synchronize before the actual debugging and have everything ready the next time you start the emulator.

Today I was trying to run the Windows Phone 8 emulator on a Parallels 8 machine using this post because I hate Windows 8 performance in Bootcamp (the disk access is crappy and the UEFI mode still needs drivers for sound, video and a way to enable Hyper-V). I observed that the first time you run an Windows Phone emulator it took more than 40 seconds to start. The reason is that the SDK creates a new Virtual Machine in Hyper-V and saves a "clean" snapshot of it.

On every subsequent run of that emulator the XDE automatically starts the virtual machine and immediately applies the snapshot (or starts the virtual machine from the snapshot directly). What caught my attention was the name of the snapshot for each virtual machine:

Emulator 720P - snapshot.720x1280.1024
Emulator WVGA 512MB - snapshot.480x800.512
Emulator WVGA - snapshot.480x800.1024
Emulator WXGA - snapshot.768x1280.1024

I tried and messed up the names and observed that XDE, if it doesn't see a certain Snapshot, it starts the Virtual Machine and creates a new snapshot with the required name. So in order to save the state it would be enough to alter/change the snapshot XDE uses to start the virtual machine.

First we need to start the emulator we want to personalize (in this post i will mess up the 512 WVGA emulator). This can be done in two ways:

From Visual Studio by running a program on that emulator or from Application Deployment (the emulator is easy to personalize because you can zoom the content and you have the hardware buttons but will require a subsequent reset of the Virtual Machine from Hyper-V)
From Hyper-V manager by starting the Emulator WVGA 512MB virtual machine and applying the saved snapshot for a fast start. After the machine starts you will have to connect to it:

Once connected to the emulator/virtual machine you can personalize/modify the way you want it to be. If you connected using Hyper-V these keyboard shortcuts will prove helpful (they also work in the emulator):

F1 - the same as pressing the back button
F2 – the same as pressing the home button
PageUp - enables physical keyboard and minimizes the software keyboard
PageDown – disables physical keyboard and maximizes the software keyboard
F9 - volume up
F10 - volume down
F7 – invoke camera
F3 – invoke Bing search

If you want/need to install some xap's you can use Application Deployment with the Emulator.

When you've reached the desired state go to the Hyper-V manager, select the Virtual machine that you are personalizing and hit Snapshot. This will create a new Snapshot(save state for the emulator).

If you've started the emulator from Visual Studio or Application Deployment App before you create the snapshot you will have to connect to the Virtual Machine from Hyper-V and from the menu Action select Reset (this will clean the ports used for debugging and the state you will save will be usable for Visual Studio and XDE).

After saving the new state the only thing you have to do is to rename the snapshot with the same name of the parent snapshot and delete the parent by right-clicking on it and select Delete Snapshot (DO NOT select Delete Snapshot Subtree).

You are now ready to go: Turn Off the virtual machine from Hyper-V and try it from Visual Studio. Everything should work. If it doesn't it means that the state has some ports that Visual Studio uses still opened and in this case you will have to connect to the Virtual Machine from Hyper-V, Reset the machine from Action and save a new Snapshot.

My personalized emulator looks like this:

If you want to get back to an "unaltered" state just delete the snapshot of the corresponding Virtual Machine from Hyper-V Manager.

Hope saving the emulator state will help you in some scenarios.

NAMASTE!

GetNativeSystemInfo on Windows Phone 8

2013-01-01T17:36:00.001+01:00

This post is related/continues my previous one. I have written a small sample that shows how to call the GetNativeSystemInfo and IsProcessorFeaturePresent functions on Windows Phone 8 devices using a C++ runtime component. For the moment I cannot think of a really good use for calling these functions because there are only two processors on the devices currently available. You could detect which of the two processors the device has and also its features.

Here is a screenshot of the sample running on my Nokia Lumia 920:

As it is the first day of the new year I Wish you all a great 2013!

SOURCE CODE

Detect CPU architecture at runtime for Windows 8 Store Apps

2012-12-30T19:34:00.000+01:00

If you are developing an application for the Windows 8 Store it is very important that you test it on an ARM device (Surface RT, Asus VivoTab RT, Dell XPS 10,etc.) before sending it into certification. You will probably have some bad surprises and not everything that was fast&fluid on your development machine will continue to be so on an ARM device (the list scroll performance reminds me of the first version of Windows Phone). So you will have to simplify the layouts, animations and in some cases even rewrite part of your code. Parallel Programming is your friend if you can use it (for Kids' Orchestra I had the big problem that generating 100ms of sound output took more then 100ms so after 2 days of trying to optimize the C# source code I realized that I only had to use the Parallel.For and everything started working).

Due to performance differences you might need to split the user experience/code on different architectures (like disabling some animations on ARM). If this is the case it becomes very important to know the processor architecture on which your application runs. One solution would be to create 3 different packages of your applications and use the conditional compilation to differentiate between what happens on each architecture. If you still want to use only one package (Any CPU) it is enough to have a method that returns the processor architecture.
The bad news is that WinRT framework doesn't have any method/property that returns the processor architecture (at least I don't know it). The good news is that you can still use GetNativeSystemInfo as it is an api supported for Windows Store apps (it is even supported for Windows Phone 8 apps):

For Windows Store apps you can use two approaches to call this api:

1. Use P/Invoke -this is the one I opted for;

2. Create a Windows Runtime Component in C++ that you can then call from managed code - this is the approach you will have to use if you need to call this function on Windows Phone 8.

What I did is to create a public class, which I called CPU, and has one public static property NativeInfo that returns an SystemInfo object:

 public class SystemInfo  
   {  
     public ProcessorArchitecture ProcessorArchitecture;  
     public ushort ProcessorArchitectureId;  
     public ProcessorType ProcessorType;  
     public uint ProcessorTypeId;  
     public uint NumberOfProcessors;  
     public ushort ProcessorLevel;  
     public ushort ProcessorRevision;  
     public uint AllocationGranularity;  
   };

and a public method IsProcessorFeaturePresent (invoking also a supported Api for Windows Store applications) which returns if a certain ProcessorFeature feature is supported or not.

I have also created a small sample that will give you a list with your processor details. Here is the result I got on my Surface:

Hope you will find the class useful. Don't hesitate to contact me if you need further details.

SOURCE CODE:

CPU.cs and Sample Project

NAMASTE!

C# XAudio2 Sound Playback for Windows Phone

2012-12-26T11:33:00.001+01:00

     Let's begin with a small introduction to XAudio2:
     XAudio2 is a low-level audio API. It provides a signal processing and mixing foundation for games that is similar to its predecessors, DirectSound and XAudio. XAudio2 is the replacement for both DirectSound and XAudio.
     XAudio2 abstracts audio generation by separating sound data from "voice", allowing each voice to be filtered by programmable digital signal processing and effects processing functions. Voices can be "submixed" together into a single stream. There is always only one Mastering Voice that outputs the result using WASAPI.

XAudio2 is primarily intended for developing high performance audio engines for games. For game developers who want to add sound effects and background music to their modern games, XAudio2 offers an audio graph and mixing engine with low-latency and support for dynamic buffers, synchronous sample-accurate playback, and implicit source rate conversion. Compared to WASAPI, XAudio2 requires only a minimum amount of code even for complex audio solutions. Compared to the Media Foundation engine, XAudio2 is a low-level, low-latency C++ API that is designed for use in games.

XAudio2 cannot be used for background music - for this task you will have to use the IMFMediaEngine. XAudio2 cannot be used for capturing audio - for this task you will have to use WASAPI. Do not use XAudio2 for media playback. For that task you can use MediaElement

XAudio2 is part of the DirectX api that is included in the new Windows Phone 8 SDK. The Api is shared between Windows 8 and Windows Phone 8 which means that you will be able to fully reuse your source code on both platforms.

If you want to use XAudio2 for your C#/VB/HTML code you have two options:

1. Use SharpDX . SharpDX is a wrapper of the DirectX Api under .Net platform. Theoretically you can use it to call XAudio2 api directly from your managed code. Practically what happens is that the .Net CLR/GC on ARM seem to block native threads so your audio will shutter/glitch in certain conditions. I had the same problem when I was developing our Windows 8 game Kids' Orchestra and the audio had glitches even on a core i7 processor.

2. The other option, which from my experience works better, is to develop an Windows Phone Runtime Component that will manage the XAudio2 part and expose the needed methods/events to the managed code.

To better understand how it is done I took the Windows 8 sample XAudio2 audio file playback sample C++ from MSDN and ported to Windows Phone 8 by splitting it in two projects: The C#/Xaml part for the UI and the "audio" project which is a Windows Phone Runtime component developed in C++.

The porting was pretty easy. I only had to re-code the player class to make it "visible" to the managed code project and added an event that will tell you when a certain Source Voice has finished playing its buffer/sound (we have 7 sounds and each sound has a Source Voice associated to it). If you need further details on how to write a Windows Phone Runtime component in C++ have a look at this MSDN Post

This sample only plays Wav files that are resources in the C++ project. You could also dynamically generate sounds in managed code and pass the Wave/buffer data as a byte[] to the runtime component. Inside the native code you will then generate an XAUDIO2_BUFFER and submit it to a Source Voice for playing.

I have attached the SOURCE CODE for the Windows Phone project. If you have problems with it don't hesitate to contact me.

NAMASTE!

Bluetooth Service's UUIDs

2012-11-29T23:27:00.002+01:00

If you are developing on Windows Phone 8 and trying to communicate with a Bluetooth device using a StreamSocket these UUID's might come in handy:

ServiceDiscoveryServerServiceClassID= '{00001000-0000-1000-8000-00805F9B34FB}';
BrowseGroupDescriptorServiceClassID = '{00001001-0000-1000-8000-00805F9B34FB}';
PublicBrowseGroupServiceClass = '{00001002-0000-1000-8000-00805F9B34FB}';
SerialPortServiceClass = '{00001101-0000-1000-8000-00805F9B34FB}';
LANAccessUsingPPPServiceClass = '{00001102-0000-1000-8000-00805F9B34FB}';
DialupNetworkingServiceClas = '{00001103-0000-1000-8000-00805F9B34FB}';
IrMCSyncServiceClass = '{00001104-0000-1000-8000-00805F9B34FB}';
OBEXObjectPushServiceClass= '{00001105-0000-1000-8000-00805F9B34FB}';
OBEXFileTransferServiceClass = '{00001106-0000-1000-8000-00805F9B34FB}';
IrMCSyncCommandServiceClass= '{00001107-0000-1000-8000-00805F9B34FB}';
HeadsetServiceClass = '{00001108-0000-1000-8000-00805F9B34FB}';
CordlessTelephonyServiceClass = '{00001109-0000-1000-8000-00805F9B34FB}';
AudioSourceServiceClass = '{0000110A-0000-1000-8000-00805F9B34FB}';
AudioSinkServiceClass= '{0000110B-0000-1000-8000-00805F9B34FB}';
AVRemoteControlTargetServiceClass = '{0000110C-0000-1000-8000-00805F9B34FB}';
AdvancedAudioDistributionServiceClass = '{0000110D-0000-1000-8000-00805F9B34FB}';
AVRemoteControlServiceClass= '{0000110E-0000-1000-8000-00805F9B34FB}';
VideoConferencingServiceClass = '{0000110F-0000-1000-8000-00805F9B34FB}';
IntercomServiceClass = '{00001110-0000-1000-8000-00805F9B34FB}';
FaxServiceClass = '{00001111-0000-1000-8000-00805F9B34FB}';
HeadsetAudioGatewayServiceClass= '{00001112-0000-1000-8000-00805F9B34FB}';
WAPServiceClass = '{00001113-0000-1000-8000-00805F9B34FB}';
WAPClientServiceClass = '{00001114-0000-1000-8000-00805F9B34FB}';
PANUServiceClass = '{00001115-0000-1000-8000-00805F9B34FB}';
NAPServiceClass = '{00001116-0000-1000-8000-00805F9B34FB}';
GNServiceClass = '{00001117-0000-1000-8000-00805F9B34FB}';
DirectPrintingServiceClass = '{00001118-0000-1000-8000-00805F9B34FB}';
ReferencePrintingServiceClass = '{00001119-0000-1000-8000-00805F9B34FB}';
ImagingServiceClass= '{0000111A-0000-1000-8000-00805F9B34FB}';
ImagingResponderServiceClass = '{0000111B-0000-1000-8000-00805F9B34FB}';
ImagingAutomaticArchiveServiceClass = '{0000111C-0000-1000-8000-00805F9B34FB}';
ImagingReferenceObjectsServiceClass = '{0000111D-0000-1000-8000-00805F9B34FB}';
HandsfreeServiceClass = '{0000111E-0000-1000-8000-00805F9B34FB}';
HandsfreeAudioGatewayServiceClass = '{0000111F-0000-1000-8000-00805F9B34FB}';
DirectPrintingReferenceObjectsServiceClass = '{00001120-0000-1000-8000-00805F9B34FB}';
ReflectedUIServiceClass = '{00001121-0000-1000-8000-00805F9B34FB}';
BasicPringingServiceClass = '{00001122-0000-1000-8000-00805F9B34FB}';
PrintingStatusServiceClass= '{00001123-0000-1000-8000-00805F9B34FB}';
HumanInterfaceDeviceServiceClass = '{00001124-0000-1000-8000-00805F9B34FB}';
HardcopyCableReplacementServiceClass = '{00001125-0000-1000-8000-00805F9B34FB}';
HCRPrintServiceClas = '{00001126-0000-1000-8000-00805F9B34FB}';
HCRScanServiceClass= '{00001127-0000-1000-8000-00805F9B34FB}';
CommonISDNAccessServiceClass = '{00001128-0000-1000-8000-00805F9B34FB}';
VideoConferencingGWServiceClass = '{00001129-0000-1000-8000-00805F9B34FB}';
UDIMTServiceClass = '{0000112A-0000-1000-8000-00805F9B34FB}';
UDITAServiceClass = '{0000112B-0000-1000-8000-00805F9B34FB}';
AudioVideoServiceClass = '{0000112C-0000-1000-8000-00805F9B34FB}';
SIMAccessServiceClass = '{0000112D-0000-1000-8000-00805F9B34FB}';
PnPInformationServiceClass= '{00001200-0000-1000-8000-00805F9B34FB}';
GenericNetworkingServiceClass = '{00001201-0000-1000-8000-00805F9B34FB}';
GenericFileTransferServiceClass = '{00001202-0000-1000-8000-00805F9B34FB}';
GenericAudioServiceClass= '{00001203-0000-1000-8000-00805F9B34FB}';
GenericTelephonyServiceClass = '{00001204-0000-1000-8000-00805F9B34FB}';

Farseer Physics for Windows Store Apps using Monogame

2012-10-08T18:08:00.000+02:00

Last week I did a session on porting XNA Windows Phone 7.x games to Windows Store apps using MonoGame. I have to thank Dean Ellis from the MonoGame project team for all the help.

While XNA is not a framework directly supported by Microsoft for Windows Store apps the current version of MonoGame is compatible with Windows 8 and, the most important thing, the applications pass the WACK. There are already several games available in the Windows Store developed using MonoGame (Armed, Skiddy, Rune Legend and I guess there are more).

For the session I ended up using the Simple Animation sample but seeing how easy is to share the code between the platforms (Windows, Windows Phone,PC, MAC, iOS, Android, Playstation, Linux) I started looking for a physics engine. The most used Open Source physics engine seems to be Farseer Physics but it was too late to do the porting for my session. On Sunday I tried the porting and everything went pretty smooth. The only thing I've changed was the serialization/de-serialization of the "World" state. I compiled the engine and also the sample. For the Sample project the Content Project was compiled using Visual Studio 2010 (for the moment Visual Studio 2012 doesn't recognize this type of project) and added the xnb's to a Content folder inside the Visual Studio 2012 solution.

You can see the result in this YouTube video:

I've used SnagIt to capture the movie and it influenced the frame rate (when running without capturing the framerate is always at 60 fps). The test device was the Samsung Slate which has a powerful cpu. I would love to know if a WinRT device will be able to run at the . If any of my readers has access to a WinRT device please deploy the sample to the device and let me know if the framerate is as expected. For the sample you will have to use an external keyboard and mouse as the touch screen is not working in this version. I will try to fix it for the next release (the problem seems to be inside the MonoGame framework as I only receive the move event and not the pressed and released from the touch screen).

Use this link to download the full project (engine and sample):

SOURCE CODE

NAMASTE

Phone Call screen in Windows Phone

2012-09-06T23:36:00.000+02:00

I've wanted to write this post for quite a while but I've always postponed it as it is a very subjective matter. In the end I decided to write my opinion. Windows Phone is really great but there are some aspects that could be improved and seem that have been designed in a hurry and never finished. One of this aspects, and it is not what this post is about, is the Application List. It is ugly and not very usable. How is it possible that Windows Mobile had before anyone else folders/groups but they are still missing in Windows Phone after more than 2 years? The application list really needs improvements/redesign.

This post instead is about the Phone call screen. I've have always had problems with my windows phone devices starting with the Omnia 7 and ending with my Lumia 800 (I've actually tried 3 different Lumia 800 all of them gave me the same problem). The short story is that I am able to drop the call with my face by pressing the Endcall button, put the call on speaker, put it on mute or hold. I am not the only person that has these problems: my wife has the same problem with her new Lumia 710 and also heard from other people. It is a combination between the proximity sensor that activates the screen and the way I am holding the phone. So I've wondered if maybe there is a better location for the Endcall button.

Lets start with a photo I've found on the web (have no idea who she is) :

If you look at the way she is holding her phone (which I think is 90% of the cases) the upper part of the screen is in contact with the face. Let's presume that by a faulty behavior (bad driver, hardware fault, OS fault or the fact that the hardware and the software are not designed by the same company) the screen turns on while you talk. The highest probability to touch the screen with the face is in the upper half of the screen. Let's see what it means in Windows Phone:

So it is Endcall, Speaker, Hold, and Mute (exactly my case).

If you look again at the picture you can see that the less exposed part of the touchscreen(so the better choice for the buttons location) is the lower part of the screen. The lower you go the smaller the probability is, so the best choice for the End call button is the lower part of the screen (this way you minimize the probability to press the button on faulty behavior). This is exactly (I don't know if this is the reason) what iPhone and Android did:

Both of them have chosen to put the End call button near the lower part of the touch screen. For Android (which also depends on the hardware implementation) Google concentrated all the buttons at the lower part of the screen. On the iPhone they kept the other buttons in the center region but they do have really good control over the hardware and putting a call on hold or mute is not as bad as dropping the call.

So it would be better to move the buttons in the lower part of the screen. The blank space could be filled with social information, last call, email, sms.

Hope we will see some improvements in Phone Call screen in Windows Phone 8

NAMASTE

What MediaLibrary needs/is missing (Windows Phone)

2012-09-04T18:39:00.001+02:00

As we (average developers :) ) still don’t have access to the Windows Phone 8 SDK I decided to write a post on the current MediaLibrary limitations for Windows Phone. I only hope that someone from the team will read this post and maybe there is still time to improve some aspects in the new version. Everything here is my personal opinion.

So what is missing from the MediaLibrary?

1. The Token property exposed on the Picture object

The most important for me. Why? Let’s open Internet Explorer on the emulator and go on a webpage that has a picture in it, tap-n-hold and save it twice. If we use Windows Phone commands to launch the Pictures hub in the emulator and go to the Saved pictures album we will see both pictures (same picture but different items). Now let’s create a new project and see what we can get using the MediaLibrary class. I will use this simple code to debug and stop on the pictures to watch its properties:

MediaLibrary ml = new MediaLibrary();

//MediaPlayer.Queue.ToString(); ;

var albums = ml.RootPictureAlbum.Albums;

foreach (var album in albums)

if (album.Pictures.Count>0)

foreach(Picture pct in album.Pictures)

{

bool stophere = true;

}

We can see both pictures but the BIG problem is that the only way to differentiate between the two of them is the Date property (not very elegant, Handle is not public property). The Token property makes a lot of sense to tell which picture is which (maybe also a Path member could be added but Token is way better as we already have the method to open a picture from its Token and you won't have to iterate all the MediaLibrary just to get the picture we want).

This property should be fairly easy to add as it already exists internally (when we use the PhotoChooser we will get the token associated with the selected picture and we will be able to open the picture) .

The token could be extended also to the PictureAlbum class. It doesn’t make much sense to iterate the MediaLibrary to find a specific album if I already know what PictureAlbum I want.

2. The possibility to create new picture albums

In this moment the Pictures Hub already has built-in albums but it is not possible to create new albums directly from the phone. It is possible to do it from Zune (which will not be used anymore) but it is not a trivial task (at least till you understand how it works). So we are mainly stuck with two “containers”: Camera Roll and Saved Pictures which is not enough for a device that theoretically could hold up more than 1GB of photos. From here the need to have tools to organize your photos better by creating new albums and copying/moving photos between albums. Maybe it is a little late to implement it in the "standard" WP8 UI as we are two months away from the official launch of the first phones on the market but maybe not too late to add the functionality in the development tools so the developers can implement it in their apps. This way a photo app could create its album and then the users will know in which album to look when they want to find pictures modified/created by a certain app.

3. Access to the videos on the device

Needed since the first version of windows phone but still no sign of it. Videos are an important part of the device media and developers need access to this part of the MediaLibrary to enable applications like video processing, video backup, video creation and more.

4. Make the Favorites Pictures album work

This functionality already exists in the Windows Phone Mango/Tango but it doesn’t work in the current version of the SDK. I’ve already posted a question on the forum with no answer till now. The count of the Favorites album is always 0.

http://social.msdn.microsoft.com/Forums/en-US/wpdevelop/thread/b57da1aa-cbe6-471b-be4c-6fe96a99c353

5. Enable MediaLibrary access in the background task

Useful for applications that want to backup the pictures from the device automatically. If it’s a problem of security see 6 but if the user already agreed at some point (capabilities, ask permission) it doesn’t make sense to lock the access to the medialibrary from the background tasks.

6. Security/capabilities

I think the current ID_CAP_MEDIALIB is too generic. It would be better to have specific CAP for pictures, videos and songs. They are pretty distinctive and a photo editor wouldn't need access to the songs on the device? Also the user should be warned that his photos might contain GPS data in the EXIF header and he should agree to let the application access those informations.

P.S. Almost all of the features requested are already implemented in the iOS development tools.

NAMASTE

Windows Phone 8 inside VMWare

2012-08-31T22:46:00.000+02:00

More than a month ago some Microsoft guy in Asia made a terrible mistake and the LKG25 of Windows Phone 8 SDK leaked to the web. As I am not one of the lucky people that are the development program (as Mary Jo Foley suspected in a tweet and I believe it is true) I was more than happy when I got my hands onto the leaked version. At start I wanted to start blogging about the news that Windows Phone 8 will bring, but then I decided that it wouldn't be fair so I will wait until the official SDK. This post is not intended as a spoiler of any feature from WP8, but more like a proof of concept.
I am sure many of you read on twitter that the new emulator is a virtual x86 machine and it comes with the virtual hard drive (.vhd file) divided on the screen resolutions.
The idea came to me today while I was installing a clean virtual machine for development. Till now developing in a virtual machine for Windows Phone and debugging on the emulator with a decent speed/quality was impossible as you would have a virtual machines inside a virtual machine that degrades the performance exponentially. So what if you could have the development environment inside a virtual machine and then the emulator on another virtual machine that runs side by side and communicate on TCP/IP. In this case the performance of the emulator would be good (as it is not a vm inside a vm) and also the speed of the development environment would be acceptable. The virtual machine for the emulator would need 512MB or a maximum of 1GB.
So the first thing I did is to install a trial version of VMWare Workstation 9 (should work with VMWare Fusion and also Parallels/VirtualBox). Then I have used WinIMAGE to convert the Flash.vhd file to Flash.vmdk which is the format that VMWare uses and created a virtual machine where I've attached the newly created vmdk.

The good news is that the virtual machine works in VMWare right from the start. Not everything works (more decent is to say that some things work :) ) but hey it runs and I did nothing. The networking is not working but the most annoying part is the mouse pointer which is invisible in the virtual machine so I am blind pressing the mouse and at some point I am able to hit some buttons as you can see in the video :

More important than what this video shows (which is almost nothing) is what it could mean (even if I doubt we will see any of these in the near feature)

Theoretically developing for Windows Phone 8 on Windows 7 should be possible and not so hard to achieve (the partition where I installed Vmware Workstation runs Windows 7)

With some collaboration between Microsoft and VMWare/Parallels it would be possible to develop on a virtual machine and debug/deploy on the emulator which is another virtual machine. This would be great for Mac users but also for everyone (I might say like me) that likes to keep his development environments clean and separated from each other (I have a VM with VS2008 and Compact Framework, soon VS2010 will pass in a virtual machine too, I don't want to install VS2010 on my Windows 8 partition etc.)

The emulator is an x86 virtual machine so it shouldn't be so hard to achieve plug-gable hardware into the emulator (like connect the webcam to the emulator camera, storage card to an USB key or shared folder, NFC hardware - here I might be mistaking but should be a serial connection after all). It would give us a better development environment.

P.S. Seeing that it is a virtual machine I beg the team which is in charge of the emulator to SAVE the emulator/virtual machine state between resets. It is really annoying to always start from 0 and none of the other major mobile platforms has this limitation.

Till next time NAMASTE to you my reader.