Den by default

Beem 1.1 Update Pushed To The Marketplace

Fri, 11 May 2012 22:27:57 GMT

I just released pushed an update to the Windows Phone Marketplace for my Beem application – a DI.FM client that I’ve been working on as a hobby. The new update includes:

A bug fix that now allows you to re-pin a tile even if it disappears (apparently an OS bug, but there is now a workaround).
UI tweaks.
Ability to search for played songs in the Zune Marketplace.
Ability to record the stream and store it locally for playback (consider this a DVR implementation for DI.FM).
Ability to set short recorded music as a ringtone.
There is now a "Now Playing” option that allows users to easily jump to the currently playing station.
Added the ability to clear the music player (in case you don’t want to see the last played content even though it is paused).

NOTE: The update is currently pending certification. It might be a couple of days before you will get it, if you already have the application installed.

FAQ

Q: Why I can record the stream but cannot upload or back it up anywhere?

A: I am currently in the United States. The application is developed in the United States and as a law-abiding individual, I have to follow the US legislation. Under the Fair Use DMCA exception, you are allowed to record the radio stream for personal use, but not for public distribution. Due to the fact that I do not know where exactly the user will upload the recorded MP3 file (e.g. it might be a publicly accessible SkyDrive or Dropbox account) , I cannot allow the files to leave the premises of the Beem storage.

Q: The volume is too low. What’s up with that?

A: I was not able to reproduce this issue with Beem, but I’ve seen it happen with other audio streams, particularly those coming from HTML5-based pages. To get the volume back to normal, try lowering it and it should get back to normal. I notified the Windows Phone Dev team about this issue.

Q: I am trying to set a recorded file as a ringtone, but it never shows up.

A: That is because the file is too long (time-wise) or is too large (size-wise). Try recording a shorter fragment.

"It's expensive getting hardware to test on" is not an excuse for web devs on a Mac to avoid IE testing

Thu, 10 May 2012 16:30:20 GMT

Bart van Zon put together a short blog post describing why some web developers, who chose Mac as their development platform, might attempt to avoid testing their product in Internet Explorer.

Here is one of them:

“It’s expensive getting hardware to test on, taking time to test it, making sure you have a Windows installation”

Really? Let’s break down the costs.

To invest in a Mac system:

MacBook Pro – starts at $1199 for 13-inch. (source) OR
Mac Mini – starts at $599 (source) + display at ~$140 (source) + ~$16 keyboard (source) & $8 mouse (source) totals to $763

Here is for Windows PC:

A decent modern laptop for $400 (source) (pre-bundled with Windows 7 Home Premium)

But let's go beyond that - Macs have Bootcamp, so your investment might be reduced to simply getting a copy of Windows for $120 (source). Or, you might go with what Wes MacDonald suggested in the comments - which results in an additional investment of $0 (download testing VHDs here).

If you are a serious developer who invests his time and effort in creating a solid platform, using hardware priced above average and consider Windows to be a breaking investment, your argument is invalid.

PS: Developers, you might want to also read this.

Windows Phone Registration Issue Fixed For Devices Registered With a Different AppHub ID

Thu, 10 May 2012 00:43:46 GMT

Today Microsoft fixed a bug that was preventing phones that were unlocked under a different AppHub account from being re-registered with a new ID, unless the original account holder would un-register it.

Ultimately, this applies to developers who might’ve had their devices unlocked by someone else other than themselves.

All you have to do now is simply use the Windows Phone registration tool to re-register the device with a different Microsoft ID that is associated with a valid AppHub account.

Help students with So.Cl research

Wed, 09 May 2012 03:24:41 GMT

If you are using So.Cl, you have a great opportunity to help three students: me, Wilson To and Alex Poms, in the monumental task of writing a research paper on the social network.

How can you help? Simply fill out this form.

For Microsoft Student Partners having trouble connecting to Lync on Windows Phone

Thu, 03 May 2012 21:45:41 GMT

Considering the recent problems of one of my MSP friends, I found out that for some reason the Lync 2010 app on Windows Phone might refuse to connect to the Lync server designated for Microsoft Student Partners. It seemed to be an application problem, since I was able to connect just fine with my account – Wilson To, however, was not.

With a little bit of research, I managed to find the source of the problem. When signing in, disable the Auto-detect server option and use this URL for the External discovery address:

http://lyncdiscover.studentpartner.com

You should be able to successfully connect once this is done.

“What Time Is It” explained and ported to Windows Phone

Tue, 01 May 2012 20:51:26 GMT

Today’s highlight from Hacker News is What Time Is It? – a web page that shows how some construction workers are putting together a wooden representation of the current time. As much as we would want that to be a real-time process, it is not. The purpose of this blog post is to explain what’s behind the process.

NOTE: The original video project is called Standard Time and was created by Mark Formanek.

First things first, I decided to analyze the network layer. Wireshark seems to be doing the job pretty well so far, so I noticed this:

The full URL looks like this:

http://176.9.156.38/big_10-25.mp4?start=0&radius=0.794870455716131

The application is fetching MPEG-4 videos that were filmed prior to the actual display. You probably already noticed that there are two parameters – one called start and the other one called radius.

Let’s see what start is about. Obviously, the videos are not filmed for every minute. Instead, each video file is structured in 10 minute chunks. In this case, the source video starts when the clock hits 10:25 AM, but it’s 270 seconds in already (4.5 minutes, therefore it starts at 10:29:30 AM, where workers finish up the :30 sign.

That being said, video URLs are structured like this (from the beginning of the day):

Basically, you can initiate the download from any point out of 5 minute intervals. The maximum value for the start parameter is 590. After that, you have to switch to the next video.

The radius parameter seems to be useless at this point.

Let’s see how to implement this for Windows Phone. I created a project and named it BerlinTime, since the videos were filmed in Berlin. The application itself consists of one page with a MediaElement on it.

<phone:PhoneApplicationPage 
    x:Class="BerlinTime.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:phone="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone"
    xmlns:shell="clr-namespace:Microsoft.Phone.Shell;assembly=Microsoft.Phone"
    SupportedOrientations="Landscape" Orientation="Landscape"
    shell:SystemTray.IsVisible="True">
    
    <Grid x:Name="LayoutRoot" Background="Transparent">
        <MediaElement BufferingTime="0:0:01" x:Name="mediaPlayer"></MediaElement>
    </Grid>
</phone:PhoneApplicationPage>

In the code-behind, I have a custom model for keeping the “normalized” (within 5 minute intervals) time:

public class TimeUnit
{
    public string Hours { get; set; }
    public string Minutes { get; set; }
    public string SecondsIn { get; set; }
}

To get the current time in a manner that can be applied to get the correct video file (remember – the video files are based on 5 minute intervals) I have GenerateCurrentTime:

private TimeUnit GenerateCurrentTime()
{
    TimeUnit unit = new TimeUnit();

    TimeSpan current = DateTime.Now.TimeOfDay;
    Debug.WriteLine(current.ToString());

    int minutes = current.Minutes;
    int seconds = 0;
    int modulusResult = minutes % 5;

    minutes = minutes - modulusResult - 5;

    seconds = (modulusResult + 5) * 60 + current.Seconds;
    Debug.WriteLine(seconds);

    unit.Hours = current.Hours.ToString("D2");
    unit.Minutes = minutes.ToString("D2");
    unit.SecondsIn = seconds.ToString();

    return unit;
}

Here is where 5 minute chunks and the start parameter become useful. To minimize the amount of downloaded data (and therefore to make the streaming smoother), I am constantly looking for the video that represents the time 5 minutes behind the actual one, so the number of seconds goes beyond 300 (5 minutes), therefore I cut the amount of media to be downloaded at least in half. If I would not be doing this, the user would have a high chance of downloading 50MB+ videos on every 10 minute reset.

I need a URL template, that can be used to generate the video URL. For this I have:

public const string UrlTemplate = "http://176.9.156.38/big_{0}-{1}.mp4?start={2}";

When the user first navigates to the page, I am getting the current time and setting the source for the MediaElement (that will buffer the data automatically) to the video file that corresponds to the current time:

protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
{
    PlayVideo();
    base.OnNavigatedTo(e);
}

private void PlayVideo()
{
    CurrentUnit = GenerateCurrentTime();

    mediaPlayer.Source = new Uri(string.Format(UrlTemplate, CurrentUnit.Hours, CurrentUnit.Minutes, CurrentUnit.SecondsIn));
    mediaPlayer.Play();
}

Eventually, the buffer will be exhausted and I will need to reload the media. So when MediaEnded is triggered for the MediaElement, I am simply playing the video again, with new time indicators:

void mediaPlayer_MediaEnded(object sender, RoutedEventArgs e)
{
    PlayVideo();
}

The end result looks something like this:

There might be slight delays, depending on your connection speed. You can download the project on GitHub.

Getting Windows Phone apps back into the Zune Desktop Client

Wed, 25 Apr 2012 23:34:34 GMT

The Windows Phone team recently announced that it will remove the Windows Phone apps section from the Zune Desktop client due to the fact that users mostly access those through the web interface or the mobile client directly on the device. Despite the fact that I do support this change, I know there are also users who might want to keep using the Zune software on their PC to download apps for their Windows Phone.

If you started the Zune client today, you probably saw this:

Here is what’s happening. You are not actually getting a Zune client update, but rather a configuration update. Whenever the Zune software launches, it tries to reach this endpoint:

http://tuners.zune.net/en-US/ZunePCClient/v4.8/configuration.xml

That is, if your client version is 4.8. For other clients check out the Zune API documentation page I wrote a while ago. This configuration file has a node called apps, and in the updated version it has the status set to disabled.

The configuration is being cached on each launch, this is why you are getting the alert when the settings change and you need to restart the client. To get the Windows Phone apps back in the desktop client, you need to set the status value to enabled. But how do you intercept the XML file? There are several ways to do it. The easiest one is to use your own mini (or not so mini) web server with the folder structure used by the endpoint to get the configuration. Here is what I did with IIS:

The configuration.xml file has absolutely the same contents as the original configuration file, with the only difference being the fact that apps are enabled via the method I outlined above.

Now, open your HOSTS file (C:\Windows\System32\drivers\etc) and add the following line:

127.0.0.1 tuners.zune.net

Now whenever tuners.zune.net is accessed for the configuration file, the local version will be fetched. If you already updated the configuration to the one disabling Windows Phone 7 apps, restart the Zune client. You will see that you will once again get an alert notifying you that the settings changed. Restart the Zune client once more and voila:

NOTE: Use at your own risk. I am just guessing that this will be available only till the next full Zune client update.

On ImagineCup, US Finals in Redmond and Microsoft Student Partners

Wed, 25 Apr 2012 04:29:19 GMT

This weekend I got the privilege of attending the Microsoft ImagineCup Unites States Finals in Redmond, WA, right in the middle of the Microsoft campus. Let me tell you right away – I had an amazing time. The people you see there represent the brightest minds passionate about Microsoft technologies from all over the country and world.

Let’s start with the highlight of the event – the ImagineCup finalists:

Software Design

FlashFood – Arizona State University
The Miracle Workers – Winona State University
Physically Kinected – University of Arkansas, Little Rock
KinectMath – University of Washington, Bothell

Game Design - Phone

Drexel Dragons – Drexel University
Pigmaster – UCLA
Wasabi Ninja – University of Houston
Panther Games - Team Alpha – Santa Ana College, Chapman University

Game Design - Xbox

Dr. Fishbowl – Carnegie Mellon University
Digital Infinity – Springbrook High School
Credit/No Credit – University of Washington, Bothell Campus
Zigers – University of Houston

Also, there was a special award that evening – Windows Azure Award, that was given to Team Legendairy. Notable guests were leading the award ceremony – Bill Buxton, Principal Researcher at Microsoft Research, and Mark Hindsbo, Vice President of Developer and Platform Evangelism for Microsoft US. It was exciting to see how young developers applied their knowledge for the global good, on pressing issues like child mortality, the availability of food and environmental sustainability.

Overall, courtesy of Microsoft, the weekend was spent attending finalist presentations, touring Seattle (go on a Duck Tour, highly recommend it) and networking with developers from and outside Microsoft. It’s worth mentioning that some notable Microsoft Student Partners were also in attendance – Wilson To (if you are not aware of his last year’s ImagineCup project, check it out right now), Megan Boorsma and Ana Parra. I also got a chance to to see fellow Microsoft Student Insiders – Ryan Bucinell, Steven Nowak and Drew DeVault. Special thanks go to Mary Perisic for organizing the trip and offering some awesome Microsoft swag.

I loved the experience - I got to see my good friends at Microsoft and discuss some of the future projects. More exciting news to come before this summer, so stay tuned. Thank you to everyone who made this weekend special!

Love Electronic Dance Music? Get Beem for Windows Phone

Thu, 12 Apr 2012 14:45:56 GMT

I am very excited to announce that my weekend hackathon project – Beem for Windows Phone, passed certification and is officially available for download in the Windows Phone Marketplace.

It is a streaming client for DI.FM (Digitally Imported) – it aggregates data from all the popular stations, including trance, progressive, house and dubstep (and many more, of course). I tried to make it visually consistent with the Zune Player – I am curious to hear whether I succeeded in that task or not.

It can play music in the background and under the lock screen, so you don’t have to keep the application constantly open.

Let me know if you have any suggestions and ideas!

Update to Windows Phone Control Kit - ZuneCard

Tue, 10 Apr 2012 07:28:18 GMT

Zune API has been out there for a while – I documented it on Coding4Fun and even created a centralized project with all the known API calls. I like to keep track of my Zune progress, and I like the Zune Card.

I implemented the exact copy of the Zune Card that can be used in a Windows Phone Silverlight Application project. The control is a part of the Windows Phone Control Kit and is called ZuneCard. The only property that needs to be specified at design time is UserID – the Zune tag (conveniently, it is also the Xbox Gamertag, if you have one).

You can download it on GitHub.

WARNING: The control is currently in testing stage. More functionality will be added and optimized. Use at your own risk.

The beginnings of Windows Phone Control Kit - TapMenu and TapMenuItem

Mon, 09 Apr 2012 03:47:03 GMT

For some situations, the controls that are out there are not enough. That is why I started working on my own control toolkit. As I work on my own applications and feel the need to implement a custom control, I will add it to the Windows Phone Control Kit collection.

Today, I decided to implement a “show-on-tap” menu, just like the one you see in the latest version of the Rowi client. My implementation is called TapMenu, and it is a container for TapMenuButton instances.

You can read about the way I implemented this control here.

Download the source on GitHub.

Are you a student in the US? Get a free Windows Phone

Fri, 06 Apr 2012 19:08:20 GMT

Paul Betts mentioned on Twitter yesterday that he was looking for a Canada-specific offer, where developers could get free Windows Phone devices. Although I was not aware of anything like that for Canada, there sure is an offer for students in the United States.

So if you want a free Windows Phone device, you need to make sure that you follow these guidelines:

You are a student in an accredited university/college in the United States
You have developed two Windows Phone applications that are (or will be) published between March 26th and May 31st, 2012.
Those apps are targeting Windows Phone 7.5
Apps support Fast App Switching
The apps are of high-quality and are not created with one of the “do-it-fast” tools, like AppMakr or FollowMyFeed
You have not received a Windows Phone device in previous student promotions from Microsoft

Full outline of the official rules can be found here ( PDF).

You can sign up for the promotion here.

SHAMELESS PLUG: If you are signing up, I would really appreciate if you put my name as the referring MSP (Den Delimarsky).

Porting Visual Studio Achievements for Windows Phone to Windows 8 Article Series

Mon, 02 Apr 2012 00:04:06 GMT

Visual Studio Achievements for Windows Phone is an open-source application that aggregates Channel9 Visual Studio Achievements to a Windows Phone device (couldn’t have made it more obvious).

I ported this application to Windows 8 as a general learning experience and made the notes available for the public. You can familiarize yourself with the process I followed by reading the articles below:

If you would like to share some feedback and similar experiences, feel free to do so.

Windows Phone Homebrew: The new Samsung Diagnostics app appears to be blocking GPRS profile switching

Wed, 28 Mar 2012 01:10:25 GMT

If you own a Samsung Windows Phone device, you probably noticed that there is an update available for the stock Diagnostics application. The default build is 1004 and the new one is 0210.

There is one breaking change that was implemented here that you should be aware of – once you update to 0210 you will not be able to enter the GPRS profile selection mode.

IMPORTANT NOTE: It seems like some devices do not have a problem with the hidden menu.

Here in the screenshot, I was attempting to type in the code to get to the required page (*#9908#) and the application instantly crashes. This means that if your device is not interop-unlocked (giving access to lower-level drivers with a registry flag), you won’t be able to do so because the current methods are tied specifically to the GPRS profile switching capability of the app.

It doesn’t appear to be an internal restriction at the moment – the layout for the invocation is the same. The Samsung-generated hash code for this command is registered and handled. It might be that there is something missing in the current firmware, or it might be that developers misplaced a native call somewhere.

Either way – tested on a Samsung Focus Flash (7.10.7720.68 – FW 2103.11.10.1). The new Diagnostics app was automatically delivered through the Marketplace update.

To revert back to a version of the Diagnostics app that works with the *#9908# command, uninstall the 0201 release and type ##634# in the dialer once again. This will revert it to the 1004 build.

NOTE: If you updated your Samsung device to 8107, let me know what model you have and whether the command mentioned above works in the diagnostics app on your build (given that the app is 0201).

Windows Phone Emulator in the 7.1.1 SDK - quick insights

Mon, 26 Mar 2012 21:25:13 GMT

RAM Size

It appears that the Windows Phone SDK 7.1.1 does not come with two separate OS images for 256MB and 512MB. Instead, it is using the standard DECFG files that I documented a while ago (*.decfg files come from the Windows CE times).

In the XDE folder there are now three configuration boards:

As you can see, there are also two DLL files (config_board and config_board256) that most likely define the OS behaviors on launch. There is only one OS image bundled (that is, one for each OS version – 7.0 and 7.1):

Modifying the DECFG boards

I noticed that modifying the configuration boards does not affect the way the emulator works, unless you want to pass the DECFG board to the XDE as a parameter.

“Windows Phone Emulator is doing a complete OS boot”

If you are launching XDE from the console, you are probably passing a command similar to this:

XDE.exe "C:\Program F
iles (x86)\Microsoft SDKs\Windows Phone\v7.1\Emulation\Images\WM70C1.en-US.bin"
/vmid {cfcdc3d0-b974-49c4-b05c-e4bb033f32f9}

Once you do this, you are prompted with the infamous boot screen:

That is happening because you are not using one of the built-in states, that are located in C:\ProgramData\Microsoft\XDE:

Notice the GUIDs that are used for the files here and now look at the GUID that you were trying to pass from the command line. The VMID is tied to these states, and if you want a fast boot, you need to pass one of these:

106DEFF1-7B7E-43EA-969A-4BC6B52DAF9E – BoardID is 1 – 256MB emulator
751F92FB-3952-4FA6-B9B8-0E6985C3E5AE – BoardID is 2 – 512MB emulator

Launching the emulator through Smartdevice.Connectivity

This method was used by me to access blacklisted applications in the emulator. If you build that sample application, you will now be able to access three devices on the Windows Phone 7 platform:

Looking at Windows 8 Metro app internals? The path has changed in the Consumer Preview.

Sat, 24 Mar 2012 23:04:58 GMT

Justin Angel put together a blog post on reverse engineering Windows 8 applications and he described the locations of the APPX packages on the local machine. Although working well for the Developer Preview, the application locations are no longer the same in the Consumer Preview. Compare those for yourself:

Consumer Preview:

C:\Program Files\WindowsApps

Developer Preview:

C:\Program Files\Applications

By the way, if someone attempts to open the WindowsApps folder with the default user, an error message will be shown with an Access Denied problem. To mitigate this issue, you have to change the owner from TrustedInstaller to the current user (the method described by Justin Angel above works).

Does changing the owner mean that I won’t be able to install apps from the Marketplace?

No.

I am deploying my application from Visual Studio 11 Beta. Is it also installed in WindowsApps?

No. It is located in your project folder: C:\Users\<USERNAME>\Documents\Visual Studio 11\Projects\<SOLUTIONNAME>\<PROJECTNAME>\bin\Debug\AppX

It is worth mentioning that the package deployed from Visual Studio 11 Beta, although located in a different area of the user disk space, will still be registered in line with all other Metro applications in the Windows Registry:

Pushing the limits of the Windows Phone SDK and sending files via EmailComposeTask

Sat, 24 Mar 2012 09:45:08 GMT

It’s almost 4 in the morning, and as with all great ideas, this one came to me while I was working on a completely different project. I was thinking that it is a shame that I cannot attach files to an email via EmailComposeTask – and indeed, I am not the only one thinking about this:

EmailComposeTask won’t allow you to send attachments, but this doesn’t mean that you cannot send files through it. .NET Framework has these two amazing methods: Convert.ToBase64String and Convert.FromBase64String. The first will allow the developer to convert a byte array (byte[]) to a Base64-encoded string, the other one will do the same operation in reverse.

Let’s say that I want to send a picture from my phone. I am going to use CameraCaptureTask:

Microsoft.Phone.Tasks.CameraCaptureTask task = new Microsoft.Phone.Tasks.CameraCaptureTask();
task.Completed += new EventHandler(task_Completed);
task.Show();

Whenever a photo is captured, I have direct access to the resulting stream. What I can do at that point, is get the byte array from it, convert it to Base64 and set is as the body for EmailComposeTask:

void task_Completed(object sender, Microsoft.Phone.Tasks.PhotoResult e)
{
    int read = 0;
    int part = 0;
    byte[] buffer = new byte[22000];

    while ((read = e.ChosenPhoto.Read(buffer,0,buffer.Length)) > 0)
    {
        Thread.Sleep(10000);

        part++;
        string bsfData = Convert.ToBase64String(buffer);

        Debug.WriteLine(bsfData.Length);

        EmailComposeTask task = new EmailComposeTask();
        task.To = "ddelimarsky@live.com";
        task.Subject = "Part " + part.ToString();
        task.Body = bsfData;
        task.Show();
    }

}

A couple of stress points here:

There is a content length restriction currently set to 64k (for the message body), therefore I have to split the entire captured byte array in chunks that are ready to be sent out. If ignored, the following exception is thrown:
This ultimately creates a multi-part email (read: 22 parts for a 2 megapixel photo).
The Thread.Sleep(10000) creates a lag of 10 seconds between EmailComposeTask invocations, because there is no completion notifier event handler for this specific task type. The user has to quickly hit send in this case.
Without a sleeping thread, I get this:

Once all parts are sent out, on the receiving end a simple console application like this will perform the Base64-to-content conversion:

using System;
using System.IO;

namespace AttachFileReader
{
    class Program
    {
        static void Main(string[] args)
        {
            string customParameter = args[0];
            string inputPath = args[1];
            string outputPath = args[2];

            switch (customParameter)
            {
                case "c":
                    {
                        if (!string.IsNullOrWhiteSpace(inputPath))
                        {
                            if (!string.IsNullOrWhiteSpace(outputPath))
                            {
                                try
                                {
                                    using (MemoryStream stream = new MemoryStream())
                                    {
                                        string data = File.ReadAllText(inputPath);
                                        string[] content = data.Split(new char[] { '=' });

                                        foreach (string d in content)
                                        {
                                            string unit = d;
                                            unit = d.Replace("=", "");
                                            unit += "=";

                                            Console.WriteLine(unit.Length);
                                            if (unit.Length > 1)
                                            {
                                                byte[] byteData = Convert.FromBase64String(unit);
                                                stream.Write(byteData, 0, byteData.Length);
                                            }
                                        }
                                        File.WriteAllBytes(outputPath, stream.ToArray());
                                        Console.WriteLine("Successfully saved to " + outputPath);
                                    }
                                }
                                catch (Exception ex)
                                {
                                    Console.WriteLine("Oh snap! Something went wrong. Will this message help you?");
                                    Console.WriteLine(ex.Message);
                                }
                            }
                            else
                            {
                                Console.WriteLine("Missing parameter - index 1");
                            }
                        }
                        else
                        {
                            Console.WriteLine("Missing parameter - index 0");
                        }
                        break;
                    }
                default:
                    {
                        Console.WriteLine("Windows Phone Attached Email Reader v.1.0\nDeveloped by Den Delimarsky.");
                        break;
                    }
            }
        }
    }
}

The first argument passed to the application is c for conversion. The second argument is the path to the text file that contains the concatenated Base64 strings. This, obviously, can be automated or be done manually. The third and last argument shows the output path.

The composite string is being broken down in chunks once again, and every single one of them is decode and written to a MemoryStream instance, that works well for byte array merging, especially in a situation where I am writing those sequentially.

The byte array obtained from MemoryStream is later saved to a file.

NOTE: jpg is used as a sample extension. It can be any other extension as long as the correct file format is being sent out.

This is more of a for-fun observation than a viable option for sending files. You might want to consider these choices for applications that go public:

send data to a web service that forwards the file to an email address
use a cloud storage system and upload files there directly
implement the email transmission protocol independently (think about System.Net.Mail)

TCP-based sockets on Windows Phone with support for large amounts of data

Sat, 24 Mar 2012 09:16:48 GMT

Network communication through sockets is a welcome addition to the Windows Phone platform. Personally, I enjoy using those because of the tremendous performance gain compared to WCF services. One topic, however, seems to be rarely covered when it comes to TCP-based communication between the server (presumably running on a desktop machine) and the client (Windows Phone) = transmission of large amounts of data.

A lot of existing samples assume that the communication, although bi-directional, is done with small data units. For example, here is a pretty good sample that I used to build the asynchronous server. The reading callback looks like this:

public static void readCallback(IAsyncResult ar) {
    StateObject state = (StateObject) ar.AsyncState;
    Socket handler = state.WorkSocket;

    // Read data from the client socket.
    int read = handler.EndReceive(ar);

    // Data was read from the client socket.
    if (read > 0) {
        state.sb.Append(
             Encoding.ASCII.GetString(state.buffer,0,read));
        handler.BeginReceive(state.buffer,0,
             StateObject.BufferSize, 0,
            new AsyncCallback(readCallback), state);
    } else {
        if (state.sb.Length > 1) {
            // All the data has been read from the client;
            // display it on the console.
            string content = state.sb.ToString();
            Console.WriteLine(content);
        }
        handler.Close();
    }
}

It works perfectly fine on the desktop machine. I am also adding a terminator verification statement that allows me to check whether the whole data set was received:

public void ReadCallback(IAsyncResult ar)
{
StateObject state = (StateObject)ar.AsyncState;
Socket handler = state.WorkSocket;

int bytesRead = handler.EndReceive(ar);

    if (bytesRead > 0)
    {
        string contentString =

Encoding.UTF8.GetString(state.buffer, 0, bytesRead);

        if (state.buffer[bytesRead - 1] != terminator[0])
        {
            state.ContentString.Append(contentString);
            handler.BeginReceive(state.buffer, 0, StateObject.BUFFER_SIZE,

0, new AsyncCallback(ReadCallback), state);
        }
        else
        {
            contentString = contentString.Replace(terminator, "");
            state.ContentString.Append(contentString);
        }
    }

}

Although seemingly simple, the data receiving process on a Windows Phone is handled in a different manner. There is no direct implementation of Socket.BeginReceive. Instead, developers work with Socket.ReceiveAsync. Many samples give you this piece of code:

public string Receive()
{
string response = "Operation Timeout";

    if (_socket != null)
    {
        SocketAsyncEventArgs socketEventArg = new SocketAsyncEventArgs();
        socketEventArg.RemoteEndPoint = _socket.RemoteEndPoint;
        socketEventArg.SetBuffer(new Byte[MAX_BUFFER_SIZE],

0, MAX_BUFFER_SIZE);

        socketEventArg.Completed +=
            new EventHandler<SocketAsyncEventArgs>
            (delegate(object s, SocketAsyncEventArgs e)
        {
            if (e.SocketError == SocketError.Success)
            {
                response = Encoding.UTF8.GetString(
                    e.Buffer, e.Offset, e.BytesTransferred);
                response = response.Trim('\0');
            }
            else
            {
                response = e.SocketError.ToString();
            }

clientDone.Set();
});

        clientDone.Reset();
        socket.ReceiveAsync(socketEventArg);
        clientDone.WaitOne(TIMEOUT_MILLISECONDS);
    }
    else
    {
        response = "Socket is not initialized";
    }

return response;
}

Notice the problem with this snippet. Once the string is received, that will be it. The inbound data length will be limited to the size of the buffer, and the maximum chunk size. The buffer size cannot always be fixed, and it is safe to assume that the developer does not want to allocate too much space for that in one iteration. The default socket chuck size cannot always be accommodated either.

The resolution comes in a continuous invocation of Socket.ReceiveAsync:

private void ProcessReceive(SocketAsyncEventArgs e)
{
    if (e.SocketError == SocketError.Success)
    {
        Socket sock = e.UserToken as Socket;
        string dataFromServer =

Encoding.UTF8.GetString(e.Buffer, 0, e.BytesTransferred);

        if (dataFromServer.EndsWith(terminator))
        {
            dataFromServer = dataFromServer.Replace(terminator, "");
            builder.Append(dataFromServer);

            sock.Shutdown(SocketShutdown.Send);
            sock.Close();
            clientDone.Set();

        }
        else
        {
            builder.Append(dataFromServer);
            sock.ReceiveAsync(e);
        }

    }
    else
    {
        clientDone.Set();
        throw new SocketException((int)e.SocketError);
    }
}

Here is where the terminator character plays a major role. Look at if (dataFromServer.EndsWith(terminator)) – that is the flag that shows whether more data is coming or not. With a receiving structure like I showed above, it is possible to keep receiving data until the connection is closed (happens all the time) or the terminator character is detected.

NOTE: If you are wondering what terminator character to use, try going with non-standard ones. For example, \u00BE. Otherwise, chances are that the actual “terminator” is not the terminating character.

Setting up a network capture box with Ubuntu and Wireshark

Fri, 23 Mar 2012 03:07:37 GMT

For a college project I had to set up an Ubuntu box and work on a network analysis assignment. I worked with this kind of tasks on Windows, and got some pretty interesting results by sniffing Windows Phone, Xbox and Windows 8 traffic with Wireshark. Ubuntu is a new environment for me, and I figured that the actual capture process is set a bit differently.

I downloaded Wireshark, but was greeted with this:

There are no interfaces I could capture data on. With a little research, I found out that it is, in fact, a built in restriction. When Wireshark is running outside the administrative sandbox, without root permissions, it won't allow the user to capture data on any of the registered network interfaces. So what are the options?

First and foremost it is still possible to use the dumpcap tool. Open the Terminal (Ctrl+ALT+T) and type in dumpcap -i NAME_OF_THE_INTERFACE. Depending on individual system configurations, there might be a different number of network interfaces. To make sure that you are capturing on the right one, use the ifconfig command. That will give you a list of registered interfaces.

In my case, the computer was connected to a wireless network, so I had to monitor the wlan0 interface.

The file that is captured is a PCAP-formatted entity, so it can be easily analyzed in Wireshark. A problem appeared when I tried to open the file, however.

When dumpcap was ran, it was elevated - remember the sudo prefix. This means that the file created will also be only accessible with elevated permissions. I ran Wireshark from the Terminal - sudo wireshark. I was able to read the file, as well as see the available capture interfaces:

This is one way to make capture easier, by the way. If you are absolutely sure about the people who are using a specific machine and want to enable capture without elevated permissions, run sudo dpkg-reconfigure wireshark-common. You will be prompted with a security dialog:

NOTE: Make sure you are aware of the security implications that come with this decision.

See me on Dream.In.Code TV - talking about my work as an admin

Tue, 20 Mar 2012 22:15:49 GMT

Last week I had a chance to be a part of a Dream.In.Code community event, specifically the Dream.In.Code TV. Andre Burdette, a good friend of mine, took the initiative of creating a show for an about the developer community he is a part of. He was kind enough to make me the first guest (ever), so I had to live up to some expectations from the viewers.

I discuss some of the behind-the-scenes aspects of my work as an admin, as well as some of my projects.

You can watch the recording of the live conversation here: